type MinusOne<T extends number, Tuple extends unknown[] = []> =
  T extends 0
    ? -1
    : [unknown, ...Tuple]['length'] extends T
      ? Tuple['length']
      : MinusOne<T, [unknown, ...Tuple]>

type MinusOne<T extends number, Tuple extends unknown[] = []> =
  T extends 0
    ? -1
    : [unknown, unknown, ...Tuple]['length'] extends T
      ? [unknown, ...Tuple]['length']
      : [unknown, ...Tuple]['length'] extends T
        ? Tuple['length']
        : MinusOne<T, [unknown, unknown, ...Tuple]>

// normal tuple of given size with linear complexity
type Tuple<L extends number, T extends unknown[] = []> = T["length"] extends L
  ? T
  : Tuple<L, [...T, unknown]>;

// find the tuple of given size between From and To tuples
// if not found, return never
type FromToTuple<L extends number, From extends unknown[] = [], To extends unknown[] = []> = From['length'] extends L
  ? From
  : From['length'] extends To['length']
    ? never
    : FromToTuple<L, [unknown, ...From], To>

// prepare a tuple as increament of each recursion
type TupleMax = Tuple<999>

// build a tuple of given size
// it use a large step in each recursion, so it can reach the target with less recursions
type SuperTuple<L extends number, C extends unknown[] = [], P extends unknown[] = []> = C["length"] extends L
  ? C
  : FromToTuple<L, P, C> extends never
    ? SuperTuple<L, [...TupleMax, ...C], C>
    : FromToTuple<L, P, C>

// this is just a middle abstraction to make the final algorithm more clear
type Minus<A extends number, B extends number> = SuperTuple<A> extends [ ...SuperTuple<B>, ... infer R extends unknown[]] ? R['length'] : never

type MinusOne<T extends number> =
  T extends 0
    ? -1
    : Minus<T, 1>