ts-gems 3.12.0 → 4.0.0

package/docs/api/types.md

@@ -0,0 +1,238 @@
+# Base Types
+
+Source: [`lib/types.d.ts`](../../lib/types.d.ts)
+
+Foundational type aliases used throughout the rest of the library, and handy
+on their own.
+
+## `Primitive`
+
+```ts
+type Primitive = string | number | boolean | null | bigint | symbol | undefined;
+```
+
+```ts
+import type { Primitive } from 'ts-gems';
+
+function serialize(value: Primitive): string {
+  return String(value);
+}
+
+serialize('x'); // ok
+serialize({}); // type error - object is not a Primitive
+```
+
+## `Builtin`
+
+```ts
+type Builtin =
+  | Primitive
+  | Function
+  | String
+  | Number
+  | Date
+  | Error
+  | RegExp
+  | Buffer
+  | ArrayBuffer
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | URL
+  | ReadableStream
+  | WritableStream;
+```
+
+The set of JavaScript built-in types that the `Deep*`/`Deeper*` transform
+families (see [the root convention](../api.md#the-deep--deeper-convention))
+treat as **leaves** — never recursed into. Note that `Map`/`Set`/`WeakMap`/
+`WeakSet` are _not_ part of `Builtin`; those are excluded from deep
+processing separately (see [`IfNoDeepValue`](helpers.md#ifnodeepvaluet)).
+
+## `Type<T = any>`
+
+```ts
+interface Type<T = any> {
+  new (...args: any[]): T;
+}
+```
+
+Represents _a constructor_ whose instances are of type `T` — i.e. the value
+`SomeClass` itself (`typeof SomeClass`), not an instance of it.
+
+```ts
+import type { Type } from 'ts-gems';
+
+class User {
+  constructor(public name: string) {}
+}
+
+function createInstance<T>(ctor: Type<T>, ...args: any[]): T {
+  return new ctor(...args);
+}
+
+const user = createInstance(User, 'Ada'); // user: User
+```
+
+## `Class<Args, Instance, Static>`
+
+```ts
+type Class<Args extends any[] = any[], Instance = {}, Static = {}> = (new (
+  ...args: Args
+) => Instance) &
+  Static;
+```
+
+Like [`Type`](#typet--any), but additionally lets you describe the
+constructor's own (static) members and the exact constructor argument types.
+
+```ts
+import type { Class } from 'ts-gems';
+
+type UserClass = Class<[name: string], { name: string }, { table: string }>;
+
+declare const UserModel: UserClass;
+UserModel.table; // string - a static member
+new UserModel('Ada').name; // string - an instance member
+```
+
+## `Maybe<T>`
+
+```ts
+type Maybe<T> = T | undefined;
+```
+
+```ts
+import type { Maybe } from 'ts-gems';
+
+function greet(name: Maybe<string>) {
+  return `Hello, ${name ?? 'stranger'}`;
+}
+```
+
+## `Nullish<T = null>`
+
+```ts
+type Nullish<T = null> = T | undefined | null;
+```
+
+```ts
+import type { Nullish } from 'ts-gems';
+
+let value: Nullish<number>; // number | undefined | null
+```
+
+## `Awaited<T>`
+
+```ts
+type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
+```
+
+Unwraps a `Promise`/`PromiseLike`, or returns `T` unchanged if it isn't one.
+
+```ts
+import type { Awaited } from 'ts-gems';
+
+type A = Awaited<Promise<string>>; // string
+type B = Awaited<number>; // number
+```
+
+## `Thunk<T>` / `ThunkAsync<T>`
+
+```ts
+type Thunk<T> = T | (() => T);
+type ThunkAsync<T> = Thunk<T> | (() => Promise<T>);
+```
+
+A value, or a (possibly async) function that produces one — useful for
+lazily-computed configuration values.
+
+```ts
+import type { Thunk } from 'ts-gems';
+
+function resolveThunk<T>(thunk: Thunk<T>): T {
+  return typeof thunk === 'function' ? (thunk as () => T)() : thunk;
+}
+
+resolveThunk(42); // ok
+resolveThunk(() => 42); // ok
+```
+
+## `TypeThunk<T = any>` / `TypeThunkAsync<T = any>`
+
+```ts
+type TypeThunk<T = any> = Thunk<Type<T>>;
+type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
+```
+
+A [`Type<T>`](#typet--any) (a class reference), or a function that returns
+one — a common pattern for deferring circular class references (e.g. in
+decorator-based ORMs/DI containers).
+
+```ts
+import type { TypeThunk } from 'ts-gems';
+
+class Author {}
+
+const authorType: TypeThunk<Author> = () => Author;
+```
+
+## `MaybePromise<T>`
+
+```ts
+type MaybePromise<T> = T | Promise<T>;
+```
+
+```ts
+import type { MaybePromise } from 'ts-gems';
+
+async function run(fn: () => MaybePromise<number>): Promise<number> {
+  return fn();
+}
+```
+
+## `PropertyType<T, K>`
+
+```ts
+type PropertyType<T, K extends keyof T> = T[K];
+```
+
+An explicit, named alias for indexed access — mostly useful for documentation
+clarity or as a stable API when refactoring generic helpers.
+
+```ts
+import type { PropertyType } from 'ts-gems';
+
+interface User {
+  name: string;
+}
+
+type NameType = PropertyType<User, 'name'>; // string
+```
+
+## `ElementType<T, K>`
+
+```ts
+type ElementType<
+  T extends { [P in K & any]: any },
+  K extends keyof T | number,
+> = T[K];
+```
+
+Returns the element type of an array, tuple, or object at index/key `K`.
+
+```ts
+import type { ElementType } from 'ts-gems';
+
+type Tuple = [string, number];
+type First = ElementType<Tuple, 0>; // string
+
+type List = string[];
+type Item = ElementType<List, number>; // string
+```

package/docs/api.md

@@ -0,0 +1,113 @@
+<!--
+docs-baseline
+git-commit: bfe8777ee92aea1e8cacecfa8f68e297d4235c19
+package-version: 4.0.0
+date: 2026-09-09
+verified-against: lib/
+diff-command: git diff bfe8777ee92aea1e8cacecfa8f68e297d4235c19..HEAD -- lib/
+-->
+
+<p align="center">
+  <img src="logo.svg" alt="ts-gems logo" width="200" height="200" />
+</p>
+
+# API Documentation
+
+**ts-gems** is a pure TypeScript type-declaration library (no runtime code except
+twelve small `as*` cast helpers). It ships utility types for transforming,
+narrowing, and inspecting other types.
+
+```bash
+npm install ts-gems --save
+```
+
+```ts
+import { DeepPartial, DTO, StrictOmit } from 'ts-gems';
+```
+
+Every exported type is re-exported from the package root (`ts-gems`), so you
+never need to import from a sub-path. The pages below group the exports the
+same way the source does, one page per module.
+
+## Pages
+
+| Page                                   | Contents                                                                                                        |
+| -------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| [Type Guards](api/type-check.md)       | `IfAny`, `IfNever`, `IfEquals`, `IfCompatible`, `IfTuple`, `IfClass`, `IfObject`, and 15+ more `If*` predicates |
+| [Base Types](api/types.md)             | `Type`, `Class`, `Primitive`, `Builtin`, `Maybe`, `Nullish`, `Awaited`, `ElementType`, ...                      |
+| [Mutable](api/mutable.md)              | `Mutable`, `DeepMutable`, `DeeperMutable`, `MutableSome`, `PickMutable`, `OmitMutable`, ...                     |
+| [Readonly](api/readonly.md)            | `DeepReadonly`, `DeeperReadonly`, `ReadonlySome`, `PickReadonly`, `OmitReadonly`, ...                           |
+| [Partial](api/partial.md)              | `DeepPartial`, `DeeperPartial`, `PartialSome`, `PickOptional`, `OmitOptional`, ...                              |
+| [Required](api/required.md)            | `DeepRequired`, `DeeperRequired`, `RequiredSome`, `PickRequired`, `OmitRequired`, ...                           |
+| [Pick](api/pick.md)                    | `StrictPick`, `PickFunctions`, `PickTypes`, `StrictPickTypes`, `FunctionKeys`, ...                              |
+| [Omit](api/omit.md)                    | `StrictOmit`, `OmitFunctions`, `OmitTypes`, `DeepOmitTypes`, `DeeperOmitTypes`                                  |
+| [OmitNever](api/omit-never.md)         | `OmitNever`, `DeepOmitNever`, `DeeperOmitNever`                                                                 |
+| [OmitUndefined](api/omit-undefined.md) | `OmitUndefined`, `DeepOmitUndefined`, `DeeperOmitUndefined`                                                     |
+| [Nullish](api/nullish.md)              | `NullishObject`, `DeepNullish`, `DeeperNullish`                                                                 |
+| [UnNullish](api/non-nullable.md)       | `UnNullish`, `DeepUnNullish`, `DeeperUnNullish`                                                                 |
+| [DTO](api/dto.md)                      | `DTO`, `PartialDTO`, `PatchDTO`                                                                                 |
+| [Combine](api/combine.md)              | `Combine`                                                                                                       |
+| [Logical](api/logical.md)              | `And`, `Or`                                                                                                     |
+| [Opaque](api/opaque.md)                | `Opaque`                                                                                                        |
+| [Helpers](api/helpers.md)              | `IfNoDeepValue`, `ValuesOf`                                                                                     |
+
+## The `Deep*` / `Deeper*` convention
+
+Several families in this library (`Mutable`, `Readonly`, `Partial`, `Required`,
+`Nullish`, `UnNullish`, `OmitNever`, `OmitUndefined`, `OmitTypes`, `DTO`) come
+in three strengths. Read this once — every page below assumes it:
+
+| Variant   | Recurses into nested objects? | Recurses into array elements?                 |
+| --------- | ----------------------------- | --------------------------------------------- |
+| _(base)_  | No — shallow, top level only  | No                                            |
+| `Deep*`   | Yes                           | No — array-typed properties are left as-is    |
+| `Deeper*` | Yes                           | Yes — array element types are transformed too |
+
+**Leaf types are never recursed into**, by any variant, including `Deeper*`.
+A property is treated as a leaf (left untouched) when its type is:
+
+- a primitive (`string`, `number`, `boolean`, `bigint`, `symbol`, `null`, `undefined`)
+- `any`
+- a `Function` or a constructor/class reference (e.g. `typeof SomeClass`, `Type<T>`)
+- `Map`, `ReadonlyMap`, `WeakMap`, `Set`, `ReadonlySet`, or `WeakSet`
+- a **tuple** (`[string, number]`, `[]`, etc.) — a fixed-length array is left
+  exactly as-is, even by `Deeper*` variants. Only _variable-length_ arrays
+  (`T[]` or `readonly T[]`) have their element type transformed.
+- a `Date`, `RegExp`, or any other `Builtin` (see [Base Types](api/types.md#builtin))
+
+Both mutable (`T[]`) and readonly (`readonly T[]`) variable-length arrays are
+recognized the same way. A `Deeper*` variant that transforms a `readonly T[]`
+property always rebuilds it as a plain `T[]` — only the _element_ type's
+readonly-ness (or lack of it) is guaranteed by the transform, not the
+wrapper's; see the note on [`DeeperReadonly`](api/readonly.md#deeperreadonlyt).
+
+```ts
+import type { DeeperReadonly } from 'ts-gems';
+
+type Config = {
+  name: string;
+  address: { city: string }[]; // plain array -> element type IS transformed
+  range: [number, number]; // tuple -> left untouched, even by Deeper*
+};
+
+type ReadonlyConfig = DeeperReadonly<Config>;
+// {
+//   readonly name: string;
+//   readonly address: { readonly city: string }[]; // element type made readonly
+//   readonly range: [number, number]; // unchanged shape
+// }
+```
+
+## Naming patterns used across pages
+
+- **`Pick*` / `Omit*`** — select or remove properties matching some criterion
+  (readonly-ness, required-ness, function-ness, type match, ...).
+- **`Strict*`** — a stricter variant of a `Pick`/`Omit` type that also excludes
+  `unknown`, `any`, and `{}` from matching, and requires an exact key
+  (`X extends keyof T`) rather than an arbitrary type.
+- **`*Some<T, K>`** — apply a transform to only the properties named in `K`,
+  leaving the rest of `T` untouched (e.g. `MutableSome<T, 'a' | 'b'>`).
+- **`*Keys<T>`** — returns the union of keys matching some criterion
+  (`keyof Pick*<T>`, purely for convenience).
+
+See each page for full signatures, descriptions and runnable examples.

package/docs/logo.svg

@@ -0,0 +1,43 @@
+<svg version="1.1" id="fi_919832" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 512 512" style="enable-background:new 0 0 512 512;">
+  <defs></defs>
+  <g id="fi_2546715" transform="matrix(0.999975, 0, 0, 0.999975, -188.837326, 635.496765)" style="">
+    <g transform="matrix(1, 0, 0, 1, 189.628876, -636.415588)">
+      <path d="m492.561 158.013c-25.95-62.577-75.997-112.625-138.574-138.574l-157.987 236.561 157.987 236.561c62.577-25.949 112.625-75.997 138.574-138.574z" fill="#ba1956"></path>
+      <g fill="#ff0f47">
+        <path d="m492.561 158.013-236.561 97.987 236.561 97.987c12.517-30.185 19.439-63.276 19.439-97.987 0-34.712-6.922-67.802-19.439-97.987z"></path>
+        <path d="m353.987 19.439c-30.185-12.517-63.275-19.439-97.987-19.439l-60 256 60 256c34.712 0 67.802-6.922 97.987-19.439l-97.987-236.561z"></path>
+        <path d=""></path>
+        <path d="m158.013 19.439c-62.576 25.95-112.624 75.998-138.574 138.574v195.973c25.949 62.577 75.997 112.625 138.574 138.574h77.987l20-236.56-20-236.561z"></path>
+      </g>
+      <path d="m158.013 492.561c30.185 12.517 63.276 19.439 97.987 19.439v-256z" fill="#ff415d"></path>
+      <path d="m256 0c-34.711 0-67.802 6.922-97.987 19.439l97.987 236.561z" fill="#ff415d"></path>
+      <path d="m19.439 158.013c-12.517 30.185-19.439 63.275-19.439 97.987 0 34.711 6.922 67.802 19.439 97.987l236.561-97.987z" fill="#ff415d"></path>
+      <path d="m312.333 120h-56.333l-60 136 60 136h56.333l79.667-79.667v-112.666z" fill="#ff415d"></path>
+      <path d="m199.667 120-79.667 79.667v112.666l79.667 79.667h56.333v-272z" fill="#ff7472"></path>
+    </g>
+  </g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g></g>
+  <g>
+    <path style="fill:#F2F2F2;" d="M503.16,322.936c-13.479,49.894-41.66,93.748-79.621,126.631c-3.709,0.199-7.586,0.293-11.609,0.293
+		c-53.154,0-82.693-33.217-97.374-58.138l48.191-28.954c0,0,16.394,34.837,47.125,34.837c30.741,0,43.039-10.25,43.039-33.813
+		c0-28.693-99.391-38.933-114.761-88.116c-15.37-49.183,5.12-118.868,76.852-113.737c44.826,3.197,70.04,25.213,82.651,41.273
+		l-47.815,34.544c-10.25-29.706-52.255-29.706-60.458-5.12c-8.192,24.597,19.466,38.933,62.506,53.279
+		C473.997,293.282,491.781,306.876,503.16,322.936z"></path>
+    <polygon style="fill:#F2F2F2;" points="300.943,169.786 83.106,169.786 83.106,221.202 162.935,221.202 162.935,444.45
+		221.115,444.45 221.115,221.202 300.943,221.202 	"></polygon>
+  </g>
+</svg>

package/lib/dto.d.ts

@@ -1,24 +1,26 @@
 import { IfNoDeepValue } from './helpers.js';
 import { DeeperNullish } from './nullish.js';
 import { DeeperPartial } from './partial.js';
-import { IfNever } from './type-check.js';
+import { IfNever, IfTuple } from './type-check.js';
 
 /**
  * Returns the given type as a Data Transfer Object (DTO) interface, Removes symbol keys and function properties.
  * @template T - The type of the data being transferred.
  */
 export type DTO<T, X = never> = {
-  [K in keyof T as IfNever<
-    Exclude<NonNullable<T[K]>, Function | symbol>,
-    never,
-    K
-  >]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
-    ? DTO<U>[]
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? NonNullable<T[K] | X>
-      : // Deep process objects
-        DTO<NonNullable<T[K] | X>>;
+  [
+    K in keyof T as K extends symbol
+      ? never
+      : IfNever<Exclude<NonNullable<T[K]>, Function | symbol>, never, K>
+  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
+    ? NonNullable<T[K] | X>
+    : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
+      ? DTO<U>[]
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<NonNullable<T[K]>> extends true
+        ? NonNullable<T[K] | X>
+        : // Deep process objects
+          DTO<NonNullable<T[K] | X>>;
 };
 
 export type PartialDTO<T, X = never> = DeeperPartial<DTO<T, X>>;

package/lib/helpers.d.ts

@@ -4,31 +4,32 @@ import { Builtin } from './types.js';
 /**
  * Returns true if T is excluded from deep operations
  */
-export type IfNoDeepValue<T> = T extends Builtin
-  ? true
-  : IfAny<T> extends true
-    ? T
-    : IfTuple<T> extends true
+export type IfNoDeepValue<T> =
+  IfAny<T> extends true
+    ? true
+    : T extends Builtin
       ? true
-      : T extends Function
+      : IfTuple<T> extends true
         ? true
-        : IfClass<T> extends true
+        : T extends Function
           ? true
-          : T extends Map<any, any>
+          : IfClass<T> extends true
             ? true
-            : T extends ReadonlyMap<any, any>
+            : T extends Map<any, any>
               ? true
-              : T extends WeakMap<any, any>
+              : T extends ReadonlyMap<any, any>
                 ? true
-                : T extends Set<any>
+                : T extends WeakMap<any, any>
                   ? true
-                  : T extends ReadonlySet<any>
+                  : T extends Set<any>
                     ? true
-                    : T extends WeakSet<any>
+                    : T extends ReadonlySet<any>
                       ? true
-                      : T extends any[]
+                      : T extends WeakSet<any>
                         ? true
-                        : false;
+                        : T extends readonly any[]
+                          ? true
+                          : false;
 
 /**
  * ValuesOf

package/lib/mutable.d.ts

@@ -7,7 +7,7 @@ import {
   OmitReadonly,
   PickReadonly,
 } from './readonly.js';
-import { IfNever } from './type-check.js';
+import { IfNever, IfTuple } from './type-check.js';
 
 /**
  * Make all properties in T mutable
@@ -26,11 +26,9 @@ export type MutableSome<T, K extends keyof T> = Mutable<Pick<T, K>> &
  * Make all properties in T mutable deeply
  */
 export type DeepMutable<T> = {
-  -readonly [K in keyof T as IfNever<
-    Exclude<T[K], undefined>,
-    never,
-    K
-  >]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+  -readonly [
+    K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>
+  ]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
     ? T[K]
     : // Deep process objects
       DeepMutable<NonNullable<T[K]>>;
@@ -40,17 +38,17 @@ export type DeepMutable<T> = {
  * Make all properties in T mutable deeply
  */
 export type DeeperMutable<T> = {
-  -readonly [K in keyof T as IfNever<
-    Exclude<T[K], undefined>,
-    never,
-    K
-  >]: NonNullable<T[K]> extends (infer U)[] // Deep process arrays
-    ? DeeperMutable<U>[]
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? T[K]
-      : // Deep process objects
-        DeeperMutable<NonNullable<T[K]>>;
+  -readonly [
+    K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>
+  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
+    ? T[K]
+    : NonNullable<T[K]> extends readonly (infer U)[] // Deep process arrays
+      ? DeeperMutable<U>[]
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<NonNullable<T[K]>> extends true
+        ? T[K]
+        : // Deep process objects
+          DeeperMutable<NonNullable<T[K]>>;
 };
 
 /**

package/lib/non-nullable.d.ts

@@ -1,26 +1,30 @@
 import { IfNoDeepValue } from './helpers.js';
-import { IfNever, IfNull } from './type-check.js';
+import { IfNever, IfNull, IfTuple } from './type-check.js';
 
 /**
- * Exclude null and undefined from T deeply
+ * Exclude null and undefined from T
  */
 export type UnNullish<T> = {
-  [K in keyof T as IfNever<
-    Exclude<T[K], undefined>,
-    never,
-    IfNull<Exclude<T[K], undefined>, never, K>
-  >]: NonNullable<T[K]>;
+  [
+    K in keyof T as IfNever<
+      Exclude<T[K], undefined>,
+      never,
+      IfNull<Exclude<T[K], undefined>, never, K>
+    >
+  ]: NonNullable<T[K]>;
 };
 
 /**
  * Exclude null and undefined from T deeply
  */
 export type DeepUnNullish<T> = {
-  [K in keyof T as IfNever<
-    Exclude<T[K], undefined>,
-    never,
-    IfNull<Exclude<T[K], undefined>, never, K>
-  >]: IfNoDeepValue<
+  [
+    K in keyof T as IfNever<
+      Exclude<T[K], undefined>,
+      never,
+      IfNull<Exclude<T[K], undefined>, never, K>
+    >
+  ]: IfNoDeepValue<
     // Do not deep process No-Deep values
     Exclude<T[K], undefined>
   > extends true
@@ -33,15 +37,19 @@ export type DeepUnNullish<T> = {
  * Exclude null and undefined from T deeply including arrays
  */
 export type DeeperUnNullish<T> = {
-  [K in keyof T as IfNever<
-    Exclude<T[K], undefined>,
-    never,
-    IfNull<Exclude<T[K], undefined>, never, K>
-  >]: NonNullable<NonNullable<T[K]>> extends (infer U)[]
-    ? DeeperUnNullish<U>[]
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? NonNullable<T[K]>
-      : // Deep process objects
-        DeeperUnNullish<NonNullable<T[K]>>;
+  [
+    K in keyof T as IfNever<
+      Exclude<T[K], undefined>,
+      never,
+      IfNull<Exclude<T[K], undefined>, never, K>
+    >
+  ]: IfTuple<NonNullable<T[K]>> extends true // Leave fixed-length tuples untouched
+    ? NonNullable<T[K]>
+    : NonNullable<NonNullable<T[K]>> extends readonly (infer U)[]
+      ? DeeperUnNullish<U>[]
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<NonNullable<T[K]>> extends true
+        ? NonNullable<T[K]>
+        : // Deep process objects
+          DeeperUnNullish<NonNullable<T[K]>>;
 };

package/lib/nullish.d.ts

@@ -1,5 +1,5 @@
 import { IfNoDeepValue } from './helpers.js';
-import { IfNever } from './type-check.js';
+import { IfNever, IfTuple } from './type-check.js';
 
 /**
  * Make all properties in T nullish
@@ -25,14 +25,18 @@ export type DeepNullish<T> = {
  * Make all properties in T nullish deeply including arrays
  */
 export type DeeperNullish<T> = {
-  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: NonNullable<
-    // Deep process arrays
-    T[K]
-  > extends (infer U)[]
-    ? DeeperNullish<U>[] | null
-    : // Do not deep process No-Deep values
-      IfNoDeepValue<NonNullable<T[K]>> extends true
-      ? T[K] | null
-      : // Deep process objects
-        DeeperNullish<NonNullable<T[K]>> | null;
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: IfTuple<
+    NonNullable<T[K]>
+  > extends true // Leave fixed-length tuples untouched
+    ? T[K] | null
+    : NonNullable<
+          // Deep process arrays
+          T[K]
+        > extends readonly (infer U)[]
+      ? DeeperNullish<U>[] | null
+      : // Do not deep process No-Deep values
+        IfNoDeepValue<NonNullable<T[K]>> extends true
+        ? T[K] | null
+        : // Deep process objects
+          DeeperNullish<NonNullable<T[K]>> | null;
 };