ts-data-forge 14.4.0 → 14.6.0

package/dist/functional/result/impl/result-match.mjs

@@ -0,0 +1,24 @@
+import { isOk } from './result-is-ok.mjs';
+
+function match(...args) {
+  switch (args.length) {
+    case 2: {
+      const [result, cases] = args;
+      return matchImpl(result, cases);
+    }
+    case 1: {
+      const [cases] = args;
+      return (result) => matchImpl(result, cases);
+    }
+  }
+}
+const matchImpl = (result, cases) => isOk(result) ? (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  cases.ok(result.value)
+) : (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  cases.err(result.value)
+);
+
+export { match };
+//# sourceMappingURL=result-match.mjs.map

package/dist/functional/result/impl/result-match.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-match.mjs","sources":["../../../../src/functional/result/impl/result-match.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Folds a `Result` into a plain value by applying one of two case handlers:\n * `ok` if the `Result` is `Ok`, `err` otherwise. This is the function form of\n * pattern matching on a `Result`.\n *\n * Unlike {@link Result.fold}, which maps both sides and returns another\n * `Result`, `match` unwraps: both branches produce the final value directly.\n *\n * @example\n *\n * ```ts\n * const doubledOrZero = Result.match(Result.ok(21), {\n *   ok: (value) => value * 2,\n *   err: () => 0,\n * });\n *\n * assert.deepStrictEqual(doubledOrZero, 42);\n *\n * const matcher = Result.match({\n *   ok: (value: number) => value + 1,\n *   err: (error: string) => error.length,\n * });\n *\n * assert.deepStrictEqual(matcher(Result.ok(1)), 2);\n *\n * assert.deepStrictEqual(matcher(Result.err('oops')), 4);\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The type returned by the `ok` case.\n * @template E2 The type returned by the `err` case.\n * @param result The `Result` to match on.\n * @param cases An object with an `ok` handler receiving the success value and\n *   an `err` handler receiving the error value.\n * @returns The value produced by whichever case handler was applied.\n */\nexport function match<R extends UnknownResult, S2, E2>(\n  result: R,\n  cases: Readonly<{\n    ok: (value: UnwrapOk<R>) => S2;\n    err: (error: UnwrapErr<R>) => E2;\n  }>,\n): E2 | S2;\n\n// Curried version\n//\n// The returned function is generic over the *whole* result, mirroring the\n// direct overload above; see the comment on the curried overload of\n// `Result.map` for why the parameter is a conditional type instead of a plain\n// `Result<S, E>`. Both sides have to be checked here, hence the nested\n// conditional.\nexport function match<S, E, S2, E2>(\n  cases: Readonly<{\n    ok: (value: S) => S2;\n    err: (error: E) => E2;\n  }>,\n): <R extends UnknownResult>(\n  result: UnwrapOk<R> extends S ? (UnwrapErr<R> extends E ? R : never) : never,\n) => E2 | S2;\n\nexport function match<R extends UnknownResult, S2, E2>(\n  ...args:\n    | readonly [\n        result: R,\n        cases: Readonly<{\n          ok: (value: UnwrapOk<R>) => S2;\n          err: (error: UnwrapErr<R>) => E2;\n        }>,\n      ]\n    | readonly [\n        cases: Readonly<{\n          ok: (value: UnwrapOk<R>) => S2;\n          err: (error: UnwrapErr<R>) => E2;\n        }>,\n      ]\n): E2 | S2 | ((result: R) => E2 | S2) {\n  switch (args.length) {\n    case 2: {\n      const [result, cases] = args;\n\n      return matchImpl(result, cases);\n    }\n\n    case 1: {\n      // Curried version: the only argument is the case handlers\n      const [cases] = args;\n\n      return (result: R) => matchImpl(result, cases);\n    }\n  }\n}\n\nconst matchImpl = <R extends UnknownResult, S2, E2>(\n  result: R,\n  cases: Readonly<{\n    ok: (value: UnwrapOk<R>) => S2;\n    err: (error: UnwrapErr<R>) => E2;\n  }>,\n): E2 | S2 =>\n  isOk(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      cases.ok(result.value as UnwrapOk<R>)\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      cases.err(result.value as UnwrapErr<R>);\n"],"names":[],"mappings":";;AAgEO,SAAS,SACX,IAAA,EAciC;AACpC,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAK,CAAA,GAAI,IAAA;AAExB,MAAA,OAAO,SAAA,CAAU,QAAQ,KAAK,CAAA;AAAA,IAChC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,MAAA,KAAc,SAAA,CAAU,MAAA,EAAQ,KAAK,CAAA;AAAA,IAC/C;AAAA;AAEJ;AAEA,MAAM,SAAA,GAAY,CAChB,MAAA,EACA,KAAA,KAKA,KAAK,MAAM,CAAA;AAAA;AAAA,EAEP,KAAA,CAAM,EAAA,CAAG,MAAA,CAAO,KAAoB;AAAA;AAAA;AAAA,EAEpC,KAAA,CAAM,GAAA,CAAI,MAAA,CAAO,KAAqB;AAAA,CAAA;;;;"}

package/dist/functional/result/impl/result-safe-try.d.mts

@@ -0,0 +1,51 @@
+import { type Err } from '../../../types.mjs';
+import { type Result, type UnknownResult } from '../result.mjs';
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Runs a generator body in which `yield* Result.safeUnwrap(...)` unwraps `Ok`
+ * values and short-circuits on the first `Err`, emulating Rust's `?` operator
+ * (early-return error propagation).
+ *
+ * The body must return a `Result`. If every unwrapped `Result` is `Ok`, the
+ * returned value is the body's `Result`; otherwise it is the first `Err`
+ * encountered, and the rest of the body never runs — though the generator is
+ * closed rather than dropped, so `finally` blocks and `using` disposals
+ * pending in the body still run. An exception thrown by the body is not
+ * converted to an `Err`: it propagates out of `safeTry` (as a rejected
+ * `Promise` for an async body). Use {@link Result.fromThrowable} for that.
+ *
+ * Passing an async generator (`async function*`) returns a
+ * `Promise<Result<...>>` instead, so `await` can be used inside the body.
+ * Note that `yield*` inside an `async function*` awaits what it receives, so
+ * unwrapping an `Ok` whose value is itself a `Promise` yields the awaited
+ * value there while the static type still says `Promise<...>`; keep promises
+ * out of the `Ok` side of a `Result` unwrapped in an async body.
+ *
+ * @example
+ *
+ * ```ts
+ * const parseTwo = (a: string, b: string): Result<number, Error> =>
+ *   Result.safeTry(function* () {
+ *     const x = yield* Result.safeUnwrap(Num.safeParseInt(a));
+ *
+ *     const y = yield* Result.safeUnwrap(Num.safeParseInt(b));
+ *
+ *     return Result.ok(x + y);
+ *   });
+ *
+ * assert.deepStrictEqual(parseTwo('1', '2'), Result.ok(3));
+ *
+ * assert.isTrue(Result.isErr(parseTwo('1', 'not a number')));
+ * ```
+ *
+ * @template Y The union of `Err` types unwrapped via
+ *   {@link Result.safeUnwrap} (`never` if nothing is unwrapped).
+ * @template R2 The `Result` type returned by the body.
+ * @param body A generator function whose `yield*` expressions delegate to
+ *   {@link Result.safeUnwrap} and whose return value is a `Result`.
+ * @returns The body's `Result`, or the first `Err` short-circuited out of it
+ *   (wrapped in a `Promise` for an async generator body).
+ */
+export declare function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(body: () => Generator<Y, R2>): Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>;
+export declare function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(body: () => AsyncGenerator<Y, R2>): Promise<Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>>;
+//# sourceMappingURL=result-safe-try.d.mts.map

package/dist/functional/result/impl/result-safe-try.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-safe-try.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-safe-try.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,aAAa,EACtE,IAAI,EAAE,MAAM,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAC3B,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtD,wBAAgB,OAAO,CAAC,CAAC,SAAS,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,aAAa,EACtE,IAAI,EAAE,MAAM,cAAc,CAAC,CAAC,EAAE,EAAE,CAAC,GAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/functional/result/impl/result-safe-try.mjs

@@ -0,0 +1,24 @@
+import { hasKey } from '../../../guard/has-key.mjs';
+import { isRecord } from '../../../guard/is-record.mjs';
+
+function safeTry(body) {
+  const generator = body();
+  const step = generator.next();
+  if (isSyncStep(step)) {
+    if (step.done !== true && isSyncGenerator(generator, step)) {
+      generator.return(step.value);
+    }
+    return step.value;
+  }
+  return step.then(async (asyncStep) => {
+    if (asyncStep.done !== true) {
+      await generator.return(asyncStep.value);
+    }
+    return asyncStep.value;
+  });
+}
+const isSyncStep = (value) => isRecord(value) && hasKey(value, "done");
+const isSyncGenerator = (_generator, step) => isSyncStep(step);
+
+export { safeTry };
+//# sourceMappingURL=result-safe-try.mjs.map

package/dist/functional/result/impl/result-safe-try.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-safe-try.mjs","sources":["../../../../src/functional/result/impl/result-safe-try.mts"],"sourcesContent":["import { hasKey, isRecord } from '../../../guard/index.mjs';\nimport { type Err } from '../../../types.mjs';\nimport { type Result, type UnknownResult } from '../result.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Runs a generator body in which `yield* Result.safeUnwrap(...)` unwraps `Ok`\n * values and short-circuits on the first `Err`, emulating Rust's `?` operator\n * (early-return error propagation).\n *\n * The body must return a `Result`. If every unwrapped `Result` is `Ok`, the\n * returned value is the body's `Result`; otherwise it is the first `Err`\n * encountered, and the rest of the body never runs — though the generator is\n * closed rather than dropped, so `finally` blocks and `using` disposals\n * pending in the body still run. An exception thrown by the body is not\n * converted to an `Err`: it propagates out of `safeTry` (as a rejected\n * `Promise` for an async body). Use {@link Result.fromThrowable} for that.\n *\n * Passing an async generator (`async function*`) returns a\n * `Promise<Result<...>>` instead, so `await` can be used inside the body.\n * Note that `yield*` inside an `async function*` awaits what it receives, so\n * unwrapping an `Ok` whose value is itself a `Promise` yields the awaited\n * value there while the static type still says `Promise<...>`; keep promises\n * out of the `Ok` side of a `Result` unwrapped in an async body.\n *\n * @example\n *\n * ```ts\n * const parseTwo = (a: string, b: string): Result<number, Error> =>\n *   Result.safeTry(function* () {\n *     const x = yield* Result.safeUnwrap(Num.safeParseInt(a));\n *\n *     const y = yield* Result.safeUnwrap(Num.safeParseInt(b));\n *\n *     return Result.ok(x + y);\n *   });\n *\n * assert.deepStrictEqual(parseTwo('1', '2'), Result.ok(3));\n *\n * assert.isTrue(Result.isErr(parseTwo('1', 'not a number')));\n * ```\n *\n * @template Y The union of `Err` types unwrapped via\n *   {@link Result.safeUnwrap} (`never` if nothing is unwrapped).\n * @template R2 The `Result` type returned by the body.\n * @param body A generator function whose `yield*` expressions delegate to\n *   {@link Result.safeUnwrap} and whose return value is a `Result`.\n * @returns The body's `Result`, or the first `Err` short-circuited out of it\n *   (wrapped in a `Promise` for an async generator body).\n */\nexport function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(\n  body: () => Generator<Y, R2>,\n): Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>;\n\nexport function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(\n  body: () => AsyncGenerator<Y, R2>,\n): Promise<Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>>;\n\nexport function safeTry(\n  body:\n    | (() => AsyncGenerator<UnknownResult, UnknownResult>)\n    | (() => Generator<UnknownResult, UnknownResult>),\n): Promise<UnknownResult> | UnknownResult {\n  const generator = body();\n\n  // A yielded `Err` and a returned `Result` are both already the final\n  // answer, so the first step's `value` is the result in either case: the\n  // generator is closed rather than resumed after yielding.\n  const step = generator.next();\n\n  if (isSyncStep(step)) {\n    // Dropping a suspended generator would skip the `finally` blocks and\n    // `using` disposals still pending in the body; closing it runs them\n    // before the short-circuited `Err` is handed back. `isSyncGenerator` is\n    // what makes `return()` here synchronous rather than a floating promise.\n    if (step.done !== true && isSyncGenerator(generator, step)) {\n      generator.return(step.value);\n    }\n\n    return step.value;\n  }\n\n  return step.then(async (asyncStep) => {\n    if (asyncStep.done !== true) {\n      await generator.return(asyncStep.value);\n    }\n\n    return asyncStep.value;\n  });\n}\n\n// A sync generator's `next()` returns a plain `{ value, done }` object with\n// own properties, while an async generator's returns a `Promise`, whose\n// `then` lives on the prototype — so an own-key check on `done` separates the\n// two.\nconst isSyncStep = (\n  value: unknown,\n): value is IteratorResult<UnknownResult, UnknownResult> =>\n  isRecord(value) && hasKey(value, 'done');\n\n// The generator-side counterpart of `isSyncStep`: a step in the sync form can\n// only have come from a sync generator, so the step is what narrows the\n// generator that produced it — hence the predicate reads its second argument\n// and not its first.\nconst isSyncGenerator = (\n  _generator:\n    | AsyncGenerator<UnknownResult, UnknownResult>\n    | Generator<UnknownResult, UnknownResult>,\n  step: unknown,\n): _generator is Generator<UnknownResult, UnknownResult> => isSyncStep(step);\n"],"names":[],"mappings":";;;AA0DO,SAAS,QACd,IAAA,EAGwC;AACxC,EAAA,MAAM,YAAY,IAAA,EAAK;AAKvB,EAAA,MAAM,IAAA,GAAO,UAAU,IAAA,EAAK;AAE5B,EAAA,IAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AAKpB,IAAA,IAAI,KAAK,IAAA,KAAS,IAAA,IAAQ,eAAA,CAAgB,SAAA,EAAW,IAAI,CAAA,EAAG;AAC1D,MAAA,SAAA,CAAU,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,IAC7B;AAEA,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAEA,EAAA,OAAO,IAAA,CAAK,IAAA,CAAK,OAAO,SAAA,KAAc;AACpC,IAAA,IAAI,SAAA,CAAU,SAAS,IAAA,EAAM;AAC3B,MAAA,MAAM,SAAA,CAAU,MAAA,CAAO,SAAA,CAAU,KAAK,CAAA;AAAA,IACxC;AAEA,IAAA,OAAO,SAAA,CAAU,KAAA;AAAA,EACnB,CAAC,CAAA;AACH;AAMA,MAAM,UAAA,GAAa,CACjB,KAAA,KAEA,QAAA,CAAS,KAAK,CAAA,IAAK,MAAA,CAAO,OAAO,MAAM,CAAA;AAMzC,MAAM,eAAA,GAAkB,CACtB,UAAA,EAGA,IAAA,KAC0D,WAAW,IAAI,CAAA;;;;"}

package/dist/functional/result/impl/result-safe-unwrap.d.mts

@@ -0,0 +1,36 @@
+import { type UnknownResult } from '../result.mjs';
+import { type NarrowToErr, type UnwrapOk } from './types.mjs';
+/**
+ * Unwraps a `Result` inside a {@link Result.safeTry} generator body via
+ * `yield*`, emulating Rust's `?` operator.
+ *
+ * If the `Result` is `Ok`, the `yield*` expression evaluates to the contained
+ * value and execution continues. If it is `Err`, the error is yielded to
+ * {@link Result.safeTry}, which returns it immediately — the rest of the
+ * generator body never runs.
+ *
+ * This generator must only be delegated to (`yield*`) inside a
+ * {@link Result.safeTry} body; resuming it after it has yielded an `Err`
+ * throws.
+ *
+ * @example
+ *
+ * ```ts
+ * const result = Result.safeTry(function* () {
+ *   const x = yield* Result.safeUnwrap(Result.ok(2));
+ *
+ *   const y = yield* Result.safeUnwrap(Result.ok(3));
+ *
+ *   return Result.ok(x + y);
+ * });
+ *
+ * assert.deepStrictEqual(result, Result.ok(5));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @param result The `Result` to unwrap.
+ * @returns A generator that yields the `Err` (if any) and returns the `Ok`
+ *   value.
+ */
+export declare function safeUnwrap<R extends UnknownResult>(result: R): Generator<NarrowToErr<R>, UnwrapOk<R>, unknown>;
+//# sourceMappingURL=result-safe-unwrap.d.mts.map

