TypeScript paginated query type loses compile‑time size safety for array inputs

Direct answer

Enforce tuple-based input only when your callers already have tuple-typed data; otherwise the API becomes unusable for dynamic datasets. You cannot retain compile-time size safety for arbitrary runtime arrays without branded length types or explicit assertions. Accepting T[] is the pragmatic default, and a strict mode is justified only if it changes the accepted input type—for example, to tuples or branded arrays—rather than merely narrowing a generic parameter.

Likely explanation vs. confirmed behavior

Likely explanation: TypeScript erases literal length information at the assignment boundary. Once a value is typed as T[], the compiler no longer tracks how many elements it contains, so a Slice<T, N> utility falls back to T[].

Confirmed behavior: as const and variadic tuple inference preserve length for literal arrays and parameters inferred as tuples, but neither reverses widening for a value already declared as T[]. A branded length type such as ArrayWithLength<T, N> can encode the size, yet it requires explicit construction or runtime validation and does not make ordinary arrays safe automatically.

What to do for this case

1. Known literals: Use as const or variadic tuple inference so the Page type preserves the exact size.
2. Dynamic data: Accept T[] and return T[]. Move the guarantee to runtime validation: assert data.length === limit (or <= limit for the final page) before returning.
3. Strict mode: Add a separate overload or entry point that accepts only tuples or branded arrays. A flag that only narrows a generic parameter will not improve inference for callers passing number[].

Verification

Build a minimal repro and run tsc --noEmit:

type Page<T, N extends number> = {
  data: Slice<T, N>;
  limit: N;
};

declare function paginate<T, N extends number>(
  data: T,
  limit: N
): Page<T, N>;

const literal = [1, 2, 3] as const;
const dynamic: number[] = [1, 2, 3];

paginate(literal, 2); // data is a tuple
paginate(dynamic, 2); // data widens to number[]

Inspect the inferred type of data in both calls. The tuple case preserves length; the array case does not. If you adopt branded lengths, verify that constructing from a plain array requires an explicit assertion or runtime check and that mismatched lengths are rejected.

One missing detail

Which TypeScript version are you targeting? Inference for variadic tuples and const type parameters has improved across minor releases. If you are on an older version, some tuple-preserving patterns may not infer as expected, which would change whether a strict overload is worth the complexity.