```ts
/**
 * Returns an array of the maximum value in every contiguous window of size k.
 * Uses a deque to maintain indices of potential maxima in O(n) time.
 * @param nums - Array of numbers to process
 * @param k - Size of the sliding window (must be between 1 and nums.length inclusive)
 * @returns Array of maximum values for each window position
 */
export function maxSlidingWindow(nums: number[], k: number): number[] {
    if (!Array.isArray(nums) || typeof k !== 'number' || !Number.isInteger(k)) {
        throw new Error('Invalid arguments: nums must be an array and k must be an integer');
    }
    
    if (k < 1 || k > nums.length) {
        throw new Error('k must be between 1 and the length of nums');
    }
    
    if (nums.length === 0) {
        throw new Error('nums must not be empty');
    }
    
    const result: number[] = [];
    const deque: number[] = []; // stores indices of elements in decreasing order
    
    for (let i = 0; i < nums.length; i++) {
        // Remove indices that are out of the current window
        while (deque.length > 0 && deque[0] <= i - k) {
            deque.shift();
        }
        
        // Remove indices of elements smaller than current element
        while (deque.length > 0 && nums[deque[deque.length - 1]] <= nums[i]) {
            deque.pop();
        }
        
        // Add current index
        deque.push(i);
        
        // Add maximum for the window when we've processed at least k elements
        if (i >= k - 1) {
            result.push(nums[deque[0]]);
        }
    }
    
    return result;
}
```