package/dist/functional/result/impl/result-safe-unwrap.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-safe-unwrap.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-safe-unwrap.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAiB,UAAU,CAAC,CAAC,SAAS,aAAa,EACjD,MAAM,EAAE,CAAC,GACR,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAWjD"}

package/dist/functional/result/impl/result-safe-unwrap.mjs

@@ -0,0 +1,14 @@
+import { isErr } from './result-is-err.mjs';
+
+function* safeUnwrap(result) {
+  if (isErr(result)) {
+    yield result;
+    throw new Error(
+      "`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`"
+    );
+  }
+  return result.value;
+}
+
+export { safeUnwrap };
+//# sourceMappingURL=result-safe-unwrap.mjs.map

package/dist/functional/result/impl/result-safe-unwrap.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-safe-unwrap.mjs","sources":["../../../../src/functional/result/impl/result-safe-unwrap.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { type NarrowToErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Unwraps a `Result` inside a {@link Result.safeTry} generator body via\n * `yield*`, emulating Rust's `?` operator.\n *\n * If the `Result` is `Ok`, the `yield*` expression evaluates to the contained\n * value and execution continues. If it is `Err`, the error is yielded to\n * {@link Result.safeTry}, which returns it immediately — the rest of the\n * generator body never runs.\n *\n * This generator must only be delegated to (`yield*`) inside a\n * {@link Result.safeTry} body; resuming it after it has yielded an `Err`\n * throws.\n *\n * @example\n *\n * ```ts\n * const result = Result.safeTry(function* () {\n *   const x = yield* Result.safeUnwrap(Result.ok(2));\n *\n *   const y = yield* Result.safeUnwrap(Result.ok(3));\n *\n *   return Result.ok(x + y);\n * });\n *\n * assert.deepStrictEqual(result, Result.ok(5));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to unwrap.\n * @returns A generator that yields the `Err` (if any) and returns the `Ok`\n *   value.\n */\nexport function* safeUnwrap<R extends UnknownResult>(\n  result: R,\n): Generator<NarrowToErr<R>, UnwrapOk<R>, unknown> {\n  if (isErr(result)) {\n    yield result;\n\n    throw new Error(\n      '`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`',\n    );\n  }\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return result.value as UnwrapOk<R>;\n}\n"],"names":[],"mappings":";;AAoCO,UAAU,WACf,MAAA,EACiD;AACjD,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AACjB,IAAA,MAAM,MAAA;AAEN,IAAA,MAAM,IAAI,KAAA;AAAA,MACR;AAAA,KACF;AAAA,EACF;AAGA,EAAA,OAAO,MAAA,CAAO,KAAA;AAChB;;;;"}

package/dist/json/json.mjs

@@ -34,13 +34,13 @@ import '../number/enum/int8.mjs';
 import '../number/enum/uint8.mjs';
 import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
-import { isRecord } from '../guard/is-record.mjs';
-import { pipe } from '../functional/pipe.mjs';
 import { err } from '../functional/result/impl/result-err.mjs';
 import { ok } from '../functional/result/impl/result-ok.mjs';
+import { isRecord } from '../guard/is-record.mjs';
 import '@sindresorhus/is';
 import { castMutable } from '../others/cast-mutable.mjs';
 import { unknownToString } from '../others/unknown-to-string.mjs';
+import { pipe } from '../functional/pipe.mjs';
 import '../collections/imap-mapped.mjs';
 import '../collections/imap.mjs';
 import '../collections/iset-mapped.mjs';

package/dist/number/refined-number-utils.mjs

@@ -1,5 +1,5 @@
-import { pipe } from '../functional/pipe.mjs';
 import '@sindresorhus/is';
+import { pipe } from '../functional/pipe.mjs';
 import { Num } from './num.mjs';
 
 var TsDataForgeInternals;

package/dist/object/object.mjs

@@ -34,9 +34,9 @@ import '../number/enum/int8.mjs';
 import '../number/enum/uint8.mjs';
 import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
+import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
 import { hasKey } from '../guard/has-key.mjs';
 import { isRecord } from '../guard/is-record.mjs';
-import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
 import '@sindresorhus/is';
 import { isNonEmpty } from '../array/impl/array-utils-length-bounded-array-guard.mjs';
 import '../collections/imap-mapped.mjs';

package/dist/others/debounce-function.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"debounce-function.d.mts","sourceRoot":"","sources":["../../src/others/debounce-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,GAAI,IAAI,SAAS,SAAS,OAAO,EAAE,QAChD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,oBACX,MAAM,KACvB,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,CAU1B,CAAC"}
+{"version":3,"file":"debounce-function.d.mts","sourceRoot":"","sources":["../../src/others/debounce-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,GAAI,IAAI,SAAS,SAAS,OAAO,EAAE,QAChD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,oBACX,MAAM,KACvB,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,CAc1B,CAAC"}

package/dist/others/debounce-function.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"debounce-function.mjs","sources":["../../src/others/debounce-function.mts"],"sourcesContent":["/**\n * Creates a debounced function that delays invoking `func` until after `waitMilliseconds`\n * have elapsed since the last time the debounced function was invoked.\n *\n * @template F The type of the function to debounce.\n * @param func The function to debounce.\n * @param waitMilliseconds The number of milliseconds to delay.\n * @returns The new debounced function.\n */\nexport const debounce = <Args extends readonly unknown[]>(\n  func: (...args: Args) => void,\n  waitMilliseconds: number,\n): ((...args: Args) => void) => {\n  let mut_timeoutId: ReturnType<typeof setTimeout> | undefined;\n\n  return (...args: Args): void => {\n    clearTimeout(mut_timeoutId);\n\n    mut_timeoutId = setTimeout(() => {\n      func(...args);\n    }, waitMilliseconds);\n  };\n};\n"],"names":[],"mappings":"AASO,MAAM,QAAA,GAAW,CACtB,IAAA,EACA,gBAAA,KAC8B;AAC9B,EAAA,IAAI,aAAA;AAEJ,EAAA,OAAO,IAAI,IAAA,KAAqB;AAC9B,IAAA,YAAA,CAAa,aAAa,CAAA;AAE1B,IAAA,aAAA,GAAgB,WAAW,MAAM;AAC/B,MAAA,IAAA,CAAK,GAAG,IAAI,CAAA;AAAA,IACd,GAAG,gBAAgB,CAAA;AAAA,EACrB,CAAA;AACF;;;;"}
+{"version":3,"file":"debounce-function.mjs","sources":["../../src/others/debounce-function.mts"],"sourcesContent":["/**\n * Creates a debounced function that delays invoking `func` until after `waitMilliseconds`\n * have elapsed since the last time the debounced function was invoked.\n *\n * @template F The type of the function to debounce.\n * @param func The function to debounce.\n * @param waitMilliseconds The number of milliseconds to delay.\n * @returns The new debounced function.\n */\nexport const debounce = <Args extends readonly unknown[]>(\n  func: (...args: Args) => void,\n  waitMilliseconds: number,\n): ((...args: Args) => void) => {\n  // Not `ReturnType<typeof setTimeout>`: with both the DOM and Node\n  // declarations in scope that resolves to `unknown`, which `clearTimeout`\n  // will not take. Naming what `clearTimeout` accepts says the same thing and\n  // stays true in either environment.\n  let mut_timeoutId: Parameters<typeof clearTimeout>[0];\n\n  return (...args: Args): void => {\n    clearTimeout(mut_timeoutId);\n\n    mut_timeoutId = setTimeout(() => {\n      func(...args);\n    }, waitMilliseconds);\n  };\n};\n"],"names":[],"mappings":"AASO,MAAM,QAAA,GAAW,CACtB,IAAA,EACA,gBAAA,KAC8B;AAK9B,EAAA,IAAI,aAAA;AAEJ,EAAA,OAAO,IAAI,IAAA,KAAqB;AAC9B,IAAA,YAAA,CAAa,aAAa,CAAA;AAE1B,IAAA,aAAA,GAAgB,WAAW,MAAM;AAC/B,MAAA,IAAA,CAAK,GAAG,IAAI,CAAA;AAAA,IACd,GAAG,gBAAgB,CAAA;AAAA,EACrB,CAAA;AACF;;;;"}

package/dist/others/fast-deep-equal.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"fast-deep-equal.d.mts","sourceRoot":"","sources":["../../src/others/fast-deep-equal.mts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,KAAM,CAAC,KAAK,CAAC,KAAG,OAyF9C,CAAC"}
+{"version":3,"file":"fast-deep-equal.d.mts","sourceRoot":"","sources":["../../src/others/fast-deep-equal.mts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,KAAM,CAAC,KAAK,CAAC,KAAG,OAgG9C,CAAC"}

package/dist/others/fast-deep-equal.mjs

@@ -49,7 +49,7 @@ const fastDeepEqual = (a, b) => {
       !(key === "_owner" && a["$$typeof"]) && fastDeepEqual(a[key], b[key])
     );
   }
-  return Number.isNaN(a) && Number.isNaN(b);
+  return typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b);
 };
 
 export { fastDeepEqual };

