type Tuple<N extends number, T extends unknown[] = []> = T["length"] extends N ? T : Tuple<N, [...T, 0]>;
type Assert<T, E> = T extends E ? T : never;
type IntToStr<A extends string | number | bigint> = `${A}` extends `${infer L extends number}` ? `${L}` : never;
type Reverse<T extends string, Acc extends string = ""> = T extends `${infer L}${infer R}` ? Reverse<R, `${L}${Acc}`> : `${T}${Acc}`;

type SumDigit<A extends number, B extends number, C extends number = 0, Acc extends unknown[] = [...Tuple<A>, ...Tuple<B>, ...Tuple<C>]> =
  Acc extends [...Tuple<10>, ...infer Rest]
  ? { digit: Rest["length"], carry: 1 }
  : { digit: Acc["length"], carry: 0 };

type SumImpl<A extends string, B extends string, C extends number = 0, Acc extends string = ""> =
  A extends `${infer A1 extends number}${infer ARest}`
    ? B extends `${infer B1 extends number}${infer BRest}`
      ? SumImpl<ARest, BRest, SumDigit<A1, B1, C>["carry"], `${Acc}${Assert<SumDigit<A1, B1, C>["digit"], number>}`>
    : SumImpl<ARest, "", SumDigit<A1, 0, C>["carry"], `${Acc}${Assert<SumDigit<A1, 0, C>["digit"], number>}`>
  : B extends `${infer B1 extends number}${infer BRest}`
    ? SumImpl<"", BRest, SumDigit<0, B1, C>["carry"], `${Acc}${Assert<SumDigit<0, B1, C>["digit"], number>}`>
  : `${Acc}${C extends 1 ? "1" : ""}`;

type Sum<A extends string | number | bigint, B extends string | number | bigint> =
  Reverse<SumImpl<Reverse<IntToStr<A>>, Reverse<IntToStr<B>>>>;

import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<Sum<2, 3>, '5'>>,
  Expect<Equal<Sum<'13', '21'>, '34'>>,
  Expect<Equal<Sum<'328', 7>, '335'>>,
  Expect<Equal<Sum<1_000_000_000_000n, '123'>, '1000000000123'>>,
  Expect<Equal<Sum<9999, 1>, '10000'>>,
  Expect<Equal<Sum<4325234, '39532'>, '4364766'>>,
  Expect<Equal<Sum<728, 0>, '728'>>,
  Expect<Equal<Sum<'0', 213>, '213'>>,
  Expect<Equal<Sum<0, '0'>, '0'>>,
]