```ts
/**
 * Processes calls with time-based quotas.
 * @param limit - The maximum number of times a name can be served in a frame.
 * @param width - The duration of each frame.
 * @param calls - Array of [time, name] pairs representing call arrivals.
 * @returns An array of "ok" or "over" corresponding to each call's status.
 */
export function windowQuota(limit: number, width: number, calls: (string | number)[][]): string[] {
  if (!Number.isPositiveInteger(limit)) throw new Error("Limit must be a positive integer.");
  if (!Number.isPositiveInteger(width)) throw new Error("Width must be a positive integer.");

  const result: string[] = [];
  const frameCalls: Map<number, Map<string, number>> = new Map();

  for (let i = 0; i < calls.length; i++) {
    const [time, name] = calls[i];

    if (!Number.isInteger(time) || time < 0) throw new Error("Time must be a non-negative integer.");
    if (typeof name !== "string" || name.trim() === "") throw new Error("Name must be a non-empty string.");

    if (i > 0 && time < calls[i - 1][0]) {
      throw new Error("Calls must arrive in non-decreasing order of time.");
    }

    const frameNumber = Math.floor(time / width);

    if (!frameCalls.has(frameNumber)) {
      frameCalls.set(frameNumber, new Map());
    }

    const nameCalls = frameCalls.get(frameNumber)!;

    if (!nameCalls.has(name)) {
      nameCalls.set(name, 0);
    }

    const count = nameCalls.get(name)! + 1;

    if (count <= limit) {
      result.push("ok");
      nameCalls.set(name, count);
    } else {
      result.push("over");
    }
  }

  return result;
}
```