package/dist/others/fast-deep-equal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"fast-deep-equal.mjs","sources":["../../src/others/fast-deep-equal.mts"],"sourcesContent":["import { isMap, isRegExp, isSet, isTypedArray } from '@sindresorhus/is';\nimport { hasKey, isRecord } from '../guard/index.mjs';\n\n/**\n * The fastest deep equal with ES6 Map, Set and Typed arrays support.\n * Checks equality of Date and RegExp objects by value.\n *\n * Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst\n */\nexport const fastDeepEqual = <T,>(a: T, b: T): boolean => {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  // Arrays are handled before `isRecord`, which excludes them.\n  if (Array.isArray(a)) {\n    return (\n      Array.isArray(b) &&\n      a.constructor === b.constructor &&\n      a.length === b.length &&\n      a.every((ai, index) => fastDeepEqual(ai, b[index]))\n    );\n  }\n\n  if (isRecord(a)) {\n    if (!isRecord(b)) {\n      return false;\n    }\n\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    if (isMap(a)) {\n      return (\n        isMap(b) &&\n        a.size === b.size &&\n        a\n          .entries()\n          .every(\n            ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key)),\n          )\n      );\n    }\n\n    if (isSet(a)) {\n      return (\n        isSet(b) &&\n        a.size === b.size &&\n        a.entries().every(([value]) => b.has(value))\n      );\n    }\n\n    if (isTypedArray(a)) {\n      return (\n        isTypedArray(b) &&\n        a.length === b.length &&\n        a.every((value, index) => value === b[index])\n      );\n    }\n\n    if (isRegExp(a)) {\n      return isRegExp(b) && a.source === b.source && a.flags === b.flags;\n    }\n\n    if (a.valueOf !== Object.prototype.valueOf) {\n      return a.valueOf() === b.valueOf();\n    }\n\n    if (a.toString !== Object.prototype.toString) {\n      return a.toString() === b.toString();\n    }\n\n    const aKeys: readonly string[] = Object.keys(a);\n\n    const bKeys: readonly string[] = Object.keys(b);\n\n    return (\n      aKeys.length === bKeys.length &&\n      aKeys.every(\n        (key) =>\n          hasKey(b, key) &&\n          // React-specific: avoid traversing React elements' _owner.\n          //  _owner contains circular references\n          // and is not needed when comparing the actual elements (and not their owners)\n          // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n          !(key === '_owner' && a['$$typeof']) &&\n          fastDeepEqual(a[key], b[key]),\n      )\n    );\n  }\n\n  // true if both NaN, false otherwise\n  return Number.isNaN(a) && Number.isNaN(b);\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"fast-deep-equal.mjs","sources":["../../src/others/fast-deep-equal.mts"],"sourcesContent":["import { isMap, isRegExp, isSet, isTypedArray } from '@sindresorhus/is';\nimport { hasKey, isRecord } from '../guard/index.mjs';\n\n/**\n * The fastest deep equal with ES6 Map, Set and Typed arrays support.\n * Checks equality of Date and RegExp objects by value.\n *\n * Forked from https://github.com/epoberezkin/fast-deep-equal/blob/v3.1.3/src/index.jst\n */\nexport const fastDeepEqual = <T,>(a: T, b: T): boolean => {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  // Arrays are handled before `isRecord`, which excludes them.\n  if (Array.isArray(a)) {\n    return (\n      Array.isArray(b) &&\n      a.constructor === b.constructor &&\n      a.length === b.length &&\n      a.every((ai, index) => fastDeepEqual(ai, b[index]))\n    );\n  }\n\n  if (isRecord(a)) {\n    if (!isRecord(b)) {\n      return false;\n    }\n\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    if (isMap(a)) {\n      return (\n        isMap(b) &&\n        a.size === b.size &&\n        a\n          .entries()\n          .every(\n            ([key, value]) => b.has(key) && fastDeepEqual(value, b.get(key)),\n          )\n      );\n    }\n\n    if (isSet(a)) {\n      return (\n        isSet(b) &&\n        a.size === b.size &&\n        a.entries().every(([value]) => b.has(value))\n      );\n    }\n\n    if (isTypedArray(a)) {\n      return (\n        isTypedArray(b) &&\n        a.length === b.length &&\n        a.every((value, index) => value === b[index])\n      );\n    }\n\n    if (isRegExp(a)) {\n      return isRegExp(b) && a.source === b.source && a.flags === b.flags;\n    }\n\n    if (a.valueOf !== Object.prototype.valueOf) {\n      return a.valueOf() === b.valueOf();\n    }\n\n    if (a.toString !== Object.prototype.toString) {\n      return a.toString() === b.toString();\n    }\n\n    const aKeys: readonly string[] = Object.keys(a);\n\n    const bKeys: readonly string[] = Object.keys(b);\n\n    return (\n      aKeys.length === bKeys.length &&\n      aKeys.every(\n        (key) =>\n          hasKey(b, key) &&\n          // React-specific: avoid traversing React elements' _owner.\n          //  _owner contains circular references\n          // and is not needed when comparing the actual elements (and not their owners)\n          // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions\n          !(key === '_owner' && a['$$typeof']) &&\n          fastDeepEqual(a[key], b[key]),\n      )\n    );\n  }\n\n  // true if both NaN, false otherwise. `Number.isNaN` takes a number: called\n  // with anything else it is always false, so the check belongs behind a\n  // `typeof` guard rather than relying on that.\n  return (\n    typeof a === 'number' &&\n    typeof b === 'number' &&\n    Number.isNaN(a) &&\n    Number.isNaN(b)\n  );\n};\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "14.4.0",
+  "version": "14.6.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -37,29 +37,29 @@
   ],
   "dependencies": {
     "@sindresorhus/is": "^8.1.0",
-    "ts-type-forge": "~9.2.1"
+    "ts-type-forge": "~9.2.2"
   },
   "devDependencies": {
     "@emotion/react": "11.14.0",
     "@emotion/styled": "11.14.1",
     "@mui/material": "9.3.1",
     "@types/react": "19.2.18",
-    "@vitest/browser-playwright": "4.1.10",
+    "@vitest/browser-playwright": "4.1.11",
     "dedent": "1.7.2",
-    "immer": "11.1.16",
+    "eslint-config-typed": "5.10.1",
+    "eslint-plugin-ts-fortress": "1.0.6",
+    "eslint-plugin-ts-type-forge": "0.7.2",
+    "immer": "11.1.18",
     "playwright": "1.62.1",
     "prettier": "3.9.6",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.2.8",
-    "rollup": "4.62.4",
+    "rollup": "4.62.5",
+    "ts-repo-utils": "10.3.3",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
-    "vite": "8.2.1",
-    "eslint-plugin-ts-fortress": "1.0.4",
-    "eslint-config-typed": "5.9.3",
-    "ts-repo-utils": "10.2.0",
-    "eslint-plugin-ts-type-forge": "0.6.6"
+    "vite": "8.2.2"
   },
   "peerDependencies": {
     "typescript": ">=4.8"

package/src/array/impl/array-utils-modification.test.mts

@@ -257,7 +257,7 @@ describe('Arr modifications', () => {
         xs: T,
       ): Readonly<{ [K in keyof T]: 0 }> => toFilled(xs, 0);
 
-      const result = blank([1, 2, 3] as const);
+      const result = blank([1, 2, 3]);
 
       expectType<typeof result, FixedLengthTuple<3, 0>>('=');
 
@@ -269,7 +269,7 @@ describe('Arr modifications', () => {
         xs: T,
       ): Readonly<{ [K in keyof T]: 0 }> => toFilled(0)(xs);
 
-      const result = blank([1, 2] as const);
+      const result = blank([1, 2]);
 
       expectType<typeof result, FixedLengthTuple<2, 0>>('=');
 
@@ -319,7 +319,7 @@ describe('Arr modifications', () => {
         xs: T,
       ): Readonly<{ [K in keyof T]: number }> => toRangeFilled(xs, 0, [1, 2]);
 
-      const result = blankMiddle([1, 2, 3] as const);
+      const result = blankMiddle([1, 2, 3]);
 
       expectType<typeof result, FixedLengthTuple<3, number>>('=');
 

package/src/array/impl/array-utils-search.mts

@@ -79,10 +79,17 @@ const findImpl = <E,>(
     predicate as () => boolean,
   );
 
-  expectType<
-    Parameters<typeof array.findIndex>[0],
-    (value: E, index: number, arr: readonly E[]) => unknown
-  >('=');
+  // Left as a comment rather than asserted. This pinned the shape of the
+  // standard library's `findIndex`, and the shape differs between the stock
+  // library and the strict one — `(value, index, obj: this) => boolean` there
+  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships
+  // to consumers so that "Go to Definition" reaches it, so an assertion that
+  // only holds under one of them shows up as an error in their editor.
+  //
+  // expectType<
+  //   Parameters<typeof array.findIndex>[0],
+  //   (value: E, index: number, arr: readonly E[]) => unknown
+  // >('=');
 
   expectType<
     typeof predicate,
@@ -162,10 +169,17 @@ const findLastImpl = <E,>(
     predicate as () => boolean,
   );
 
-  expectType<
-    Parameters<typeof array.findIndex>[0],
-    (value: E, index: number, arr: readonly E[]) => unknown
-  >('=');
+  // Left as a comment rather than asserted. This pinned the shape of the
+  // standard library's `findIndex`, and the shape differs between the stock
+  // library and the strict one — `(value, index, obj: this) => boolean` there
+  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships
+  // to consumers so that "Go to Definition" reaches it, so an assertion that
+  // only holds under one of them shows up as an error in their editor.
+  //
+  // expectType<
+  //   Parameters<typeof array.findIndex>[0],
+  //   (value: E, index: number, arr: readonly E[]) => unknown
+  // >('=');
 
   expectType<
     typeof predicate,

package/src/array/impl/array-utils-shape-invariants.test.mts

@@ -267,7 +267,7 @@ describe('Arr shape invariants', () => {
     );
 
     assert.deepStrictEqual<readonly string[]>(
-      toSortedNonNumberInGenericContext(['c', 'a', 'b'] as const),
+      toSortedNonNumberInGenericContext(['c', 'a', 'b']),
       ['a', 'b', 'c'],
     );
 
@@ -313,12 +313,12 @@ describe('Arr shape invariants', () => {
     );
 
     assert.deepStrictEqual<readonly number[]>(
-      uniqInGenericContext([1, 1, 2] as const),
+      uniqInGenericContext([1, 1, 2]),
       [1, 2],
     );
 
     assert.deepStrictEqual<readonly number[]>(
-      uniqByInGenericContext([1, 1, 2] as const),
+      uniqByInGenericContext([1, 1, 2]),
       [1, 2],
     );
   });

package/src/array/impl/array-utils-transformation.test.mts

@@ -77,7 +77,7 @@ describe('Arr transformations', () => {
         boxes: T,
       ): Readonly<{ [K in keyof T]: unknown }> => map(boxes, (b) => b.v);
 
-      const result = mapValues([{ v: 1 }, { v: 'a' }] as const);
+      const result = mapValues([{ v: 1 }, { v: 'a' }]);
 
       expectType<typeof result, FixedLengthTuple<2, unknown>>('=');
 

package/src/functional/async-result/async-result.mts

@@ -0,0 +1,17 @@
+import { type Result } from '../result/index.mjs';
+
+/**
+ * Represents an asynchronous computation that can either succeed (`Ok`) or
+ * fail (`Err`) — a `Promise` that resolves to a `Result<S, E>`.
+ *
+ * Unlike a raw `Promise`, an `AsyncResult` never rejects for expected
+ * failures: errors are carried in the `Err` channel with a concrete type `E`,
+ * so they can be handled with the same combinators as a synchronous
+ * `Result`.
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ */
+export type AsyncResult<S, E> = Promise<Result<S, E>>;
+
+export * as AsyncResult from './impl/index.mjs';

package/src/functional/async-result/impl/async-result-flat-map.mts

@@ -0,0 +1,99 @@
+import { Result, type UnknownResult } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+import {
+  type UnknownAsyncResult,
+  type UnwrapErr,
+  type UnwrapOk,
+} from './types.mjs';
+
+/**
+ * Applies a function that returns an `AsyncResult` or a `Result` to the
+ * success value of an `AsyncResult`. If the input resolves to `Err`, the
+ * original `Err` is passed through and the function is not called. This is
+ * the monadic bind operation for `AsyncResult`.
+ *
+ * @example
+ *
+ * ```ts
+ * const parseNumber = (input: string): Result<number, string> => {
+ *   const num = Number.parseInt(input, 10);
+ *
+ *   return Number.isNaN(num) ? Result.err('not a number') : Result.ok(num);
+ * };
+ *
+ * const input = AsyncResult.fromPromise(
+ *   Promise.resolve('42'),
+ *   () => 'failed',
+ * );
+ *
+ * const parsed = await AsyncResult.flatMap(input, parseNumber);
+ *
+ * assert.deepStrictEqual(parsed, Result.ok(42));
+ * ```
+ *
+ * @template S The type of the success value of the input.
+ * @template E The type of the error value of the input.
+ * @template R2 The `AsyncResult` or `Result` type returned by the function.
+ * @param asyncResult The `AsyncResult` to flat map.
+ * @param flatMapFn The function to apply that returns an `AsyncResult` or a
+ *   `Result`.
+ * @returns The result of applying the function, or the original `Err`.
+ */
+export function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(
+  asyncResult: AsyncResult<S, E>,
+  flatMapFn: (value: S) => R2,
+): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
+
+// Curried version
+//
+// The function's return type is captured as a whole (`R2`) and unwrapped with
+// `UnwrapOk` / `UnwrapErr`, instead of being written as
+// `AsyncResult<S2, E2> | Result<S2, E2>` with separate `S2` / `E2` type
+// parameters. With the union form, inference for `E2` collects a candidate
+// from matching `Ok<S2>` against `Err<E2>` (both have a `value` property), so
+// `E2` ends up as the success type and the call fails to type-check even for
+// a function annotated as returning `Result<S2, E2>`.
+export function flatMap<S, R2 extends UnknownAsyncResult | UnknownResult>(
+  flatMapFn: (value: S) => R2,
+): <E>(
+  asyncResult: AsyncResult<S, E>,
+) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
+
+export function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(
+  ...args:
+    | readonly [asyncResult: AsyncResult<S, E>, flatMapFn: (value: S) => R2]
+    | readonly [flatMapFn: (value: S) => R2]
+):
+  | AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>
+  | ((
+      asyncResult: AsyncResult<S, E>,
+    ) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>) {
+  switch (args.length) {
+    case 2: {
+      // Direct version: first argument is asyncResult
+      const [asyncResult, flatMapFn] = args;
+
+      return flatMapImpl(asyncResult, flatMapFn);
+    }
+
+    case 1: {
+      // Curried version
+      const [flatMapFn] = args;
+
+      return (asyncResult: AsyncResult<S, E>) =>
+        flatMapImpl(asyncResult, flatMapFn);
+    }
+  }
+}
+
+const flatMapImpl = async <S, E, R2 extends UnknownAsyncResult | UnknownResult>(
+  asyncResult: AsyncResult<S, E>,
+  flatMapFn: (value: S) => R2,
+): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>> => {
+  const result = await asyncResult;
+
+  return Result.isErr(result)
+    ? result
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      ((await flatMapFn(result.value)) as Result<UnwrapOk<R2>, UnwrapErr<R2>>);
+};

package/src/functional/async-result/impl/async-result-from-promise.mts

@@ -0,0 +1,69 @@
+import { Result } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+
+/**
+ * Converts a `Promise` into an `AsyncResult`. If the input Promise resolves,
+ * the `AsyncResult` resolves to `Ok` with the resolved value. If the input
+ * Promise rejects, the rejection reason is passed through `mapError` and the
+ * `AsyncResult` resolves to `Err` with the mapped error.
+ *
+ * Passing `mapError` is what gives the error channel a concrete type `E`.
+ * Omitting it carries the rejection reason through untouched, leaving the
+ * error channel as `unknown` — the same contract as `Result.fromPromise`.
+ *
+ * @example
+ *
+ * ```ts
+ * const resolved = await AsyncResult.fromPromise(
+ *   Promise.resolve('ok'),
+ *   (error) => `failed: ${String(error)}`,
+ * );
+ *
+ * const rejected = await AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   (error) => (isError(error) ? error.message : 'unknown'),
+ * );
+ *
+ * assert.deepStrictEqual(resolved, Result.ok('ok'));
+ *
+ * assert.deepStrictEqual(rejected, Result.err('boom'));
+ *
+ * // Without `mapError`, the rejection reason is carried as-is.
+ * const untyped = await AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ * );
+ *
+ * assert.isTrue(Result.isErr(untyped));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @param promise The Promise to convert.
+ * @param mapError The function applied to the rejection reason to produce the
+ *   error value. Omit it to carry the rejection reason as `unknown`.
+ * @returns An `AsyncResult<S, E>` that never rejects for the input Promise's
+ *   failure.
+ */
+export function fromPromise<S>(promise: Promise<S>): AsyncResult<S, unknown>;
+
+export function fromPromise<S, E>(
+  promise: Promise<S>,
+  mapError: (error: unknown) => E,
+): AsyncResult<S, E>;
+
+export function fromPromise<S, E>(
+  promise: Promise<S>,
+  mapError?: (error: unknown) => E,
+): AsyncResult<S, E> | AsyncResult<S, unknown> {
+  return mapError === undefined
+    ? fromPromiseImpl(promise, (error: unknown) => error)
+    : fromPromiseImpl(promise, mapError);
+}
+
+const fromPromiseImpl = <S, E>(
+  promise: Promise<S>,
+  mapError: (error: unknown) => E,
+): AsyncResult<S, E> =>
+  promise
+    .then((value) => Result.ok(value))
+    .catch((error: unknown) => Result.err(mapError(error)));