```python
import heapq

class Solution:
    """
    This class is designed to solve the "smallest range" problem.
    The prompt requires a specific __init__ method, which is used here
    to make instances of this class act as nodes in a min-heap.
    The main logic is encapsulated in the `smallestRange` static method.
    """
    
    # Required function signature as per the task description.
    def __init__(self, value, list_num, index):
        self.value = value
        self.list_num = list_num
        self.index = index

    # Comparison method to allow instances to be used in a min-heap.
    def __lt__(self, other):
        return self.value < other.value

    @staticmethod
    def smallestRange(nums):
        """
        Finds the smallest range that includes at least one element from each list.
        """
        if not nums:
            return []

        min_heap = []
        max_val = -float('inf')
        
        # Initialize the heap with the first element from each list.
        for i, lst in enumerate(nums):
            if not lst:
                # If any list is empty, no range can cover all lists.
                return []
            
            value = lst[0]
            heapq.heappush(min_heap, Solution(value, i, 0))
            max_val = max(max_val, value)

        min_range_size = float('inf')
        range_start = 0
        range_end = 0

        # The loop continues as long as we can form a valid range.
        while min_heap:
            # Pop the element with the minimum value.
            node = heapq.heappop(min_heap)
            min_val = node.value
            
            # Check if the current range [min_val, max_val] is the smallest.
            current_range_size = max_val - min_val
            if current_range_size < min_range_size:
                min_range_size = current_range_size
                range_start = min_val
                range_end = max_val
            elif current_range_size == min_range_size and min_val < range_start:
                # Tie-breaking: choose the range with the smaller start value.
                range_start = min_val
                range_end = max_val
            
            list_idx = node.list_num
            element_idx = node.index

            # If there's a next element in the list from which we popped.
            if element_idx + 1 < len(nums[list_idx]):
                next_element_idx = element_idx + 1
                next_val = nums[list_idx][next_element_idx]
                
                # Push the next element to the heap.
                heapq.heappush(min_heap, Solution(next_val, list_idx, next_element_idx))
                
                # Update the maximum value in our current window.
                max_val = max(max_val, next_val)
            else:
                # If any list is exhausted, we can no longer find a valid range.
                break
        
        return [range_start, range_end]
```