```typescript
/**
 * Merges overlapping intervals in a list of [start, end] pairs into non-overlapping pairs,
 * where touching intervals are merged. The resulting intervals are sorted ascending by start.
 *
 * @param intervals - A list of [start, end] pairs to be merged.
 *
 * @returns A fresh list of non-overlapping [start, end] pairs covering the same points, sorted ascending by start.
 */
export function mergeIntervals(intervals: number[][]): number[][] {
  if (!intervals || !Array.isArray(intervals) || intervals.length === 0) {
    return [];
  }

  // Filter out intervals with invalid "start" values
  const validIntervals = intervals.filter(([start, end]) => {
    if (typeof start !== 'number' || typeof end !== 'number') {
      throw new Error('Start and end of an interval must be numbers');
    }
    return start <= end;
  });

  // Sort the valid intervals by "start"
  const sortedIntervals = validIntervals.sort((a, b) => a[0] - b[0]);

  const mergedIntervals: number[][] = [sortedIntervals[0]];
  
  for (const currentInterval of sortedIntervals.slice(1)) {
    // Get the last interval in the list
    const lastMergedInterval = mergedIntervals[mergedIntervals.length - 1];
    
    // If the starting point of the current interval is less than or equal to 
    // the end of the last merged interval, merge them
    if (currentInterval[0] <= lastMergedInterval[1]) {
      // Update the end point of the last merged interval
      mergedIntervals[mergedIntervals.length - 1][1] = Math.max(lastMergedInterval[1], currentInterval[1]);
    } else {
      // Add the current interval to the list of merged intervals
      mergedIntervals.push(currentInterval);
    }
  }

  return mergedIntervals;
}
```