```python
def region_totals(grid: list, queries: list) -> list:
    """
    Calculate the sum of cells in each specified query block of a grid.

    :param grid: A non-empty list of rows, where each row is a non-empty list of integers.
    :param queries: A list of four-integer lists [top, left, bottom, right] defining query blocks.
    :return: A list of sums for each query block in the order they appear.
    """
    if not grid or not grid[0]:
        raise ValueError("Grid must have at least one row with at least one cell.")
    
    rows_length = len(grid)
    columns_length = len(grid[0])
    
    # Check that all rows are of the same length
    for i in range(1, rows_length):
        if len(grid[i]) != columns_length:
            raise ValueError("All rows must have the same number of cells.")
    
    def is_integer(value: any) -> bool:
        return isinstance(value, int)
    
    # Validate each query
    valid_queries = []
    for query in queries:
        if not (isinstance(query, list) and len(query) == 4):
            raise ValueError("Each query must be a list of exactly four integers.")
        
        top, left, bottom, right = query
        
        if top >= bottom or left >= right:
            raise ValueError("Query bounds must satisfy top < bottom and left < right.")
        
        if not is_integer(top) or not is_integer(left) or not is_integer(bottom) or not is_integer(right):
            raise ValueError("All query dimensions must be integers.")
        
        if top < 0 or left < 0 or bottom > rows_length or right > columns_length:
            raise ValueError("Query bounds must be within the grid boundaries.")
        
        valid_queries.append(query)
    
    # Build a prefix-sum table
    prefix_sum = [[0] * (columns_length + 1) for _ in range(rows_length + 1)]
    
    for i in range(1, rows_length + 1):
        for j in range(1, columns_length + 1):
            prefix_sum[i][j] = grid[i-1][j-1] + prefix_sum[i-1][j] + prefix_sum[i][j-1] - prefix_sum[i-1][j-1]
    
    # Calculate block totals from the prefix-sum table
    totals = []
    for query in valid_queries:
        top, left, bottom, right = query
        total = prefix_sum[bottom][right] - prefix_sum[top][right] - prefix_sum[bottom][left] + prefix_sum[top][left]
        totals.append(total)
    
    return totals
```