ts-data-forge 6.8.0 → 6.9.0

package/src/number/branded-types/positive-uint16.test.mts

@@ -9,45 +9,45 @@ import {
 describe('PositiveUint16 test', () => {
   describe(asPositiveUint16, () => {
     test('accepts valid positive uint16 values', () => {
-      expect(() => asPositiveUint16(1)).not.toThrowError();
+      expect(() => asPositiveUint16(1)).not.toThrow();
 
-      expect(() => asPositiveUint16(1000)).not.toThrowError();
+      expect(() => asPositiveUint16(1000)).not.toThrow();
 
-      expect(() => asPositiveUint16(65_535)).not.toThrowError(); // 2^16 - 1
+      expect(() => asPositiveUint16(65_535)).not.toThrow(); // 2^16 - 1
 
-      expect(() => asPositiveUint16(32_768)).not.toThrowError(); // 2^15
+      expect(() => asPositiveUint16(32_768)).not.toThrow(); // 2^15
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveUint16(0)).toThrowError(TypeError);
+      expect(() => asPositiveUint16(0)).toThrow(TypeError);
     });
 
     test('rejects values outside uint16 range', () => {
-      expect(() => asPositiveUint16(65_536)).toThrowError(TypeError); // 2^16
+      expect(() => asPositiveUint16(65_536)).toThrow(TypeError); // 2^16
 
-      expect(() => asPositiveUint16(100_000)).toThrowError(TypeError);
+      expect(() => asPositiveUint16(100_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveUint16(-1)).toThrowError(TypeError);
+      expect(() => asPositiveUint16(-1)).toThrow(TypeError);
 
-      expect(() => asPositiveUint16(-42)).toThrowError(TypeError);
+      expect(() => asPositiveUint16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveUint16(Number.NaN)).toThrowError(TypeError);
+      expect(() => asPositiveUint16(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asPositiveUint16(Number.POSITIVE_INFINITY)).toThrowError(
+      expect(() => asPositiveUint16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asPositiveUint16(Number.NEGATIVE_INFINITY)).toThrowError(
+      expect(() => asPositiveUint16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asPositiveUint16(1.2)).toThrowError(TypeError);
+      expect(() => asPositiveUint16(1.2)).toThrow(TypeError);
 
-      expect(() => asPositiveUint16(-3.4)).toThrowError(TypeError);
+      expect(() => asPositiveUint16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -70,7 +70,7 @@ describe('PositiveUint16 test', () => {
     ] as const)(
       `asPositiveUint16($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveUint16(value)).toThrowError(
+        expect(() => asPositiveUint16(value)).toThrow(
           new TypeError(
             `Expected a positive integer in [1, 2^16), got: ${value}`,
           ),

package/src/number/branded-types/positive-uint32.test.mts

@@ -9,45 +9,45 @@ import {
 describe('PositiveUint32 test', () => {
   describe(asPositiveUint32, () => {
     test('accepts valid positive uint32 values', () => {
-      expect(() => asPositiveUint32(1)).not.toThrowError();
+      expect(() => asPositiveUint32(1)).not.toThrow();
 
-      expect(() => asPositiveUint32(1000)).not.toThrowError();
+      expect(() => asPositiveUint32(1000)).not.toThrow();
 
-      expect(() => asPositiveUint32(4_294_967_295)).not.toThrowError(); // 2^32 - 1
+      expect(() => asPositiveUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
 
-      expect(() => asPositiveUint32(2_147_483_648)).not.toThrowError(); // 2^31
+      expect(() => asPositiveUint32(2_147_483_648)).not.toThrow(); // 2^31
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveUint32(0)).toThrowError(TypeError);
+      expect(() => asPositiveUint32(0)).toThrow(TypeError);
     });
 
     test('rejects values outside uint32 range', () => {
-      expect(() => asPositiveUint32(4_294_967_296)).toThrowError(TypeError); // 2^32
+      expect(() => asPositiveUint32(4_294_967_296)).toThrow(TypeError); // 2^32
 
-      expect(() => asPositiveUint32(10_000_000_000)).toThrowError(TypeError);
+      expect(() => asPositiveUint32(10_000_000_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveUint32(-1)).toThrowError(TypeError);
+      expect(() => asPositiveUint32(-1)).toThrow(TypeError);
 
-      expect(() => asPositiveUint32(-42)).toThrowError(TypeError);
+      expect(() => asPositiveUint32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveUint32(Number.NaN)).toThrowError(TypeError);
+      expect(() => asPositiveUint32(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asPositiveUint32(Number.POSITIVE_INFINITY)).toThrowError(
+      expect(() => asPositiveUint32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asPositiveUint32(Number.NEGATIVE_INFINITY)).toThrowError(
+      expect(() => asPositiveUint32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asPositiveUint32(1.2)).toThrowError(TypeError);
+      expect(() => asPositiveUint32(1.2)).toThrow(TypeError);
 
-      expect(() => asPositiveUint32(-3.4)).toThrowError(TypeError);
+      expect(() => asPositiveUint32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -70,7 +70,7 @@ describe('PositiveUint32 test', () => {
     ] as const)(
       `asPositiveUint32($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveUint32(value)).toThrowError(
+        expect(() => asPositiveUint32(value)).toThrow(
           new TypeError(
             `Expected a positive integer in [1, 2^32), got: ${value}`,
           ),

package/src/number/branded-types/safe-int.test.mts

@@ -5,45 +5,41 @@ import { asSafeInt, SafeInt } from './safe-int.mjs';
 describe('SafeInt test', () => {
   describe(asSafeInt, () => {
     test('accepts valid safe integers', () => {
-      expect(() => asSafeInt(0)).not.toThrowError();
+      expect(() => asSafeInt(0)).not.toThrow();
 
-      expect(() => asSafeInt(1)).not.toThrowError();
+      expect(() => asSafeInt(1)).not.toThrow();
 
-      expect(() => asSafeInt(-1)).not.toThrowError();
+      expect(() => asSafeInt(-1)).not.toThrow();
 
-      expect(() => asSafeInt(42)).not.toThrowError();
+      expect(() => asSafeInt(42)).not.toThrow();
 
-      expect(() => asSafeInt(-42)).not.toThrowError();
+      expect(() => asSafeInt(-42)).not.toThrow();
 
-      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
 
-      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects values outside safe integer range', () => {
-      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrowError(
-        TypeError,
-      );
+      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(TypeError);
 
-      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrowError(
-        TypeError,
-      );
+      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrow(TypeError);
 
-      expect(() => asSafeInt(Number.MAX_VALUE)).toThrowError(TypeError);
+      expect(() => asSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
 
-      expect(() => asSafeInt(-Number.MAX_VALUE)).toThrowError(TypeError);
+      expect(() => asSafeInt(-Number.MAX_VALUE)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asSafeInt(Number.NaN)).toThrowError(TypeError);
+      expect(() => asSafeInt(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asSafeInt(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asSafeInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asSafeInt(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asSafeInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asSafeInt(1.2)).toThrowError(TypeError);
+      expect(() => asSafeInt(1.2)).toThrow(TypeError);
 
-      expect(() => asSafeInt(-3.4)).toThrowError(TypeError);
+      expect(() => asSafeInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -65,7 +61,7 @@ describe('SafeInt test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asSafeInt($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asSafeInt(value)).toThrowError(
+      expect(() => asSafeInt(value)).toThrow(
         new TypeError(`Expected a safe integer, got: ${value}`),
       );
     });

package/src/number/branded-types/safe-uint.test.mts

@@ -5,47 +5,41 @@ import { asSafeUint, isSafeUint, SafeUint } from './safe-uint.mjs';
 describe('SafeUint test', () => {
   describe(asSafeUint, () => {
     test('accepts valid safe unsigned integers', () => {
-      expect(() => asSafeUint(0)).not.toThrowError();
+      expect(() => asSafeUint(0)).not.toThrow();
 
-      expect(() => asSafeUint(1)).not.toThrowError();
+      expect(() => asSafeUint(1)).not.toThrow();
 
-      expect(() => asSafeUint(42)).not.toThrowError();
+      expect(() => asSafeUint(42)).not.toThrow();
 
-      expect(() => asSafeUint(100)).not.toThrowError();
+      expect(() => asSafeUint(100)).not.toThrow();
 
-      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects negative numbers', () => {
-      expect(() => asSafeUint(-1)).toThrowError(TypeError);
+      expect(() => asSafeUint(-1)).toThrow(TypeError);
 
-      expect(() => asSafeUint(-42)).toThrowError(TypeError);
+      expect(() => asSafeUint(-42)).toThrow(TypeError);
 
-      expect(() => asSafeUint(Number.MIN_SAFE_INTEGER)).toThrowError(TypeError);
+      expect(() => asSafeUint(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
     });
 
     test('rejects values outside safe integer range', () => {
-      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER + 1)).toThrowError(
-        TypeError,
-      );
+      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER + 1)).toThrow(TypeError);
 
-      expect(() => asSafeUint(Number.MAX_VALUE)).toThrowError(TypeError);
+      expect(() => asSafeUint(Number.MAX_VALUE)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asSafeUint(Number.NaN)).toThrowError(TypeError);
+      expect(() => asSafeUint(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asSafeUint(Number.POSITIVE_INFINITY)).toThrowError(
-        TypeError,
-      );
+      expect(() => asSafeUint(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asSafeUint(Number.NEGATIVE_INFINITY)).toThrowError(
-        TypeError,
-      );
+      expect(() => asSafeUint(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asSafeUint(1.2)).toThrowError(TypeError);
+      expect(() => asSafeUint(1.2)).toThrow(TypeError);
 
-      expect(() => asSafeUint(-3.4)).toThrowError(TypeError);
+      expect(() => asSafeUint(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -66,7 +60,7 @@ describe('SafeUint test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asSafeUint($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asSafeUint(value)).toThrowError(
+      expect(() => asSafeUint(value)).toThrow(
         new TypeError(`Expected a non-negative safe integer, got: ${value}`),
       );
     });

package/src/number/branded-types/uint.test.mts

@@ -5,35 +5,35 @@ import { asUint, isUint, Uint } from './uint.mjs';
 describe('Uint test', () => {
   describe(asUint, () => {
     test('accepts valid unsigned integers', () => {
-      expect(() => asUint(0)).not.toThrowError();
+      expect(() => asUint(0)).not.toThrow();
 
-      expect(() => asUint(1)).not.toThrowError();
+      expect(() => asUint(1)).not.toThrow();
 
-      expect(() => asUint(42)).not.toThrowError();
+      expect(() => asUint(42)).not.toThrow();
 
-      expect(() => asUint(100)).not.toThrowError();
+      expect(() => asUint(100)).not.toThrow();
 
-      expect(() => asUint(Number.MAX_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asUint(Number.MAX_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects negative integers', () => {
-      expect(() => asUint(-1)).toThrowError(TypeError);
+      expect(() => asUint(-1)).toThrow(TypeError);
 
-      expect(() => asUint(-42)).toThrowError(TypeError);
+      expect(() => asUint(-42)).toThrow(TypeError);
 
-      expect(() => asUint(Number.MIN_SAFE_INTEGER)).toThrowError(TypeError);
+      expect(() => asUint(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asUint(Number.NaN)).toThrowError(TypeError);
+      expect(() => asUint(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asUint(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asUint(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asUint(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asUint(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asUint(1.2)).toThrowError(TypeError);
+      expect(() => asUint(1.2)).toThrow(TypeError);
 
-      expect(() => asUint(-3.4)).toThrowError(TypeError);
+      expect(() => asUint(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -52,7 +52,7 @@ describe('Uint test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asUint($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asUint(value)).toThrowError(
+      expect(() => asUint(value)).toThrow(
         new TypeError(`Expected a non-negative integer, got: ${value}`),
       );
     });

package/src/number/branded-types/uint16.test.mts

@@ -6,37 +6,37 @@ import { asUint16, isUint16, Uint16 } from './uint16.mjs';
 describe('Uint16 test', () => {
   describe(asUint16, () => {
     test('accepts valid uint16 values', () => {
-      expect(() => asUint16(0)).not.toThrowError();
+      expect(() => asUint16(0)).not.toThrow();
 
-      expect(() => asUint16(1)).not.toThrowError();
+      expect(() => asUint16(1)).not.toThrow();
 
-      expect(() => asUint16(65_535)).not.toThrowError(); // 2^16 - 1
+      expect(() => asUint16(65_535)).not.toThrow(); // 2^16 - 1
 
-      expect(() => asUint16(32_768)).not.toThrowError(); // 2^15
+      expect(() => asUint16(32_768)).not.toThrow(); // 2^15
     });
 
     test('rejects values outside uint16 range', () => {
-      expect(() => asUint16(65_536)).toThrowError(TypeError); // 2^16
+      expect(() => asUint16(65_536)).toThrow(TypeError); // 2^16
 
-      expect(() => asUint16(100_000)).toThrowError(TypeError);
+      expect(() => asUint16(100_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asUint16(-1)).toThrowError(TypeError);
+      expect(() => asUint16(-1)).toThrow(TypeError);
 
-      expect(() => asUint16(-42)).toThrowError(TypeError);
+      expect(() => asUint16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asUint16(Number.NaN)).toThrowError(TypeError);
+      expect(() => asUint16(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asUint16(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asUint16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asUint16(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asUint16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asUint16(1.2)).toThrowError(TypeError);
+      expect(() => asUint16(1.2)).toThrow(TypeError);
 
-      expect(() => asUint16(-3.4)).toThrowError(TypeError);
+      expect(() => asUint16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -55,7 +55,7 @@ describe('Uint16 test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asUint16($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asUint16(value)).toThrowError(
+      expect(() => asUint16(value)).toThrow(
         new TypeError(
           `Expected a non-negative integer less than 2^16, got: ${value}`,
         ),

package/src/number/branded-types/uint32.test.mts

@@ -6,37 +6,37 @@ import { asUint32, isUint32, Uint32 } from './uint32.mjs';
 describe('Uint32 test', () => {
   describe(asUint32, () => {
     test('accepts valid uint32 values', () => {
-      expect(() => asUint32(0)).not.toThrowError();
+      expect(() => asUint32(0)).not.toThrow();
 
-      expect(() => asUint32(1)).not.toThrowError();
+      expect(() => asUint32(1)).not.toThrow();
 
-      expect(() => asUint32(4_294_967_295)).not.toThrowError(); // 2^32 - 1
+      expect(() => asUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
 
-      expect(() => asUint32(2_147_483_648)).not.toThrowError(); // 2^31
+      expect(() => asUint32(2_147_483_648)).not.toThrow(); // 2^31
     });
 
     test('rejects values outside uint32 range', () => {
-      expect(() => asUint32(4_294_967_296)).toThrowError(TypeError); // 2^32
+      expect(() => asUint32(4_294_967_296)).toThrow(TypeError); // 2^32
 
-      expect(() => asUint32(10_000_000_000)).toThrowError(TypeError);
+      expect(() => asUint32(10_000_000_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asUint32(-1)).toThrowError(TypeError);
+      expect(() => asUint32(-1)).toThrow(TypeError);
 
-      expect(() => asUint32(-42)).toThrowError(TypeError);
+      expect(() => asUint32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asUint32(Number.NaN)).toThrowError(TypeError);
+      expect(() => asUint32(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asUint32(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asUint32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asUint32(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asUint32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asUint32(1.2)).toThrowError(TypeError);
+      expect(() => asUint32(1.2)).toThrow(TypeError);
 
-      expect(() => asUint32(-3.4)).toThrowError(TypeError);
+      expect(() => asUint32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -55,7 +55,7 @@ describe('Uint32 test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asUint32($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asUint32(value)).toThrowError(
+      expect(() => asUint32(value)).toThrow(
         new TypeError(
           `Expected a non-negative integer less than 2^32, got: ${value}`,
         ),

package/src/number/enum/int8.test.mts

@@ -35,7 +35,7 @@ describe('Int8 test', () => {
       { value: Number.POSITIVE_INFINITY, name: 'Infinity' },
       { value: Number.NEGATIVE_INFINITY, name: '-Infinity' },
     ])('asInt8($name) should throw TypeError', ({ value }) => {
-      expect(() => asInt8(value)).toThrowError(TypeError);
+      expect(() => asInt8(value)).toThrow(TypeError);
     });
   });
 

package/src/number/enum/uint8.test.mts

@@ -35,7 +35,7 @@ describe('Uint8 test', () => {
       { value: Number.POSITIVE_INFINITY, name: 'Infinity' },
       { value: Number.NEGATIVE_INFINITY, name: '-Infinity' },
     ])('asUint8($name) should throw TypeError', ({ value }) => {
-      expect(() => asUint8(value)).toThrowError(TypeError);
+      expect(() => asUint8(value)).toThrow(TypeError);
     });
   });
 

package/src/object/object.mts

@@ -1,3 +1,6 @@
+import { Arr } from '../array/index.mjs';
+import { hasKey, isRecord } from '../guard/index.mjs';
+
 /**
  * A collection of type-safe object utility functions providing functional
  * programming patterns for object manipulation, including pick, omit, shallow
@@ -58,7 +61,6 @@ export namespace Obj {
 
     const bEntries = Object.entries(b);
 
-    // eslint-disable-next-line ts-data-forge/prefer-arr-is-array-of-length
     if (aEntries.length !== bEntries.length) return false;
 
     return aEntries.every(([k, v]) => eq(b[k], v));
@@ -332,8 +334,175 @@ export namespace Obj {
   ): TsDataForgeInternals.MergeAll<Records> =>
     // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     Object.fromEntries(records.flatMap((r) => Object.entries(r))) as never;
+
+  /**
+   * Deeply picks a nested property from an object along the specified key path.
+   * Supports both direct and curried usage.
+   *
+   * @example
+   *
+   * ```ts
+   * const data = { a: { b: { c: 1, d: 2 }, e: 3 }, f: 4 } as const;
+   *
+   * // Direct usage
+   * const result = Obj.deepPick(data, ['a', 'b', 'c']);
+   * assert.deepStrictEqual(result, { a: { b: { c: 1 } } });
+   *
+   * // Curried usage with pipe
+   * const pickName = Obj.deepPick(['user', 'name']);
+   * const result2 = pipe(data).map(pickName).value;
+   * ```
+   *
+   * @template R - The type of the input record
+   * @template Path - The key path tuple
+   * @param record - The source record
+   * @param path - A readonly tuple of keys representing the nested path
+   * @returns A new record containing only the nested property at the path
+   */
+  export function deepPick<
+    const R extends UnknownRecord,
+    const Path extends readonly (string | number)[],
+  >(record: R, path: Path): DeepPick<R, Path>;
+
+  // Curried version
+  export function deepPick<const Path extends readonly (string | number)[]>(
+    path: Path,
+  ): <const R extends UnknownRecord>(record: R) => DeepPick<R, Path>;
+
+  export function deepPick<
+    const R extends UnknownRecord,
+    const Path extends readonly (string | number)[],
+  >(
+    ...args: readonly [record: R, path: Path] | readonly [path: Path]
+  ): DeepPick<R, Path> | ((record: R) => DeepPick<R, Path>) {
+    switch (args.length) {
+      case 2: {
+        const [record, path] = args;
+
+        return (
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          deepPickImpl(record, path) as never
+        );
+      }
+
+      case 1: {
+        const [path] = args;
+
+        return (record: R) => deepPick(record, path);
+      }
+    }
+  }
+
+  /**
+   * Deeply omits a nested property from an object along the specified key path.
+   * Supports both direct and curried usage.
+   *
+   * @example
+   *
+   * ```ts
+   * const data = { a: { b: { c: 1, d: 2 }, e: 3 }, f: 4 } as const;
+   *
+   * // Direct usage
+   * const result = Obj.deepOmit(data, ['a', 'b', 'c']);
+   * assert.deepStrictEqual(result, { a: { b: { d: 2 }, e: 3 }, f: 4 });
+   *
+   * // Curried usage with pipe
+   * const omitPassword = Obj.deepOmit(['user', 'password']);
+   * const result2 = pipe(data).map(omitPassword).value;
+   * ```
+   *
+   * @template R - The type of the input record
+   * @template Path - The key path tuple
+   * @param record - The source record
+   * @param path - A readonly tuple of keys representing the nested path to omit
+   * @returns A new record with the nested property at the path removed
+   */
+  export function deepOmit<
+    const R extends UnknownRecord,
+    const Path extends readonly (string | number)[],
+  >(record: R, path: Path): DeepOmit<R, Path>;
+
+  // Curried version
+  export function deepOmit<const Path extends readonly (string | number)[]>(
+    path: Path,
+  ): <const R extends UnknownRecord>(record: R) => DeepOmit<R, Path>;
+
+  export function deepOmit<
+    const R extends UnknownRecord,
+    const Path extends readonly (string | number)[],
+  >(
+    ...args: readonly [record: R, path: Path] | readonly [path: Path]
+  ): DeepOmit<R, Path> | ((record: R) => DeepOmit<R, Path>) {
+    switch (args.length) {
+      case 2: {
+        const [record, path] = args;
+
+        return (
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          deepOmitImpl(record, path) as never
+        );
+      }
+
+      case 1: {
+        const [path] = args;
+
+        return (record: R) => deepOmit(record, path);
+      }
+    }
+  }
 }
 
+const deepPickImpl = (
+  record: UnknownRecord,
+  path: readonly (string | number)[],
+): UnknownRecord => {
+  if (!Arr.isNonEmpty(path)) return record;
+
+  const head = path[0];
+
+  if (!hasKey(record, head)) return {};
+
+  const value = record[head];
+
+  const tail = path.slice(1);
+
+  if (!Arr.isNonEmpty(tail)) return { [head]: value };
+
+  if (!isRecord(value)) return { [head]: {} };
+
+  return {
+    [head]: deepPickImpl(value, tail),
+  };
+};
+
+const deepOmitImpl = (
+  record: UnknownRecord,
+  path: readonly (string | number)[],
+): UnknownRecord => {
+  if (!Arr.isNonEmpty(path)) return record;
+
+  const head = path[0];
+
+  const tail = path.slice(1);
+
+  if (!hasKey(record, head)) return record;
+
+  if (!Arr.isNonEmpty(tail)) {
+    return Object.fromEntries(
+      Object.entries(record).filter(([k]) => k !== head),
+    );
+  }
+
+  const value = record[head];
+
+  if (!isRecord(value)) return record;
+
+  return {
+    ...record,
+    [head]: deepOmitImpl(value, tail),
+  };
+};
+
 /**
  * @internal
  * Internal type utilities for the Obj module.