unthrown 3.1.0 → 4.0.0

package/dist/index.cjs

@@ -14,6 +14,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 * A `Defect` is never wrapped in an `UnwrapError`: its original cause is
 * re-thrown (with its original stack) instead.
 *
+* `unwrap()` and `unwrapErr()` are type-gated (`this: Result<T, never>` /
+* `Result<never, E>`), so the wrong-variant branch that throws this is
+* unreachable through well-typed code — it remains only as a defensive guard
+* against unsound runtime misuse (e.g. an `as` cast past the gate).
+*
 * @typeParam E - the type of the {@link UnwrapError.error} it carries.
 *
 * @category Errors
@@ -713,9 +718,9 @@ function isDefectMarker(x) {
 * import { fromNullable } from "unthrown";
 *
 * const map = new Map([["a", 1]]);
-* fromNullable(map.get("a"), () => "absent").unwrap(); // => 1
+* fromNullable(map.get("a"), () => "absent").unwrapOr(0); // => 1
 * fromNullable(map.get("z"), () => "absent"); // => Err("absent")
-* fromNullable(0, () => "absent").unwrap(); // => 0 (falsy but present)
+* fromNullable(0, () => "absent").unwrapOr(-1); // => 0 (falsy but present)
 * ```
 */
 function fromNullable(value, onAbsent) {
@@ -759,7 +764,7 @@ function fromNullable(value, onAbsent) {
 *     cause instanceof SyntaxError ? ("invalid_json" as const) : defect(cause),
 * );
 *
-* parse('{"ok":true}').unwrap(); // => { ok: true }
+* parse('{"ok":true}').unwrapOr(null); // => { ok: true }
 * parse("nope"); // => Err("invalid_json")
 * ```
 */
@@ -806,8 +811,8 @@ function fromThrowable(fn, qualify) {
 *   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
 * );
 *
-* user.unwrap(); // => the fetched user (on success)
-* // when fetchUser rejects with NotFoundError: => Err("not_found")
+* if (user.isOk()) user.value; // => the fetched user
+* // when fetchUser rejects with NotFoundError: user is Err("not_found")
 * ```
 */
 function fromPromise(promise, qualify) {
@@ -1068,8 +1073,13 @@ const AsyncResult = {
 *
 * @remarks
 * Extend the returned class to declare a concrete error. Supply the payload with
-* an instantiation expression; omit it for a payload-less error. A `message`
-* field in the payload is forwarded to `Error`. The `_tag` always reflects
+* an instantiation expression; omit it for a payload-less error. The `message`
+* is **not** a payload field — it is the human string owned by `Error`, not
+* structured data, so it is reserved. Define it once per subclass the standard
+* way, `override message = "…"` (it may interpolate the payload via `this`,
+* which the base populates before the subclass field initialiser runs); a
+* payload `message` is rejected at compile time, so contextual detail lives in
+* typed fields, never baked into per-call prose. The `_tag` always reflects
 * `tag` and cannot be overridden by the payload. `name` is likewise reserved —
 * it is the display label (set it with `options.name`); a payload `name` is
 * rejected at compile time (and excluded from the instance type), so it can't
@@ -1084,11 +1094,14 @@ const AsyncResult = {
 * ```ts
 * class RetryableError extends TaggedError("@my-lib/RetryableError", {
 *   name: "RetryableError",
-* })<{ message: string }> {}
-*
-* const e = new RetryableError({ message: "boom" });
-* e._tag; // "@my-lib/RetryableError" — namespaced discriminant
-* e.name; // "RetryableError"          — clean display name
+* }) {
+*   override message = "operation failed; safe to retry";
+* }
+*
+* const e = new RetryableError();
+* e._tag;    // "@my-lib/RetryableError" — namespaced discriminant
+* e.name;    // "RetryableError"          — clean display name
+* e.message; // "operation failed; safe to retry" — the standard Error.message
 * ```
 *
 * @typeParam Tag - the string literal discriminant.
@@ -1112,10 +1125,11 @@ function TaggedError(tag, options) {
 	class TaggedErrorBase extends Error {
 		_tag;
 		constructor(props) {
-			super(typeof props?.["message"] === "string" ? props["message"] : void 0);
+			super();
 			if (props) Object.assign(this, props);
 			this._tag = tag;
 			this.name = displayName;
+			delete this.message;
 			Object.setPrototypeOf(this, new.target.prototype);
 		}
 	}

package/dist/index.d.cts

@@ -254,20 +254,34 @@ type ResultMethods<T, E> = {
   /**
    * Extract the success value.
    *
+   * @remarks
+   * Compiles only when the error channel is empty (`E = never`) — eliminate
+   * modeled errors first (`match` / `recover` / `orElse`), or reach for the
+   * `unwrapOr` / `unwrapOrElse` / `getOrNull` / `getOrUndefined` family (which
+   * recover an `Err`). If you get a `'this' context` type error here, that is
+   * the gate: the receiver still has a non-`never` error channel.
+   *
+   * `E = never` empties only the **modeled** error channel — a `Defect` can
+   * still be present, and `unwrap()` **rethrows its original cause** (it
+   * _panics_); `Result<T, never>` does not mean `unwrap()` cannot throw.
+   *
    * @returns the `Ok` value.
-   * @throws On `Err`, an {@link UnwrapError} carrying the error. On a `Defect`,
-   * re-throws the **original cause** with its original stack, so an unhandled
-   * Defect surfaces at the global handler as the real failure.
    */
-  unwrap(): T;
+  unwrap(this: Result$1<T, never>): T;
   /**
    * Extract the modeled error.
    *
+   * @remarks
+   * Compiles only when the success channel is empty (`T = never`) — eliminate
+   * the success case first. `T = never` is rarely the case in practice (a
+   * `Result` you hold usually still has a success type), so to inspect an
+   * error prefer an `isErr()` guard or, in tests, `@unthrown/vitest`'s
+   * `toBeErrWith`. A `Defect` still **rethrows its original cause** (a defect is
+   * a bug, not an absent value), so this does not mean `unwrapErr()` can't throw.
+   *
    * @returns the `Err` value.
-   * @throws On `Ok`, an {@link UnwrapError} carrying the value. On a `Defect`,
-   * re-throws the original cause.
    */
-  unwrapErr(): E;
+  unwrapErr(this: Result$1<never, E>): E;
   /**
    * The success value, or `fallback` on `Err`.
    *
@@ -531,11 +545,17 @@ type AsyncResultMethods<T, E> = {
     defect: (cause: unknown) => R;
   }): Promise<R>;
   /**
-   * Asynchronous {@link ResultMethods.unwrap | unwrap}. The returned promise
-   * rejects on `Err`/`Defect`.
+   * Asynchronous {@link ResultMethods.unwrap | unwrap}. Compiles only when the
+   * error channel is empty (`this: AsyncResult<T, never>`); the returned promise
+   * rejects on a `Defect` (rethrowing its cause).
    */
-  unwrap(): Promise<T>; /** Asynchronous {@link ResultMethods.unwrapErr | unwrapErr}. */
-  unwrapErr(): Promise<E>; /** Asynchronous {@link ResultMethods.unwrapOr | unwrapOr}. */
+  unwrap(this: AsyncResult$1<T, never>): Promise<T>;
+  /**
+   * Asynchronous {@link ResultMethods.unwrapErr | unwrapErr}. Compiles only when
+   * the success channel is empty (`this: AsyncResult<never, E>`); the returned
+   * promise rejects on a `Defect` (rethrowing its cause).
+   */
+  unwrapErr(this: AsyncResult$1<never, E>): Promise<E>; /** Asynchronous {@link ResultMethods.unwrapOr | unwrapOr}. */
   unwrapOr<U>(fallback: U): Promise<T | U>; /** Asynchronous {@link ResultMethods.unwrapOrElse | unwrapOrElse}. */
   unwrapOrElse<U>(f: (error: E) => U): Promise<T | U>; /** Asynchronous {@link ResultMethods.getOrNull | getOrNull}. */
   getOrNull(): Promise<T | null>; /** Asynchronous {@link ResultMethods.getOrUndefined | getOrUndefined}. */
@@ -743,6 +763,11 @@ declare function isDefect<T, E>(r: Result$1<T, E>): r is DefectView<T, E>;
  * A `Defect` is never wrapped in an `UnwrapError`: its original cause is
  * re-thrown (with its original stack) instead.
  *
+ * `unwrap()` and `unwrapErr()` are type-gated (`this: Result<T, never>` /
+ * `Result<never, E>`), so the wrong-variant branch that throws this is
+ * unreachable through well-typed code — it remains only as a defensive guard
+ * against unsound runtime misuse (e.g. an `as` cast past the gate).
+ *
  * @typeParam E - the type of the {@link UnwrapError.error} it carries.
  *
  * @category Errors
@@ -868,9 +893,9 @@ type Defect = {
  * import { fromNullable } from "unthrown";
  *
  * const map = new Map([["a", 1]]);
- * fromNullable(map.get("a"), () => "absent").unwrap(); // => 1
+ * fromNullable(map.get("a"), () => "absent").unwrapOr(0); // => 1
  * fromNullable(map.get("z"), () => "absent"); // => Err("absent")
- * fromNullable(0, () => "absent").unwrap(); // => 0 (falsy but present)
+ * fromNullable(0, () => "absent").unwrapOr(-1); // => 0 (falsy but present)
  * ```
  */
 declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () => E): Result$1<NonNullable<T>, E>;
@@ -912,7 +937,7 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  *     cause instanceof SyntaxError ? ("invalid_json" as const) : defect(cause),
  * );
  *
- * parse('{"ok":true}').unwrap(); // => { ok: true }
+ * parse('{"ok":true}').unwrapOr(null); // => { ok: true }
  * parse("nope"); // => Err("invalid_json")
  * ```
  */
@@ -950,8 +975,8 @@ declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T,
  *   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
  * );
  *
- * user.unwrap(); // => the fetched user (on success)
- * // when fetchUser rejects with NotFoundError: => Err("not_found")
+ * if (user.isOk()) user.value; // => the fetched user
+ * // when fetchUser rejects with NotFoundError: user is Err("not_found")
  * ```
  */
 declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R): AsyncResult$1<T, Exclude<R, Defect>>;
@@ -1199,7 +1224,7 @@ type Props = Record<string, unknown>;
  *
  * @category Types
  */
-type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly<Omit<A, "name">> & {
+type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly<Omit<A, "name" | "message">> & {
   readonly _tag: Tag;
 };
 /**
@@ -1208,10 +1233,13 @@ type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly
  *
  * @remarks
  * When the payload is empty, the constructor takes **no** arguments (the
- * `keyof A extends never ? void : A` trick); otherwise it takes the payload. A
- * `name` key is **rejected** (`name?: never`) because it is reserved for the
- * display label — mirroring how {@link TaggedErrorInstance} excludes it — so the
- * reservation is enforced at the call site, not just ignored at runtime.
+ * `keyof A extends never ? void : A` trick); otherwise it takes the payload. The
+ * `name` and `message` keys are both **rejected** (`name?: never` /
+ * `message?: never`) because both are reserved: `name` is the display label, and
+ * `message` is the human string owned by `Error`. Set the message the standard
+ * way — `override message = "…"` (or a constructor override) on the subclass —
+ * never as a free-form per-call payload field. The reservations are enforced at
+ * the call site, mirroring how {@link TaggedErrorInstance} excludes both.
  *
  * @typeParam Tag - the string literal discriminant.
  *
@@ -1220,6 +1248,7 @@ type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly
 type TaggedErrorConstructor<Tag extends string> = {
   new <A extends Props = {}>(args: keyof A extends never ? void : A & {
     readonly name?: never;
+    readonly message?: never;
   }): TaggedErrorInstance<Tag, A>;
 };
 /**
@@ -1228,8 +1257,13 @@ type TaggedErrorConstructor<Tag extends string> = {
  *
  * @remarks
  * Extend the returned class to declare a concrete error. Supply the payload with
- * an instantiation expression; omit it for a payload-less error. A `message`
- * field in the payload is forwarded to `Error`. The `_tag` always reflects
+ * an instantiation expression; omit it for a payload-less error. The `message`
+ * is **not** a payload field — it is the human string owned by `Error`, not
+ * structured data, so it is reserved. Define it once per subclass the standard
+ * way, `override message = "…"` (it may interpolate the payload via `this`,
+ * which the base populates before the subclass field initialiser runs); a
+ * payload `message` is rejected at compile time, so contextual detail lives in
+ * typed fields, never baked into per-call prose. The `_tag` always reflects
  * `tag` and cannot be overridden by the payload. `name` is likewise reserved —
  * it is the display label (set it with `options.name`); a payload `name` is
  * rejected at compile time (and excluded from the instance type), so it can't
@@ -1244,11 +1278,14 @@ type TaggedErrorConstructor<Tag extends string> = {
  * ```ts
  * class RetryableError extends TaggedError("@my-lib/RetryableError", {
  *   name: "RetryableError",
- * })<{ message: string }> {}
+ * }) {
+ *   override message = "operation failed; safe to retry";
+ * }
  *
- * const e = new RetryableError({ message: "boom" });
- * e._tag; // "@my-lib/RetryableError" — namespaced discriminant
- * e.name; // "RetryableError"          — clean display name
+ * const e = new RetryableError();
+ * e._tag;    // "@my-lib/RetryableError" — namespaced discriminant
+ * e.name;    // "RetryableError"          — clean display name
+ * e.message; // "operation failed; safe to retry" — the standard Error.message
  * ```
  *
  * @typeParam Tag - the string literal discriminant.

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}

package/dist/index.d.mts

@@ -254,20 +254,34 @@ type ResultMethods<T, E> = {
   /**
    * Extract the success value.
    *
+   * @remarks
+   * Compiles only when the error channel is empty (`E = never`) — eliminate
+   * modeled errors first (`match` / `recover` / `orElse`), or reach for the
+   * `unwrapOr` / `unwrapOrElse` / `getOrNull` / `getOrUndefined` family (which
+   * recover an `Err`). If you get a `'this' context` type error here, that is
+   * the gate: the receiver still has a non-`never` error channel.
+   *
+   * `E = never` empties only the **modeled** error channel — a `Defect` can
+   * still be present, and `unwrap()` **rethrows its original cause** (it
+   * _panics_); `Result<T, never>` does not mean `unwrap()` cannot throw.
+   *
    * @returns the `Ok` value.
-   * @throws On `Err`, an {@link UnwrapError} carrying the error. On a `Defect`,
-   * re-throws the **original cause** with its original stack, so an unhandled
-   * Defect surfaces at the global handler as the real failure.
    */
-  unwrap(): T;
+  unwrap(this: Result$1<T, never>): T;
   /**
    * Extract the modeled error.
    *
+   * @remarks
+   * Compiles only when the success channel is empty (`T = never`) — eliminate
+   * the success case first. `T = never` is rarely the case in practice (a
+   * `Result` you hold usually still has a success type), so to inspect an
+   * error prefer an `isErr()` guard or, in tests, `@unthrown/vitest`'s
+   * `toBeErrWith`. A `Defect` still **rethrows its original cause** (a defect is
+   * a bug, not an absent value), so this does not mean `unwrapErr()` can't throw.
+   *
    * @returns the `Err` value.
-   * @throws On `Ok`, an {@link UnwrapError} carrying the value. On a `Defect`,
-   * re-throws the original cause.
    */
-  unwrapErr(): E;
+  unwrapErr(this: Result$1<never, E>): E;
   /**
    * The success value, or `fallback` on `Err`.
    *
@@ -531,11 +545,17 @@ type AsyncResultMethods<T, E> = {
     defect: (cause: unknown) => R;
   }): Promise<R>;
   /**
-   * Asynchronous {@link ResultMethods.unwrap | unwrap}. The returned promise
-   * rejects on `Err`/`Defect`.
+   * Asynchronous {@link ResultMethods.unwrap | unwrap}. Compiles only when the
+   * error channel is empty (`this: AsyncResult<T, never>`); the returned promise
+   * rejects on a `Defect` (rethrowing its cause).
    */
-  unwrap(): Promise<T>; /** Asynchronous {@link ResultMethods.unwrapErr | unwrapErr}. */
-  unwrapErr(): Promise<E>; /** Asynchronous {@link ResultMethods.unwrapOr | unwrapOr}. */
+  unwrap(this: AsyncResult$1<T, never>): Promise<T>;
+  /**
+   * Asynchronous {@link ResultMethods.unwrapErr | unwrapErr}. Compiles only when
+   * the success channel is empty (`this: AsyncResult<never, E>`); the returned
+   * promise rejects on a `Defect` (rethrowing its cause).
+   */
+  unwrapErr(this: AsyncResult$1<never, E>): Promise<E>; /** Asynchronous {@link ResultMethods.unwrapOr | unwrapOr}. */
   unwrapOr<U>(fallback: U): Promise<T | U>; /** Asynchronous {@link ResultMethods.unwrapOrElse | unwrapOrElse}. */
   unwrapOrElse<U>(f: (error: E) => U): Promise<T | U>; /** Asynchronous {@link ResultMethods.getOrNull | getOrNull}. */
   getOrNull(): Promise<T | null>; /** Asynchronous {@link ResultMethods.getOrUndefined | getOrUndefined}. */
@@ -743,6 +763,11 @@ declare function isDefect<T, E>(r: Result$1<T, E>): r is DefectView<T, E>;
  * A `Defect` is never wrapped in an `UnwrapError`: its original cause is
  * re-thrown (with its original stack) instead.
  *
+ * `unwrap()` and `unwrapErr()` are type-gated (`this: Result<T, never>` /
+ * `Result<never, E>`), so the wrong-variant branch that throws this is
+ * unreachable through well-typed code — it remains only as a defensive guard
+ * against unsound runtime misuse (e.g. an `as` cast past the gate).
+ *
  * @typeParam E - the type of the {@link UnwrapError.error} it carries.
  *
  * @category Errors
@@ -868,9 +893,9 @@ type Defect = {
  * import { fromNullable } from "unthrown";
  *
  * const map = new Map([["a", 1]]);
- * fromNullable(map.get("a"), () => "absent").unwrap(); // => 1
+ * fromNullable(map.get("a"), () => "absent").unwrapOr(0); // => 1
  * fromNullable(map.get("z"), () => "absent"); // => Err("absent")
- * fromNullable(0, () => "absent").unwrap(); // => 0 (falsy but present)
+ * fromNullable(0, () => "absent").unwrapOr(-1); // => 0 (falsy but present)
  * ```
  */
 declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () => E): Result$1<NonNullable<T>, E>;
@@ -912,7 +937,7 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  *     cause instanceof SyntaxError ? ("invalid_json" as const) : defect(cause),
  * );
  *
- * parse('{"ok":true}').unwrap(); // => { ok: true }
+ * parse('{"ok":true}').unwrapOr(null); // => { ok: true }
  * parse("nope"); // => Err("invalid_json")
  * ```
  */
@@ -950,8 +975,8 @@ declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T,
  *   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
  * );
  *
- * user.unwrap(); // => the fetched user (on success)
- * // when fetchUser rejects with NotFoundError: => Err("not_found")
+ * if (user.isOk()) user.value; // => the fetched user
+ * // when fetchUser rejects with NotFoundError: user is Err("not_found")
  * ```
  */
 declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R): AsyncResult$1<T, Exclude<R, Defect>>;
@@ -1199,7 +1224,7 @@ type Props = Record<string, unknown>;
  *
  * @category Types
  */
-type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly<Omit<A, "name">> & {
+type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly<Omit<A, "name" | "message">> & {
   readonly _tag: Tag;
 };
 /**
@@ -1208,10 +1233,13 @@ type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly
  *
  * @remarks
  * When the payload is empty, the constructor takes **no** arguments (the
- * `keyof A extends never ? void : A` trick); otherwise it takes the payload. A
- * `name` key is **rejected** (`name?: never`) because it is reserved for the
- * display label — mirroring how {@link TaggedErrorInstance} excludes it — so the
- * reservation is enforced at the call site, not just ignored at runtime.
+ * `keyof A extends never ? void : A` trick); otherwise it takes the payload. The
+ * `name` and `message` keys are both **rejected** (`name?: never` /
+ * `message?: never`) because both are reserved: `name` is the display label, and
+ * `message` is the human string owned by `Error`. Set the message the standard
+ * way — `override message = "…"` (or a constructor override) on the subclass —
+ * never as a free-form per-call payload field. The reservations are enforced at
+ * the call site, mirroring how {@link TaggedErrorInstance} excludes both.
  *
  * @typeParam Tag - the string literal discriminant.
  *
@@ -1220,6 +1248,7 @@ type TaggedErrorInstance<Tag extends string, A extends Props> = Error & Readonly
 type TaggedErrorConstructor<Tag extends string> = {
   new <A extends Props = {}>(args: keyof A extends never ? void : A & {
     readonly name?: never;
+    readonly message?: never;
   }): TaggedErrorInstance<Tag, A>;
 };
 /**
@@ -1228,8 +1257,13 @@ type TaggedErrorConstructor<Tag extends string> = {
  *
  * @remarks
  * Extend the returned class to declare a concrete error. Supply the payload with
- * an instantiation expression; omit it for a payload-less error. A `message`
- * field in the payload is forwarded to `Error`. The `_tag` always reflects
+ * an instantiation expression; omit it for a payload-less error. The `message`
+ * is **not** a payload field — it is the human string owned by `Error`, not
+ * structured data, so it is reserved. Define it once per subclass the standard
+ * way, `override message = "…"` (it may interpolate the payload via `this`,
+ * which the base populates before the subclass field initialiser runs); a
+ * payload `message` is rejected at compile time, so contextual detail lives in
+ * typed fields, never baked into per-call prose. The `_tag` always reflects
  * `tag` and cannot be overridden by the payload. `name` is likewise reserved —
  * it is the display label (set it with `options.name`); a payload `name` is
  * rejected at compile time (and excluded from the instance type), so it can't
@@ -1244,11 +1278,14 @@ type TaggedErrorConstructor<Tag extends string> = {
  * ```ts
  * class RetryableError extends TaggedError("@my-lib/RetryableError", {
  *   name: "RetryableError",
- * })<{ message: string }> {}
+ * }) {
+ *   override message = "operation failed; safe to retry";
+ * }
  *
- * const e = new RetryableError({ message: "boom" });
- * e._tag; // "@my-lib/RetryableError" — namespaced discriminant
- * e.name; // "RetryableError"          — clean display name
+ * const e = new RetryableError();
+ * e._tag;    // "@my-lib/RetryableError" — namespaced discriminant
+ * e.name;    // "RetryableError"          — clean display name
+ * e.message; // "operation failed; safe to retry" — the standard Error.message
  * ```
  *
  * @typeParam Tag - the string literal discriminant.

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -13,6 +13,11 @@
 * A `Defect` is never wrapped in an `UnwrapError`: its original cause is
 * re-thrown (with its original stack) instead.
 *
+* `unwrap()` and `unwrapErr()` are type-gated (`this: Result<T, never>` /
+* `Result<never, E>`), so the wrong-variant branch that throws this is
+* unreachable through well-typed code — it remains only as a defensive guard
+* against unsound runtime misuse (e.g. an `as` cast past the gate).
+*
 * @typeParam E - the type of the {@link UnwrapError.error} it carries.
 *
 * @category Errors
@@ -712,9 +717,9 @@ function isDefectMarker(x) {
 * import { fromNullable } from "unthrown";
 *
 * const map = new Map([["a", 1]]);
-* fromNullable(map.get("a"), () => "absent").unwrap(); // => 1
+* fromNullable(map.get("a"), () => "absent").unwrapOr(0); // => 1
 * fromNullable(map.get("z"), () => "absent"); // => Err("absent")
-* fromNullable(0, () => "absent").unwrap(); // => 0 (falsy but present)
+* fromNullable(0, () => "absent").unwrapOr(-1); // => 0 (falsy but present)
 * ```
 */
 function fromNullable(value, onAbsent) {
@@ -758,7 +763,7 @@ function fromNullable(value, onAbsent) {
 *     cause instanceof SyntaxError ? ("invalid_json" as const) : defect(cause),
 * );
 *
-* parse('{"ok":true}').unwrap(); // => { ok: true }
+* parse('{"ok":true}').unwrapOr(null); // => { ok: true }
 * parse("nope"); // => Err("invalid_json")
 * ```
 */
@@ -805,8 +810,8 @@ function fromThrowable(fn, qualify) {
 *   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
 * );
 *
-* user.unwrap(); // => the fetched user (on success)
-* // when fetchUser rejects with NotFoundError: => Err("not_found")
+* if (user.isOk()) user.value; // => the fetched user
+* // when fetchUser rejects with NotFoundError: user is Err("not_found")
 * ```
 */
 function fromPromise(promise, qualify) {
@@ -1067,8 +1072,13 @@ const AsyncResult = {
 *
 * @remarks
 * Extend the returned class to declare a concrete error. Supply the payload with
-* an instantiation expression; omit it for a payload-less error. A `message`
-* field in the payload is forwarded to `Error`. The `_tag` always reflects
+* an instantiation expression; omit it for a payload-less error. The `message`
+* is **not** a payload field — it is the human string owned by `Error`, not
+* structured data, so it is reserved. Define it once per subclass the standard
+* way, `override message = "…"` (it may interpolate the payload via `this`,
+* which the base populates before the subclass field initialiser runs); a
+* payload `message` is rejected at compile time, so contextual detail lives in
+* typed fields, never baked into per-call prose. The `_tag` always reflects
 * `tag` and cannot be overridden by the payload. `name` is likewise reserved —
 * it is the display label (set it with `options.name`); a payload `name` is
 * rejected at compile time (and excluded from the instance type), so it can't
@@ -1083,11 +1093,14 @@ const AsyncResult = {
 * ```ts
 * class RetryableError extends TaggedError("@my-lib/RetryableError", {
 *   name: "RetryableError",
-* })<{ message: string }> {}
-*
-* const e = new RetryableError({ message: "boom" });
-* e._tag; // "@my-lib/RetryableError" — namespaced discriminant
-* e.name; // "RetryableError"          — clean display name
+* }) {
+*   override message = "operation failed; safe to retry";
+* }
+*
+* const e = new RetryableError();
+* e._tag;    // "@my-lib/RetryableError" — namespaced discriminant
+* e.name;    // "RetryableError"          — clean display name
+* e.message; // "operation failed; safe to retry" — the standard Error.message
 * ```
 *
 * @typeParam Tag - the string literal discriminant.
@@ -1111,10 +1124,11 @@ function TaggedError(tag, options) {
 	class TaggedErrorBase extends Error {
 		_tag;
 		constructor(props) {
-			super(typeof props?.["message"] === "string" ? props["message"] : void 0);
+			super();
 			if (props) Object.assign(this, props);
 			this._tag = tag;
 			this.name = displayName;
+			delete this.message;
 			Object.setPrototypeOf(this, new.target.prototype);
 		}
 	}

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/core.ts","../src/constructors.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"sourcesContent":["// unthrown — the runtime engine.\n//\n// `Result` is the PUBLIC discriminated union (tag/value/error/cause + methods).\n// `Res` is a method holder only: its prototype carries the implementations, and\n// instances are built by `okRes`/`errRes`/`defectRes` with `Object.create` +\n// the variant type — so a builder returns a value that already *is* a union\n// member (no `as unknown as`). `Res` is never exported from `index.ts`.\n// `AsyncRes` wraps a `Promise<Result>` constructed never to reject and operates\n// purely on the public union (via `r.tag`). See CLAUDE.md → \"Internal design\".\n//\n// Type-changing pass-throughs (e.g. `map` reusing an `Err` as a differently-typed\n// `Result`) all funnel through the single `passThrough` helper — one sound\n// `as unknown as` in one place, rather than boxed's inline cast at every branch.\n// The only other casts are the builders' construction (`as OkView`/…) and the\n// `bind`/`let` scope merge (a computed key can't be spelled at the type level).\n\nimport type {\n  AsyncResult,\n  Bound,\n  DefectView,\n  ErrView,\n  NotThenable,\n  OkView,\n  Result,\n} from \"./types.js\";\n\n/**\n * Thrown by a {@link Result}'s `unwrap` / `unwrapErr` when the assertion is\n * wrong on a *modeled* result — `unwrap()` on an `Err`, or `unwrapErr()` on an\n * `Ok`.\n *\n * @remarks\n * The offending value is exposed two ways: the typed {@link UnwrapError.error}\n * property for programmatic access, and the standard `Error.cause` for the\n * runtime and devtools to chain — when `E` is an `Error` (e.g. a `TaggedError`)\n * its original stack is printed under \"caused by\".\n *\n * A `Defect` is never wrapped in an `UnwrapError`: its original cause is\n * re-thrown (with its original stack) instead.\n *\n * @typeParam E - the type of the {@link UnwrapError.error} it carries.\n *\n * @category Errors\n */\nexport class UnwrapError<E = unknown> extends Error {\n  /**\n   * The offending value: the `Err` error for `unwrap()`, or the `Ok` value for\n   * `unwrapErr()`.\n   */\n  readonly error: E;\n  constructor(error: E) {\n    super(\"unthrown: called unwrap on a non-matching Result\", { cause: error });\n    this.name = \"UnwrapError\";\n    this.error = error;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\n/**\n * Method holder for {@link Result}. Never instantiated with `new` and never\n * exported; the builders below attach its prototype to plain objects. Every\n * method types `this` as the public `Result` union, so it narrows on `tag`.\n *\n * @internal\n */\nclass Res<T, E> {\n  map<U>(this: Result<T, E>, f: (value: T) => U & NotThenable<U>): Result<U, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return okRes(f(this.value));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatMap<U, E2>(this: Result<T, E>, f: (value: T) => Result<U, E2>): Result<U, E | E2> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return f(this.value);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tap<R>(this: Result<T, E>, f: (value: T) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Ok\") return this;\n    try {\n      f(this.value);\n      return this;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatTap<E2>(this: Result<T, E>, f: (value: T) => Result<unknown, E2>): Result<T, E | E2> {\n    if (this.tag !== \"Ok\") return this;\n    try {\n      const r = f(this.value);\n      // Keep the original value on success; an Err/Defect from `f` short-circuits.\n      return r.tag === \"Ok\" ? this : passThrough(r);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  bind<K extends string, U, E2>(\n    this: Result<T, E>,\n    name: K,\n    f: (scope: T) => Result<U, E2>,\n  ): Result<Bound<T, K, U>, E | E2> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      const r = f(this.value);\n      if (r.tag !== \"Ok\") return passThrough(r);\n      // The merged scope can't be spelled at the type level (a computed key\n      // widens to an index signature), so the constructed Ok is cast to `Bound`.\n      return okRes({ ...scopeOf(this.value), [name]: r.value }) as unknown as Result<\n        Bound<T, K, U>,\n        E | E2\n      >;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  let<K extends string, U>(\n    this: Result<T, E>,\n    name: K,\n    f: (scope: T) => U & NotThenable<U>,\n  ): Result<Bound<T, K, U>, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return okRes({ ...scopeOf(this.value), [name]: f(this.value) }) as unknown as Result<\n        Bound<T, K, U>,\n        E\n      >;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  as<U>(this: Result<T, E>, value: U): Result<U, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    return okRes(value);\n  }\n\n  mapErr<E2>(this: Result<T, E>, f: (error: E) => E2 & NotThenable<E2>): Result<T, E2> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      return errRes(f(this.error));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  orElse<U, E2>(this: Result<T, E>, f: (error: E) => Result<U, E2>): Result<T | U, E2> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      return f(this.error);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  recover<U>(this: Result<T, E>, f: (error: E) => U & NotThenable<U>): Result<T | U, never> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      return okRes(f(this.error));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tapErr<R>(this: Result<T, E>, f: (error: E) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      f(this.error);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.error);\n    }\n  }\n\n  flatTapErr<E2>(this: Result<T, E>, f: (error: E) => Result<unknown, E2>): Result<T, E | E2> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      const r = f(this.error);\n      // Keep the original error on the effect's success; an Err/Defect threads through.\n      return r.tag === \"Ok\" ? this : passThrough(r);\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.error);\n    }\n  }\n\n  recoverDefect<U, E2>(\n    this: Result<T, E>,\n    f: (cause: unknown) => Result<U, E2>,\n  ): Result<T | U, E | E2> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      return f(this.cause);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tapDefect<R>(this: Result<T, E>, f: (cause: unknown) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      f(this.cause);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.cause);\n    }\n  }\n\n  match<R>(\n    this: Result<T, E>,\n    cases: {\n      ok: (value: T) => R;\n      err: (error: E) => R;\n      defect: (cause: unknown) => R;\n    },\n  ): R {\n    switch (this.tag) {\n      case \"Ok\":\n        return cases.ok(this.value);\n      case \"Err\":\n        return cases.err(this.error);\n      case \"Defect\":\n        return cases.defect(this.cause);\n    }\n  }\n\n  unwrap(this: Result<T, E>): T {\n    switch (this.tag) {\n      case \"Ok\":\n        return this.value;\n      case \"Err\":\n        throw new UnwrapError(this.error);\n      case \"Defect\":\n        throw this.cause; // rethrow original cause, original stack\n    }\n  }\n\n  unwrapErr(this: Result<T, E>): E {\n    switch (this.tag) {\n      case \"Err\":\n        return this.error;\n      case \"Ok\":\n        throw new UnwrapError(this.value);\n      case \"Defect\":\n        throw this.cause;\n    }\n  }\n\n  unwrapOr<U>(this: Result<T, E>, fallback: U): T | U {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return fallback;\n  }\n\n  unwrapOrElse<U>(this: Result<T, E>, f: (error: E) => U): T | U {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return f(this.error);\n  }\n\n  getOrNull(this: Result<T, E>): T | null {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return null;\n  }\n\n  getOrUndefined(this: Result<T, E>): T | undefined {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return undefined;\n  }\n\n  isOk(this: Result<T, E>): this is OkView<T, E> {\n    return this.tag === \"Ok\";\n  }\n\n  isErr(this: Result<T, E>): this is ErrView<E, T> {\n    return this.tag === \"Err\";\n  }\n\n  isDefect(this: Result<T, E>): this is DefectView<T, E> {\n    return this.tag === \"Defect\";\n  }\n\n  toAsync(this: Result<T, E>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(Promise.resolve(this));\n  }\n}\n\nconst RESULT_PROTO = Res.prototype;\n\n/**\n * Construct an `Ok` result — a plain object on the {@link Res} prototype.\n *\n * @internal\n */\nexport function okRes<T, E>(value: T): Result<T, E> {\n  // Frozen so the `readonly` surface is real at runtime: a variant cannot be\n  // forged by mutating `tag`/payload after construction.\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Ok\" as const,\n      value,\n    }),\n  ) as OkView<T, E>;\n}\n\n/**\n * Construct an `Err` result.\n *\n * @internal\n */\nexport function errRes<T, E>(error: E): Result<T, E> {\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Err\" as const,\n      error,\n    }),\n  ) as ErrView<E, T>;\n}\n\n/**\n * Construct a `Defect` result.\n *\n * @internal\n */\nexport function defectRes<T, E>(cause: unknown): Result<T, E> {\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Defect\" as const,\n      cause,\n    }),\n  ) as DefectView<T, E>;\n}\n\n/**\n * Type guard: is `x` a {@link Result} (any of `Ok` / `Err` / `Defect`)?\n *\n * @remarks\n * Unlike {@link isOk} / {@link isErr} / {@link isDefect}, which narrow a value\n * already known to be a `Result`, this narrows from `unknown` — useful at an\n * untyped boundary. It checks the value carries the `Result` prototype, so a\n * look-alike plain object (`{ tag: \"Ok\" }`) is **not** matched. An `AsyncResult`\n * is not a `Result` and returns `false`.\n *\n * @returns `true` when `x` is a `Result` produced by this library.\n *\n * @example\n * ```ts\n * import { isResult, Ok } from \"unthrown\";\n *\n * isResult(Ok(1)); // => true\n * isResult({ tag: \"Ok\" }); // => false (look-alike, wrong prototype)\n * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)\n *\n * const x: unknown = Ok(1);\n * if (isResult(x)) x.match({ ok: () => 1, err: () => 0, defect: () => -1 });\n * ```\n *\n * @category Guards\n */\nexport function isResult(x: unknown): x is Result<unknown, unknown> {\n  return x instanceof Res;\n}\n\n/**\n * Reuse a non-matching variant (an `Err` or `Defect`) as a differently-typed\n * `Result`, with no runtime work. Sound because the passed-through variant\n * carries no value of the changed success type, so retyping it is a no-op — only\n * the phantom type parameter moves. This is the single sanctioned home for that\n * assertion (the same one boxed applies inline at every pass-through); every\n * combinator's short-circuit branch funnels through here instead of casting.\n *\n * @internal\n */\nfunction passThrough<T, E>(self: Result<unknown, unknown>): Result<T, E> {\n  return self as unknown as Result<T, E>;\n}\n\n/**\n * A throw inside a *failure observer* (`tapErr` / `tapDefect` / `flatTapErr`)\n * must not destroy the failure being observed — that is the exact place (e.g. a\n * failing error-logger) where losing the underlying failure hurts most. The\n * resulting Defect aggregates both: `errors[0]` is the observer's throw,\n * `errors[1]` the original failure.\n *\n * @internal\n */\nfunction observerThrowToDefect<T, E>(thrown: unknown, original: unknown): Result<T, E> {\n  return defectRes(\n    new AggregateError(\n      [thrown, original],\n      \"unthrown: a failure-observer callback threw; errors[0] is the callback's throw, errors[1] the original failure\",\n    ),\n  );\n}\n\n/**\n * Validate that a `bind`/`let` scope is a real (non-null) object before merging a\n * key into it.\n *\n * @remarks\n * Do-notation accumulates an **object** scope: a chain starts at `Do()` (an\n * empty object) and every `bind`/`let` returns an object, so in typed code the\n * scope is always an object. The method lives on the general `Result` surface,\n * though, so a primitive `Ok` (e.g. `Ok(5).bind(...)`, or a chain whose value was\n * `map`-ped away from its scope) could reach it. Rather than let `{ ...5 }`\n * silently collapse to `{}` and drop the prior scope, we throw here — the\n * surrounding `try` turns it into a `Defect`, surfacing the misuse as the\n * bug it is (a defect is a bug, not an absent value). A `this: object` constraint\n * was rejected: TypeScript does not hard-enforce a constraint inferred solely\n * from `this`, and it breaks `AsyncRes implements AsyncResult`.\n *\n * @internal\n */\nfunction scopeOf(value: unknown): object {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(\"bind/let requires an object scope — start a do-chain with Do()\");\n  }\n  return value;\n}\n\n/**\n * The sole runtime implementation of {@link AsyncResult}: wraps a\n * `Promise<Result>` constructed never to reject. Operates on the public `Result`\n * union (via `tag`), never on `Res` internals. Never re-exported from `index.ts`.\n *\n * @internal\n */\nexport class AsyncRes<T, E> implements AsyncResult<T, E> {\n  constructor(private readonly promise: Promise<Result<T, E>>) {}\n\n  // oxlint-disable-next-line no-thenable -- AsyncResult is an intentional (success-only) thenable so `await` collapses it to a Result; see the Awaitable type. onrejected is still forwarded so a hypothetical internal rejection settles the await instead of hanging — though the internal promise never rejects.\n  then<R1 = Result<T, E>, R2 = never>(\n    onfulfilled?: ((value: Result<T, E>) => R1 | PromiseLike<R1>) | null,\n    onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null,\n  ): PromiseLike<R1 | R2> {\n    return this.promise.then(onfulfilled, onrejected);\n  }\n\n  map<U>(f: (value: T) => U & NotThenable<U>): AsyncResult<U, E> {\n    return new AsyncRes<U, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return okRes(f(r.value));\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  flatMap<U, E2>(f: (value: T) => Result<U, E2> | AsyncResult<U, E2>): AsyncResult<U, E | E2> {\n    return new AsyncRes<U, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return await f(r.value);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tap<R>(f: (value: T) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Ok\") return r;\n        try {\n          f(r.value);\n          return r;\n        } catch (cause) {\n          return defectRes<T, E>(cause);\n        }\n      }),\n    );\n  }\n\n  flatTap<E2>(\n    f: (value: T) => Result<unknown, E2> | AsyncResult<unknown, E2>,\n  ): AsyncResult<T, E | E2> {\n    return new AsyncRes<T, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          const inner = await f(r.value);\n          // Keep the original value on success; an Err/Defect from `f` wins.\n          return inner.tag === \"Ok\" ? r : passThrough(inner);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  bind<K extends string, U, E2>(\n    name: K,\n    f: (scope: T) => Result<U, E2> | AsyncResult<U, E2>,\n  ): AsyncResult<Bound<T, K, U>, E | E2> {\n    return new AsyncRes<Bound<T, K, U>, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          const inner = await f(r.value);\n          if (inner.tag !== \"Ok\") return passThrough(inner);\n          return okRes({ ...scopeOf(r.value), [name]: inner.value }) as unknown as Result<\n            Bound<T, K, U>,\n            E | E2\n          >;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  let<K extends string, U>(\n    name: K,\n    f: (scope: T) => U & NotThenable<U>,\n  ): AsyncResult<Bound<T, K, U>, E> {\n    return new AsyncRes<Bound<T, K, U>, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return okRes({ ...scopeOf(r.value), [name]: f(r.value) }) as unknown as Result<\n            Bound<T, K, U>,\n            E\n          >;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  as<U>(value: U): AsyncResult<U, E> {\n    return new AsyncRes<U, E>(\n      this.promise.then((r) => (r.tag === \"Ok\" ? okRes<U, E>(value) : passThrough(r))),\n    );\n  }\n\n  mapErr<E2>(f: (error: E) => E2 & NotThenable<E2>): AsyncResult<T, E2> {\n    return new AsyncRes<T, E2>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          return errRes(f(r.error));\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  orElse<U, E2>(f: (error: E) => Result<U, E2> | AsyncResult<U, E2>): AsyncResult<T | U, E2> {\n    return new AsyncRes<T | U, E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          return await f(r.error);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  recover<U>(f: (error: E) => U & NotThenable<U>): AsyncResult<T | U, never> {\n    return new AsyncRes<T | U, never>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          return okRes<T | U, never>(f(r.error));\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tapErr<R>(f: (error: E) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Err\") return r;\n        try {\n          f(r.error);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.error);\n        }\n      }),\n    );\n  }\n\n  flatTapErr<E2>(\n    f: (error: E) => Result<unknown, E2> | AsyncResult<unknown, E2>,\n  ): AsyncResult<T, E | E2> {\n    return new AsyncRes<T, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const inner = await f(r.error);\n          // Keep the original error on success; an Err/Defect from `f` wins.\n          return inner.tag === \"Ok\" ? passThrough(r) : passThrough(inner);\n        } catch (cause) {\n          return observerThrowToDefect(cause, r.error);\n        }\n      }),\n    );\n  }\n\n  recoverDefect<U, E2>(\n    f: (cause: unknown) => Result<U, E2> | AsyncResult<U, E2>,\n  ): AsyncResult<T | U, E | E2> {\n    return new AsyncRes<T | U, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Defect\") return r;\n        try {\n          return await f(r.cause);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Defect\") return r;\n        try {\n          f(r.cause);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.cause);\n        }\n      }),\n    );\n  }\n\n  match<R>(cases: {\n    ok: (value: T) => R;\n    err: (error: E) => R;\n    defect: (cause: unknown) => R;\n  }): Promise<R> {\n    return this.promise.then((r) => r.match(cases));\n  }\n\n  unwrap(): Promise<T> {\n    return this.promise.then((r) => r.unwrap());\n  }\n  unwrapErr(): Promise<E> {\n    return this.promise.then((r) => r.unwrapErr());\n  }\n  unwrapOr<U>(fallback: U): Promise<T | U> {\n    return this.promise.then((r) => r.unwrapOr(fallback));\n  }\n  unwrapOrElse<U>(f: (error: E) => U): Promise<T | U> {\n    return this.promise.then((r) => r.unwrapOrElse(f));\n  }\n  getOrNull(): Promise<T | null> {\n    return this.promise.then((r) => r.getOrNull());\n  }\n  getOrUndefined(): Promise<T | undefined> {\n    return this.promise.then((r) => r.getOrUndefined());\n  }\n}\n","// Result constructors and the standalone narrowing guards.\n\nimport { errRes, okRes } from \"./core.js\";\nimport type { DefectView, ErrView, OkView, Result } from \"./types.js\";\n\n/**\n * Construct a successful {@link Result}.\n *\n * @typeParam T - the success value type.\n * @param value - the success value to wrap.\n *\n * @example\n * ```ts\n * import { Ok } from \"unthrown\";\n *\n * Ok(2).map((n) => n + 1); // => Ok(3)\n * Ok(42).unwrap(); // => 42\n * ```\n *\n * @category Constructors\n */\nexport function Ok<T>(value: T): Result<T, never> {\n  return okRes(value);\n}\n\n/**\n * Construct a failed {@link Result} carrying a **modeled** error.\n *\n * @typeParam E - the modeled error type.\n * @param error - the domain error to wrap.\n *\n * @example\n * ```ts\n * import { Err } from \"unthrown\";\n *\n * Err(\"not_found\").map((n) => n + 1); // => Err(\"not_found\") (map skipped)\n * Err(\"not_found\").unwrapErr(); // => \"not_found\"\n * ```\n *\n * @category Constructors\n */\nexport function Err<E>(error: E): Result<never, E> {\n  return errRes(error);\n}\n\n/**\n * Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.\n *\n * @returns `true` when `r` is `Ok`.\n *\n * @example\n * ```ts\n * import { isOk, Ok, Err, type Result } from \"unthrown\";\n *\n * isOk(Ok(1)); // => true\n * isOk(Err(\"boom\")); // => false\n *\n * declare const r: Result<number, string>;\n * if (isOk(r)) r.value; // number, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isOk<T, E>(r: Result<T, E>): r is OkView<T, E> {\n  return r.tag === \"Ok\";\n}\n/**\n * Type guard: narrow a {@link Result} to its `Err` variant, exposing `.error`.\n *\n * @returns `true` when `r` is `Err`.\n *\n * @example\n * ```ts\n * import { isErr, Ok, Err, type Result } from \"unthrown\";\n *\n * isErr(Err(\"boom\")); // => true\n * isErr(Ok(1)); // => false\n *\n * declare const r: Result<number, string>;\n * if (isErr(r)) r.error; // string, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isErr<T, E>(r: Result<T, E>): r is ErrView<E, T> {\n  return r.tag === \"Err\";\n}\n/**\n * Type guard: narrow a {@link Result} to its `Defect` variant, exposing `.cause`.\n *\n * @remarks\n * A `Defect` has no public constructor — it only arises at a boundary (e.g. a\n * callback throwing inside a combinator). This guard is how you detect one.\n *\n * @returns `true` when `r` is a `Defect`.\n *\n * @example\n * ```ts\n * import { isDefect, Ok } from \"unthrown\";\n *\n * // A throw inside a combinator is captured as a Defect:\n * const r = Ok(1).map(() => {\n *   throw new Error(\"boom\");\n * });\n * isDefect(r); // => true\n * isDefect(Ok(1)); // => false\n *\n * if (isDefect(r)) r.cause; // unknown, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isDefect<T, E>(r: Result<T, E>): r is DefectView<T, E> {\n  return r.tag === \"Defect\";\n}\n","// Do-notation entry point. The `bind` / `let` steps live on the `Result` /\n// `AsyncResult` method surface (core.ts); `Do()` just seeds an empty object\n// scope to grow.\n\nimport { Ok } from \"./constructors.js\";\nimport type { Result } from \"./types.js\";\n\n/**\n * Start a do-notation chain with an empty object scope, grown step by step with\n * `bind` (for `Result`-returning steps) and `let` (for pure values).\n *\n * @remarks\n * Capitalised because `do` is a reserved word. Each step receives the scope\n * accumulated so far; the error types union across `bind`s, and a throw in any\n * step becomes a `Defect`. To go asynchronous, lift the chain with `toAsync()`\n * (then a `bind` may return an `AsyncResult`).\n *\n * @example\n * ```ts\n * import { Do, Ok } from \"unthrown\";\n *\n * const result = Do()\n *   .bind(\"user\", () => findUser(id)) // Result<User, NotFound>\n *   .bind(\"org\", ({ user }) => findOrg(user.orgId)) // Result<Org, NotFound>\n *   .let(\"label\", ({ user, org }) => `${user.name} @ ${org.name}`)\n *   .map(({ user, org, label }) => render(user, org, label));\n * // Result<View, NotFound>\n * ```\n *\n * @example\n * ```ts\n * import { Do, Ok, Err } from \"unthrown\";\n *\n * // Ok path — the scope accumulates:\n * Do()\n *   .bind(\"a\", () => Ok(2))\n *   .let(\"b\", ({ a }) => a * 10)\n *   .map(({ a, b }) => a + b); // => Ok(22)\n *\n * // Err path — the first Err short-circuits the rest:\n * Do()\n *   .bind(\"a\", () => Err(\"boom\"))\n *   .let(\"b\", ({ a }) => a); // => Err(\"boom\")\n * ```\n *\n * @category Do-notation\n */\nexport function Do(): Result<{}, never> {\n  return Ok({});\n}\n","// Defect marker plumbing.\n\nconst DEFECT: unique symbol = Symbol(\"unthrown/Defect\");\n\n/**\n * The opaque marker a `qualify` function returns to triage a cause as\n * **unexpected**.\n *\n * @remarks\n * `qualify` (passed to {@link fromPromise} / {@link fromThrowable}) returns\n * `E | Defect`: either a modeled domain error, or a `Defect` produced by the\n * injected `defect` helper to say \"this failure is not modeled\". A `Defect` is\n * opaque — it carries the original cause for the boundary to convert into the\n * third runtime state of a `Result`. It is **not** a public value; the only way\n * to mint one is the `defect` helper the boundary passes to `qualify`.\n *\n * @internal\n */\nexport type Defect = {\n  readonly [DEFECT]: true;\n  readonly cause: unknown;\n};\n\n/**\n * Wrap a cause as a `Defect` marker — the value returned from a `qualify`\n * function when a failure is **not** a modeled domain error. The boundary\n * (`fromPromise` / `fromThrowable`) passes this in as `qualify`'s second\n * argument, so domain code never imports it.\n *\n * @param cause - the original thrown/rejected value.\n * @returns an opaque Defect marker carrying `cause`.\n *\n * @internal\n */\nexport function defect(cause: unknown): Defect {\n  return { [DEFECT]: true, cause };\n}\n\n/**\n * Internal guard for the qualify-time marker. Distinct from the public\n * {@link isDefect} state guard — this one narrows the `E | Defect` union a\n * `qualify` function returns, not a `Result`.\n *\n * @internal\n */\nexport function isDefectMarker(x: unknown): x is Defect {\n  return (\n    typeof x === \"object\" && x !== null && (x as Record<PropertyKey, unknown>)[DEFECT] === true\n  );\n}\n","// Boundary interop and aggregation. Every throwing/rejecting boundary is forced\n// through `qualify`, which triages each cause into a modeled `E` or a `Defect`;\n// there is no path that yields `unknown` in `E`.\n\nimport { AsyncRes, defectRes, errRes, okRes } from \"./core.js\";\nimport { type Defect, defect, isDefectMarker } from \"./defect.js\";\nimport { Err, Ok } from \"./constructors.js\";\nimport type { AsyncErrOf, AsyncOkOf, AsyncResult, ErrOf, OkOf, Result } from \"./types.js\";\n\n/**\n * Bridge a nullable value into a {@link Result}: absence becomes a **modeled**\n * `Err`. The sanctioned alternative to an `Option` type.\n *\n * @remarks\n * `null` and `undefined` map to `Err(onAbsent())`; any other value (including\n * falsy ones like `0`, `\"\"`, `false`) maps to `Ok`.\n *\n * @typeParam T - the (nullable) value type.\n * @typeParam E - the error produced when the value is absent.\n * @param value - the possibly-absent value.\n * @param onAbsent - lazily produces the error for the absent case.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromNullable } from \"unthrown\";\n *\n * const map = new Map([[\"a\", 1]]);\n * fromNullable(map.get(\"a\"), () => \"absent\").unwrap(); // => 1\n * fromNullable(map.get(\"z\"), () => \"absent\"); // => Err(\"absent\")\n * fromNullable(0, () => \"absent\").unwrap(); // => 0 (falsy but present)\n * ```\n */\nexport function fromNullable<T, E>(\n  value: T | null | undefined,\n  onAbsent: () => E,\n): Result<NonNullable<T>, E> {\n  return value === null || value === undefined ? Err(onAbsent()) : Ok(value as NonNullable<T>);\n}\n\n/**\n * Wrap a throwing synchronous function so it returns a {@link Result} instead of\n * throwing.\n *\n * @remarks\n * `qualify` **must** triage every thrown cause into a modeled error `E` or a\n * `Defect` (via the injected `defect` helper, its second argument) — there is no\n * path that leaves `unknown` in `E`. A throw inside `qualify` itself is treated\n * as a `Defect`.\n *\n * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of\n * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a\n * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is\n * out-of-band and must not pollute the error channel); reach for\n * {@link fromSafePromise} when every failure is a Defect.\n *\n * @typeParam A - the wrapped function's argument tuple.\n * @typeParam T - the wrapped function's return type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param fn - the throwing function to wrap.\n * @param qualify - triages a thrown `cause` into a modeled `E`, or marks it\n * unmodeled by returning `defect(cause)` (the helper passed as its second arg).\n * @returns a function with the same arguments returning `Result<T, E>`.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromThrowable } from \"unthrown\";\n *\n * // Model the parse failure as an `Err`, everything unexpected as a `Defect`.\n * const parse = fromThrowable(\n *   (text: string) => JSON.parse(text) as unknown,\n *   (cause, defect) =>\n *     cause instanceof SyntaxError ? (\"invalid_json\" as const) : defect(cause),\n * );\n *\n * parse('{\"ok\":true}').unwrap(); // => { ok: true }\n * parse(\"nope\"); // => Err(\"invalid_json\")\n * ```\n */\nexport function fromThrowable<A extends unknown[], T, R>(\n  fn: (...args: A) => T,\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R,\n): (...args: A) => Result<T, Exclude<R, Defect>> {\n  type E = Exclude<R, Defect>;\n  const triage = qualify as (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect;\n  return (...args: A): Result<T, E> => {\n    try {\n      return Ok(fn(...args)) as Result<T, E>;\n    } catch (cause) {\n      return qualifyToResult<T, E>(cause, triage);\n    }\n  };\n}\n\n/**\n * Wrap a `Promise` (or a thunk producing one) as an {@link AsyncResult}, forcing\n * every rejection to be triaged.\n *\n * @remarks\n * `qualify` **must** map each rejection cause into a modeled error `E` or a\n * `Defect` (via the injected `defect` helper, its second argument). The returned\n * `AsyncResult`'s internal promise never rejects; `await`-ing it always yields a\n * `Result`. A throw inside `qualify` is itself a `Defect`.\n *\n * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of\n * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a\n * `qualify` that returns *only* `defect(cause)` yields `E = never`; when every\n * rejection is a Defect, prefer {@link fromSafePromise}.\n *\n * @typeParam T - the resolved value type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param promise - the promise, or a thunk returning one.\n * @param qualify - triages a rejection `cause` into a modeled `E`, or marks it\n * unmodeled by returning `defect(cause)` (the helper passed as its second arg).\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromPromise } from \"unthrown\";\n *\n * // A rejection with a NotFoundError becomes a modeled `Err`; anything else a Defect.\n * const user = await fromPromise(fetchUser(id), (cause, defect) =>\n *   cause instanceof NotFoundError ? (\"not_found\" as const) : defect(cause),\n * );\n *\n * user.unwrap(); // => the fetched user (on success)\n * // when fetchUser rejects with NotFoundError: => Err(\"not_found\")\n * ```\n */\nexport function fromPromise<T, R>(\n  promise: Promise<T> | (() => Promise<T>),\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R,\n): AsyncResult<T, Exclude<R, Defect>> {\n  type E = Exclude<R, Defect>;\n  const triage = qualify as (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect;\n  // Promise.resolve() also absorbs a non-thenable passed from untyped code, so\n  // this boundary never throws synchronously — it exists to prevent throws.\n  const p =\n    typeof promise === \"function\" ? Promise.resolve().then(promise) : Promise.resolve(promise);\n  const settled: Promise<Result<T, E>> = p.then(\n    (value) => okRes<T, E>(value),\n    (cause) => qualifyToResult<T, E>(cause, triage),\n  );\n  return new AsyncRes<T, E>(settled);\n}\n\n/**\n * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection\n * becomes a `Defect`.\n *\n * @remarks\n * Use this only when a rejection genuinely indicates a bug rather than an\n * anticipated outcome — the error channel is `never`, so there is nothing to\n * triage. (`await`-ing still yields a `Result`; it never throws.)\n *\n * @typeParam T - the resolved value type.\n * @param promise - the promise, or a thunk returning one.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromSafePromise } from \"unthrown\";\n *\n * (await fromSafePromise(Promise.resolve(3))).unwrap(); // => 3\n * // a rejection becomes a Defect (never a modeled Err):\n * await fromSafePromise(Promise.reject(new Error(\"boom\"))); // => Defect(Error(\"boom\"))\n * ```\n */\nexport function fromSafePromise<T>(\n  promise: Promise<T> | (() => Promise<T>),\n): AsyncResult<T, never> {\n  // Promise.resolve() also absorbs a non-thenable passed from untyped code, so\n  // this boundary never throws synchronously — it exists to prevent throws.\n  const p =\n    typeof promise === \"function\" ? Promise.resolve().then(promise) : Promise.resolve(promise);\n  const settled: Promise<Result<T, never>> = p.then(\n    (value) => okRes<T, never>(value),\n    (cause) => defectRes<T, never>(cause),\n  );\n  return new AsyncRes<T, never>(settled);\n}\n\nfunction qualifyToResult<T, E>(\n  cause: unknown,\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect,\n): Result<T, E> {\n  try {\n    const q = qualify(cause, defect);\n    return isDefectMarker(q) ? defectRes<T, E>(q.cause) : errRes<T, E>(q);\n  } catch (qErr) {\n    // a throw inside qualify is itself a Defect\n    return defectRes<T, E>(qErr);\n  }\n}\n\n/**\n * The success channel of {@link all} / {@link allAsync}: a **positional tuple**\n * for a fixed-length input (including the empty tuple), or a homogeneous\n * **array** for a dynamic one.\n *\n * @remarks\n * The split keys off the input's `length`: a fixed tuple has a literal length\n * (`number extends Rs[\"length\"]` is false → keep the positional `Ts`), while a\n * general array has `length: number` (→ collapse to `Ts[number][]`). Checking\n * length rather than `Rs extends [unknown, ...unknown[]]` keeps `all([])` typed\n * as `Result<[], …>` instead of `Result<never[], …>`.\n *\n * @typeParam Rs - the tuple/array of input `Result` types.\n * @typeParam Ts - per-element extracted success types (`OkOf` for `all`,\n * `AsyncOkOf` for `allAsync`).\n * @internal\n */\ntype AllOk<\n  Rs extends readonly unknown[],\n  Ts extends readonly unknown[],\n> = number extends Rs[\"length\"] ? Ts[number][] : Ts;\n\n/** A record of `Result`s — the input to {@link allFromDict}. */\ntype ResultRecord = Record<string, Result<unknown, unknown>>;\n/** A record of `AsyncResult`s — the input to {@link allFromDictAsync}. */\ntype AsyncResultRecord = Record<string, AsyncResult<unknown, unknown>>;\n\n/**\n * Fold an array of settled `Result`s: first `Err` wins, any `Defect` dominates,\n * else `Ok` of the values array.\n *\n * @internal\n */\nfunction foldArray(results: readonly Result<unknown, unknown>[]): Result<unknown, unknown> {\n  let firstErr: Result<unknown, unknown> | undefined;\n  let firstDefect: Result<unknown, unknown> | undefined;\n  const values: unknown[] = [];\n  for (const r of results) {\n    if (r.tag === \"Defect\") {\n      firstDefect ??= r;\n      break; // any Defect dominates — nothing later can change the outcome\n    } else if (r.tag === \"Err\") firstErr ??= r;\n    else values.push(r.value);\n  }\n  return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/**\n * Fold a record of settled `Result`s with the same rules, else `Ok` of the\n * record of values. Keys are written with `Object.defineProperty` so a\n * caller-supplied `\"__proto__\"` key cannot pollute the prototype.\n *\n * @internal\n */\nfunction foldRecord(results: ResultRecord): Result<unknown, unknown> {\n  let firstErr: Result<unknown, unknown> | undefined;\n  let firstDefect: Result<unknown, unknown> | undefined;\n  const values: Record<string, unknown> = {};\n  for (const [key, r] of Object.entries(results)) {\n    if (r.tag === \"Defect\") {\n      firstDefect ??= r;\n      break; // any Defect dominates — nothing later can change the outcome\n    } else if (r.tag === \"Err\") firstErr ??= r;\n    else\n      Object.defineProperty(values, key, {\n        value: r.value,\n        enumerable: true,\n        writable: true,\n        configurable: true,\n      });\n  }\n  return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/**\n * Collect a tuple/array of {@link Result}s into a single `Result` of all their\n * success values.\n *\n * @remarks\n * Short-circuits on the **first** `Err` (later entries are not inspected for\n * their error); any `Defect` present **dominates**, winning even over an earlier\n * `Err`. A **fixed tuple** keeps its positional types — `all([Ok(1), Ok(\"a\")])`\n * is `Result<[number, string], …>` — while a **dynamic array** `Result<T, E>[]`\n * collapses to `Result<T[], E>` with no cast. For a **record** keyed by name,\n * use {@link allFromDict}.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { all, Ok, Err } from \"unthrown\";\n *\n * all([Ok(1), Ok(\"a\"), Ok(true)]).unwrap(); // => [1, \"a\", true] (typed [number, string, boolean])\n * all([Ok(1), Err(\"e\"), Ok(3)]); // => Err(\"e\") (short-circuits on the first Err)\n * ```\n */\nexport function all<Rs extends readonly Result<unknown, unknown>[]>(\n  results: readonly [...Rs],\n): Result<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>> {\n  return foldArray(results) as unknown as Result<\n    AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>,\n    ErrOf<Rs[number]>\n  >;\n}\n\n/**\n * Collect a **record** of {@link Result}s into a single `Result` of a record of\n * their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is\n * `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for\n * parallel work you'd rather not tuple.\n *\n * @remarks\n * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`\n * dominates. This is **not** error accumulation.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allFromDict, Ok, Err } from \"unthrown\";\n *\n * allFromDict({ id: Ok(1), name: Ok(\"ada\") }).unwrap(); // => { id: 1, name: \"ada\" }\n * allFromDict({ id: Ok(1), name: Err(\"missing\") }); // => Err(\"missing\")\n * ```\n */\nexport function allFromDict<R extends ResultRecord>(\n  results: R,\n): Result<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>> {\n  return foldRecord(results) as unknown as Result<\n    { [K in keyof R]: OkOf<R[K]> },\n    ErrOf<R[keyof R]>\n  >;\n}\n\n/**\n * The asynchronous counterpart of {@link all}: combine a tuple/array of\n * {@link AsyncResult}s into one `AsyncResult` of all their success values.\n *\n * @remarks\n * The inputs are resolved **concurrently** (order preserved); the resolved\n * `Result`s are then folded with the same rules as {@link all} — first `Err`\n * short-circuits, any `Defect` dominates. As ever, the returned `AsyncResult`'s\n * internal promise never rejects. For a **record**, use {@link allFromDictAsync}.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allAsync, fromSafePromise } from \"unthrown\";\n *\n * const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);\n * (await both).unwrap(); // => [1, 2]\n * ```\n */\nexport function allAsync<Rs extends readonly AsyncResult<unknown, unknown>[]>(\n  results: readonly [...Rs],\n): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>> {\n  // Each AsyncResult is a (never-rejecting) thenable, so Promise.all adopts them;\n  // `foldArray` then applies the all() rules. The internal promise never rejects.\n  const settled = Promise.all(results).then((resolved) =>\n    foldArray(resolved as readonly Result<unknown, unknown>[]),\n  );\n  return new AsyncRes(settled) as unknown as AsyncResult<\n    AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>,\n    AsyncErrOf<Rs[number]>\n  >;\n}\n\n/**\n * The asynchronous counterpart of {@link allFromDict}: combine a record of\n * {@link AsyncResult}s into one `AsyncResult` of a record of their values.\n *\n * @remarks\n * Resolved concurrently (order preserved), folded with the {@link all} rules,\n * and the internal promise never rejects.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allFromDictAsync, fromSafePromise } from \"unthrown\";\n *\n * const both = allFromDictAsync({\n *   a: fromSafePromise(Promise.resolve(1)),\n *   b: fromSafePromise(Promise.resolve(\"x\")),\n * });\n * (await both).unwrap(); // => { a: 1, b: \"x\" }\n * ```\n */\nexport function allFromDictAsync<R extends AsyncResultRecord>(\n  results: R,\n): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>> {\n  const entries = Object.entries(results);\n  const settled = Promise.all(entries.map(([, ar]) => ar)).then((resolved) => {\n    // Null-proto accumulator: pairing resolved values back to keys can't pollute.\n    const byKey: ResultRecord = Object.create(null) as ResultRecord;\n    entries.forEach(([key], i) => {\n      byKey[key] = resolved[i]!;\n    });\n    return foldRecord(byKey);\n  });\n  return new AsyncRes(settled) as unknown as AsyncResult<\n    { [K in keyof R]: AsyncOkOf<R[K]> },\n    AsyncErrOf<R[keyof R]>\n  >;\n}\n","// Result facade — a discoverable namespace alias for the standalone entry\n// points. The free functions remain the primary, tree-shakeable API; this\n// object is a separate export, so `import { Ok }` never pulls it in. The value\n// `Result` and the type `Result<T, E>` (types.ts) share a name — the\n// companion-object pattern. See CLAUDE.md → \"Internal design\".\n\nimport { Err, isDefect, isErr, isOk, Ok } from \"./constructors.js\";\nimport { isResult } from \"./core.js\";\nimport { Do } from \"./do.js\";\nimport {\n  all,\n  allAsync,\n  allFromDict,\n  allFromDictAsync,\n  fromNullable,\n  fromPromise,\n  fromSafePromise,\n  fromThrowable,\n} from \"./interop.js\";\nimport type { AsyncResult as AsyncResultType, Result as ResultType } from \"./types.js\";\n\n/**\n * Companion object grouping the **`Result`-producing** entry points under a\n * single, discoverable namespace: {@link Result.Ok}, {@link Result.Err},\n * {@link Result.Do}, {@link Result.fromNullable}, {@link Result.fromThrowable},\n * {@link Result.all}, {@link Result.allFromDict}, {@link Result.isOk},\n * {@link Result.isErr}, {@link Result.isDefect}, {@link Result.isResult}.\n *\n * @remarks\n * Purely additive sugar — each member **is** the corresponding free function.\n * The free functions remain the primary, tree-shakeable API; importing only\n * `{ Ok }` never pulls this object in. The value `Result` and the type\n * {@link Result} share one name (the companion-object pattern).\n *\n * The **async** entry points live on the sibling {@link AsyncResult} companion\n * (`AsyncResult.fromPromise`, `AsyncResult.all`, …), grouped by what they\n * return — a static lives in exactly one namespace.\n *\n * @category Facade\n *\n * @example\n * ```ts\n * import { Result } from \"unthrown\";\n * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).unwrap(); // => 2\n * ```\n */\nexport const Result = {\n  Ok,\n  Err,\n  Do,\n  fromNullable,\n  fromThrowable,\n  all,\n  allFromDict,\n  isOk,\n  isErr,\n  isDefect,\n  isResult,\n} as const;\n\n/**\n * `Result<T, E>` — the core discriminated union. Shares its name with the\n * {@link Result | companion object} above (the value and type are one name); this\n * is the type half.\n *\n * @remarks\n * A `Result` is a discriminated union, so TypeDoc can't list its methods on this\n * alias. Its fluent combinators (`map`, `flatMap`, `match`, `unwrap`, …) are\n * documented one per entry on {@link ResultMethods} — the shared method surface\n * every variant carries. For \"which one do I reach for?\", see the\n * [Choosing a combinator](/guide/choosing-a-combinator) guide.\n *\n * @category Facade\n */\n// Re-alias the Result type into this module so a single `export { Result }`\n// (from index.ts) carries BOTH the companion object above and the type — value\n// and type sharing one name, declaration-merged in one place.\nexport type Result<T, E> = ResultType<T, E>;\n\n/**\n * Companion object grouping the **`AsyncResult`-producing** entry points under\n * the matching namespace: {@link AsyncResult.fromPromise},\n * {@link AsyncResult.fromSafePromise}, {@link AsyncResult.all},\n * {@link AsyncResult.allFromDict}.\n *\n * @remarks\n * The async sibling of {@link Result}. Statics are grouped by what they\n * **return**, so `fromPromise`/`fromSafePromise` and the async aggregates sit\n * here rather than on {@link Result}; the namespace already conveys \"async\", so\n * the aggregates drop the `Async` suffix (`AsyncResult.all` is the free function\n * `allAsync`; `AsyncResult.allFromDict` is `allFromDictAsync`). Like\n * {@link Result}, the free functions remain the primary, tree-shakeable API; the\n * value `AsyncResult` and the type {@link AsyncResult} share one name.\n *\n * @category Facade\n *\n * @example\n * ```ts\n * import { AsyncResult } from \"unthrown\";\n * const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));\n * user.unwrap(); // => the fetched user (on success)\n * ```\n */\nexport const AsyncResult = {\n  fromPromise,\n  fromSafePromise,\n  all: allAsync,\n  allFromDict: allFromDictAsync,\n} as const;\n\n/**\n * `AsyncResult<T, E>` — the async counterpart of {@link Result}. Shares its name\n * with the {@link AsyncResult | companion object} above (value and type are one\n * name); this is the type half.\n *\n * @remarks\n * `AsyncResult` carries the async fluent surface; its combinators (`map`,\n * `flatMap`, `match`, `unwrap`, …) are documented one per entry — with their\n * async signatures — on {@link AsyncResultMethods}. For \"which one do I reach\n * for?\", see the [Choosing a combinator](/guide/choosing-a-combinator) guide.\n *\n * @category Facade\n */\n// Re-alias the AsyncResult type into this module (same companion-object pattern\n// as Result above) so one `export { AsyncResult }` carries value + type.\nexport type AsyncResult<T, E> = AsyncResultType<T, E>;\n","// The TaggedError convention (à la Effect's `Data.TaggedError`) and an\n// exhaustive, zero-dependency fold over a tagged error union.\n\nimport type { AsyncResult, Result } from \"./types.js\";\n\ntype Props = Record<string, unknown>;\n\n/**\n * The instance shape produced by a {@link TaggedError} class: an `Error` plus a\n * `_tag` discriminant and the (readonly) payload fields.\n *\n * @typeParam Tag - the string literal discriminant.\n * @typeParam A - the payload object type.\n *\n * @category Types\n */\nexport type TaggedErrorInstance<Tag extends string, A extends Props> = Error &\n  Readonly<Omit<A, \"name\">> & { readonly _tag: Tag };\n\n/**\n * The class constructor returned by {@link TaggedError}. Generic in its payload:\n * apply it with an instantiation expression at the `extends` site.\n *\n * @remarks\n * When the payload is empty, the constructor takes **no** arguments (the\n * `keyof A extends never ? void : A` trick); otherwise it takes the payload. A\n * `name` key is **rejected** (`name?: never`) because it is reserved for the\n * display label — mirroring how {@link TaggedErrorInstance} excludes it — so the\n * reservation is enforced at the call site, not just ignored at runtime.\n *\n * @typeParam Tag - the string literal discriminant.\n *\n * @category Types\n */\nexport type TaggedErrorConstructor<Tag extends string> = {\n  new <A extends Props = {}>(\n    args: keyof A extends never ? void : A & { readonly name?: never },\n  ): TaggedErrorInstance<Tag, A>;\n};\n\n/**\n * Build a base class for a tagged error — a class extending `Error` with a\n * `_tag` string discriminant, in the style of Effect's `Data.TaggedError`.\n *\n * @remarks\n * Extend the returned class to declare a concrete error. Supply the payload with\n * an instantiation expression; omit it for a payload-less error. A `message`\n * field in the payload is forwarded to `Error`. The `_tag` always reflects\n * `tag` and cannot be overridden by the payload. `name` is likewise reserved —\n * it is the display label (set it with `options.name`); a payload `name` is\n * rejected at compile time (and excluded from the instance type), so it can't\n * shadow `Error.name`.\n *\n * `_tag` is the discriminant used by {@link matchTags}; `Error.name` is the\n * human-facing label in stack traces and logs. By default they coincide, but\n * they can be **decoupled** with `options.name` — so a tag can be namespaced for\n * collision-safety (`\"@my-lib/RetryableError\"`) without that slash-prefixed\n * string leaking into `Error.name`:\n *\n * ```ts\n * class RetryableError extends TaggedError(\"@my-lib/RetryableError\", {\n *   name: \"RetryableError\",\n * })<{ message: string }> {}\n *\n * const e = new RetryableError({ message: \"boom\" });\n * e._tag; // \"@my-lib/RetryableError\" — namespaced discriminant\n * e.name; // \"RetryableError\"          — clean display name\n * ```\n *\n * @typeParam Tag - the string literal discriminant.\n * @param tag - the discriminant value; also the default error `name`.\n * @param options - optional overrides. `options.name` sets `Error.name`\n * independently of `tag` (defaults to `tag`).\n *\n * @category Tagged errors\n *\n * @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class HttpError extends TaggedError(\"HttpError\")<{ status: number }> {}\n *\n * new NotFound()._tag; // => \"NotFound\"\n * new HttpError({ status: 500 }).status; // => 500\n * ```\n */\nexport function TaggedError<Tag extends string>(\n  tag: Tag,\n  options?: { readonly name?: string },\n): TaggedErrorConstructor<Tag> {\n  const displayName = options?.name ?? tag;\n  class TaggedErrorBase extends Error {\n    readonly _tag!: Tag;\n\n    constructor(props?: Props) {\n      super(typeof props?.[\"message\"] === \"string\" ? (props[\"message\"] as string) : undefined);\n      if (props) Object.assign(this, props);\n      // The tag is authoritative — assign it after the payload so it can't be\n      // clobbered. `name` is the display label, independent of the discriminant.\n      (this as { _tag: Tag })._tag = tag;\n      this.name = displayName;\n      Object.setPrototypeOf(this, new.target.prototype);\n    }\n  }\n\n  return TaggedErrorBase as unknown as TaggedErrorConstructor<Tag>;\n}\n\n/**\n * The handler object {@link matchTags} requires: a branch per error tag, plus\n * `Ok` and `Defect`. Miss a tag and it will not compile — the exhaustiveness is\n * enforced by the type, with no `.exhaustive()` to forget.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the tagged error union.\n * @typeParam R - the folded result type.\n *\n * @category Types\n */\nexport type TagHandlers<T, E extends { _tag: string }, R> = {\n  Ok: (value: T) => R;\n  Defect: (cause: unknown) => R;\n} & { [K in E[\"_tag\"]]: (error: Extract<E, { _tag: K }>) => R };\n\n/**\n * The channel-handler names are reserved: an error tag named `\"Ok\"` or\n * `\"Defect\"` would collide with them inside {@link TagHandlers}, so\n * {@link matchTags} rejects such unions at the call site.\n *\n * @internal\n */\ntype ReservedTagError =\n  'unthrown: error tags \"Ok\" and \"Defect\" are reserved by matchTags — rename the colliding tag (TaggedError\\'s options.name can keep the display name)';\n\n/**\n * Exhaustively fold a {@link Result} (or {@link AsyncResult}) whose error type is\n * a tagged union, dispatching each error to the handler matching its `_tag`.\n *\n * @remarks\n * The `handlers` object must provide `Ok`, `Defect`, and exactly one function\n * per error tag; each tag's handler receives the narrowed error variant. A\n * missing tag is a compile error. For an `AsyncResult`, the fold resolves to a\n * `Promise<R>`. At runtime, an error whose `_tag` has no handler (possible only\n * outside the typed contract) is routed to the `Defect` handler — an unmodeled\n * tag is an unmodeled failure. Tags named `\"Ok\"` or `\"Defect\"` are rejected at\n * compile time.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the tagged error union (`E extends { _tag: string }`).\n * @typeParam R - the folded result type.\n * @param result - the result to fold.\n * @param handlers - one branch per channel/tag.\n *\n * @category Tagged errors\n *\n * @example\n * ```ts\n * import { Ok, Err, matchTags, TaggedError, type Result } from \"unthrown\";\n *\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class Forbidden extends TaggedError(\"Forbidden\")<{ user: string }> {}\n *\n * const fold = (r: Result<number, NotFound | Forbidden>) =>\n *   matchTags(r, {\n *     Ok: (n) => `got ${n}`,\n *     Defect: (cause) => `bug: ${String(cause)}`,\n *     NotFound: () => \"404\",\n *     Forbidden: (e) => `403 for ${e.user}`,\n *   });\n *\n * fold(Ok(1)); // => \"got 1\"\n * fold(Err(new Forbidden({ user: \"ada\" }))); // => \"403 for ada\"\n * ```\n */\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: Result<T, E>,\n  handlers: TagHandlers<T, E, R> &\n    ([Extract<E[\"_tag\"], \"Ok\" | \"Defect\">] extends [never] ? unknown : ReservedTagError),\n): R;\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: AsyncResult<T, E>,\n  handlers: TagHandlers<T, E, R> &\n    ([Extract<E[\"_tag\"], \"Ok\" | \"Defect\">] extends [never] ? unknown : ReservedTagError),\n): Promise<R>;\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: Result<T, E> | AsyncResult<T, E>,\n  handlers: TagHandlers<T, E, R>,\n): R | Promise<R> {\n  const onErr = (error: E): R => {\n    const tag = error._tag as E[\"_tag\"];\n    // `Object.hasOwn` guards against a rogue tag (e.g. \"constructor\") resolving\n    // through the prototype chain to an unrelated `Object.prototype` member —\n    // only an own property of `handlers` counts as a real handler.\n    const handler =\n      tag === \"Ok\" || tag === \"Defect\" || !Object.hasOwn(handlers, tag)\n        ? undefined\n        : (handlers[tag] as unknown as ((e: E) => R) | undefined);\n    // An unhandled or reserved tag can only arise outside the typed contract (a\n    // widened cast, a JS caller). That is an unmodeled failure — route it to the\n    // Defect handler rather than crashing on `undefined(error)`.\n    return handler ? handler(error) : handlers.Defect(error);\n  };\n  // Both Result and AsyncResult share `match`; the cast picks one signature for\n  // the call while the public overloads keep the return type correct.\n  return (result as Result<T, E>).match({ ok: handlers.Ok, err: onErr, defect: handlers.Defect });\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/core.ts","../src/constructors.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"sourcesContent":["// unthrown — the runtime engine.\n//\n// `Result` is the PUBLIC discriminated union (tag/value/error/cause + methods).\n// `Res` is a method holder only: its prototype carries the implementations, and\n// instances are built by `okRes`/`errRes`/`defectRes` with `Object.create` +\n// the variant type — so a builder returns a value that already *is* a union\n// member (no `as unknown as`). `Res` is never exported from `index.ts`.\n// `AsyncRes` wraps a `Promise<Result>` constructed never to reject and operates\n// purely on the public union (via `r.tag`). See CLAUDE.md → \"Internal design\".\n//\n// Type-changing pass-throughs (e.g. `map` reusing an `Err` as a differently-typed\n// `Result`) all funnel through the single `passThrough` helper — one sound\n// `as unknown as` in one place, rather than boxed's inline cast at every branch.\n// The only other casts are the builders' construction (`as OkView`/…) and the\n// `bind`/`let` scope merge (a computed key can't be spelled at the type level).\n\nimport type {\n  AsyncResult,\n  Bound,\n  DefectView,\n  ErrView,\n  NotThenable,\n  OkView,\n  Result,\n} from \"./types.js\";\n\n/**\n * Thrown by a {@link Result}'s `unwrap` / `unwrapErr` when the assertion is\n * wrong on a *modeled* result — `unwrap()` on an `Err`, or `unwrapErr()` on an\n * `Ok`.\n *\n * @remarks\n * The offending value is exposed two ways: the typed {@link UnwrapError.error}\n * property for programmatic access, and the standard `Error.cause` for the\n * runtime and devtools to chain — when `E` is an `Error` (e.g. a `TaggedError`)\n * its original stack is printed under \"caused by\".\n *\n * A `Defect` is never wrapped in an `UnwrapError`: its original cause is\n * re-thrown (with its original stack) instead.\n *\n * `unwrap()` and `unwrapErr()` are type-gated (`this: Result<T, never>` /\n * `Result<never, E>`), so the wrong-variant branch that throws this is\n * unreachable through well-typed code — it remains only as a defensive guard\n * against unsound runtime misuse (e.g. an `as` cast past the gate).\n *\n * @typeParam E - the type of the {@link UnwrapError.error} it carries.\n *\n * @category Errors\n */\nexport class UnwrapError<E = unknown> extends Error {\n  /**\n   * The offending value: the `Err` error for `unwrap()`, or the `Ok` value for\n   * `unwrapErr()`.\n   */\n  readonly error: E;\n  constructor(error: E) {\n    super(\"unthrown: called unwrap on a non-matching Result\", { cause: error });\n    this.name = \"UnwrapError\";\n    this.error = error;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\n/**\n * Method holder for {@link Result}. Never instantiated with `new` and never\n * exported; the builders below attach its prototype to plain objects. Every\n * method types `this` as the public `Result` union, so it narrows on `tag`.\n *\n * @internal\n */\nclass Res<T, E> {\n  map<U>(this: Result<T, E>, f: (value: T) => U & NotThenable<U>): Result<U, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return okRes(f(this.value));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatMap<U, E2>(this: Result<T, E>, f: (value: T) => Result<U, E2>): Result<U, E | E2> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return f(this.value);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tap<R>(this: Result<T, E>, f: (value: T) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Ok\") return this;\n    try {\n      f(this.value);\n      return this;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatTap<E2>(this: Result<T, E>, f: (value: T) => Result<unknown, E2>): Result<T, E | E2> {\n    if (this.tag !== \"Ok\") return this;\n    try {\n      const r = f(this.value);\n      // Keep the original value on success; an Err/Defect from `f` short-circuits.\n      return r.tag === \"Ok\" ? this : passThrough(r);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  bind<K extends string, U, E2>(\n    this: Result<T, E>,\n    name: K,\n    f: (scope: T) => Result<U, E2>,\n  ): Result<Bound<T, K, U>, E | E2> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      const r = f(this.value);\n      if (r.tag !== \"Ok\") return passThrough(r);\n      // The merged scope can't be spelled at the type level (a computed key\n      // widens to an index signature), so the constructed Ok is cast to `Bound`.\n      return okRes({ ...scopeOf(this.value), [name]: r.value }) as unknown as Result<\n        Bound<T, K, U>,\n        E | E2\n      >;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  let<K extends string, U>(\n    this: Result<T, E>,\n    name: K,\n    f: (scope: T) => U & NotThenable<U>,\n  ): Result<Bound<T, K, U>, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return okRes({ ...scopeOf(this.value), [name]: f(this.value) }) as unknown as Result<\n        Bound<T, K, U>,\n        E\n      >;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  as<U>(this: Result<T, E>, value: U): Result<U, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    return okRes(value);\n  }\n\n  mapErr<E2>(this: Result<T, E>, f: (error: E) => E2 & NotThenable<E2>): Result<T, E2> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      return errRes(f(this.error));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  orElse<U, E2>(this: Result<T, E>, f: (error: E) => Result<U, E2>): Result<T | U, E2> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      return f(this.error);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  recover<U>(this: Result<T, E>, f: (error: E) => U & NotThenable<U>): Result<T | U, never> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      return okRes(f(this.error));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tapErr<R>(this: Result<T, E>, f: (error: E) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      f(this.error);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.error);\n    }\n  }\n\n  flatTapErr<E2>(this: Result<T, E>, f: (error: E) => Result<unknown, E2>): Result<T, E | E2> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      const r = f(this.error);\n      // Keep the original error on the effect's success; an Err/Defect threads through.\n      return r.tag === \"Ok\" ? this : passThrough(r);\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.error);\n    }\n  }\n\n  recoverDefect<U, E2>(\n    this: Result<T, E>,\n    f: (cause: unknown) => Result<U, E2>,\n  ): Result<T | U, E | E2> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      return f(this.cause);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tapDefect<R>(this: Result<T, E>, f: (cause: unknown) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      f(this.cause);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.cause);\n    }\n  }\n\n  match<R>(\n    this: Result<T, E>,\n    cases: {\n      ok: (value: T) => R;\n      err: (error: E) => R;\n      defect: (cause: unknown) => R;\n    },\n  ): R {\n    switch (this.tag) {\n      case \"Ok\":\n        return cases.ok(this.value);\n      case \"Err\":\n        return cases.err(this.error);\n      case \"Defect\":\n        return cases.defect(this.cause);\n    }\n  }\n\n  unwrap(this: Result<T, E>): T {\n    switch (this.tag) {\n      case \"Ok\":\n        return this.value;\n      case \"Err\":\n        throw new UnwrapError(this.error);\n      case \"Defect\":\n        throw this.cause; // rethrow original cause, original stack\n    }\n  }\n\n  unwrapErr(this: Result<T, E>): E {\n    switch (this.tag) {\n      case \"Err\":\n        return this.error;\n      case \"Ok\":\n        throw new UnwrapError(this.value);\n      case \"Defect\":\n        throw this.cause;\n    }\n  }\n\n  unwrapOr<U>(this: Result<T, E>, fallback: U): T | U {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return fallback;\n  }\n\n  unwrapOrElse<U>(this: Result<T, E>, f: (error: E) => U): T | U {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return f(this.error);\n  }\n\n  getOrNull(this: Result<T, E>): T | null {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return null;\n  }\n\n  getOrUndefined(this: Result<T, E>): T | undefined {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return undefined;\n  }\n\n  isOk(this: Result<T, E>): this is OkView<T, E> {\n    return this.tag === \"Ok\";\n  }\n\n  isErr(this: Result<T, E>): this is ErrView<E, T> {\n    return this.tag === \"Err\";\n  }\n\n  isDefect(this: Result<T, E>): this is DefectView<T, E> {\n    return this.tag === \"Defect\";\n  }\n\n  toAsync(this: Result<T, E>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(Promise.resolve(this));\n  }\n}\n\nconst RESULT_PROTO = Res.prototype;\n\n/**\n * Construct an `Ok` result — a plain object on the {@link Res} prototype.\n *\n * @internal\n */\nexport function okRes<T, E>(value: T): Result<T, E> {\n  // Frozen so the `readonly` surface is real at runtime: a variant cannot be\n  // forged by mutating `tag`/payload after construction.\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Ok\" as const,\n      value,\n    }),\n  ) as OkView<T, E>;\n}\n\n/**\n * Construct an `Err` result.\n *\n * @internal\n */\nexport function errRes<T, E>(error: E): Result<T, E> {\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Err\" as const,\n      error,\n    }),\n  ) as ErrView<E, T>;\n}\n\n/**\n * Construct a `Defect` result.\n *\n * @internal\n */\nexport function defectRes<T, E>(cause: unknown): Result<T, E> {\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Defect\" as const,\n      cause,\n    }),\n  ) as DefectView<T, E>;\n}\n\n/**\n * Type guard: is `x` a {@link Result} (any of `Ok` / `Err` / `Defect`)?\n *\n * @remarks\n * Unlike {@link isOk} / {@link isErr} / {@link isDefect}, which narrow a value\n * already known to be a `Result`, this narrows from `unknown` — useful at an\n * untyped boundary. It checks the value carries the `Result` prototype, so a\n * look-alike plain object (`{ tag: \"Ok\" }`) is **not** matched. An `AsyncResult`\n * is not a `Result` and returns `false`.\n *\n * @returns `true` when `x` is a `Result` produced by this library.\n *\n * @example\n * ```ts\n * import { isResult, Ok } from \"unthrown\";\n *\n * isResult(Ok(1)); // => true\n * isResult({ tag: \"Ok\" }); // => false (look-alike, wrong prototype)\n * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)\n *\n * const x: unknown = Ok(1);\n * if (isResult(x)) x.match({ ok: () => 1, err: () => 0, defect: () => -1 });\n * ```\n *\n * @category Guards\n */\nexport function isResult(x: unknown): x is Result<unknown, unknown> {\n  return x instanceof Res;\n}\n\n/**\n * Reuse a non-matching variant (an `Err` or `Defect`) as a differently-typed\n * `Result`, with no runtime work. Sound because the passed-through variant\n * carries no value of the changed success type, so retyping it is a no-op — only\n * the phantom type parameter moves. This is the single sanctioned home for that\n * assertion (the same one boxed applies inline at every pass-through); every\n * combinator's short-circuit branch funnels through here instead of casting.\n *\n * @internal\n */\nfunction passThrough<T, E>(self: Result<unknown, unknown>): Result<T, E> {\n  return self as unknown as Result<T, E>;\n}\n\n/**\n * A throw inside a *failure observer* (`tapErr` / `tapDefect` / `flatTapErr`)\n * must not destroy the failure being observed — that is the exact place (e.g. a\n * failing error-logger) where losing the underlying failure hurts most. The\n * resulting Defect aggregates both: `errors[0]` is the observer's throw,\n * `errors[1]` the original failure.\n *\n * @internal\n */\nfunction observerThrowToDefect<T, E>(thrown: unknown, original: unknown): Result<T, E> {\n  return defectRes(\n    new AggregateError(\n      [thrown, original],\n      \"unthrown: a failure-observer callback threw; errors[0] is the callback's throw, errors[1] the original failure\",\n    ),\n  );\n}\n\n/**\n * Validate that a `bind`/`let` scope is a real (non-null) object before merging a\n * key into it.\n *\n * @remarks\n * Do-notation accumulates an **object** scope: a chain starts at `Do()` (an\n * empty object) and every `bind`/`let` returns an object, so in typed code the\n * scope is always an object. The method lives on the general `Result` surface,\n * though, so a primitive `Ok` (e.g. `Ok(5).bind(...)`, or a chain whose value was\n * `map`-ped away from its scope) could reach it. Rather than let `{ ...5 }`\n * silently collapse to `{}` and drop the prior scope, we throw here — the\n * surrounding `try` turns it into a `Defect`, surfacing the misuse as the\n * bug it is (a defect is a bug, not an absent value). A `this: object` constraint\n * was rejected: TypeScript does not hard-enforce a constraint inferred solely\n * from `this`, and it breaks `AsyncRes implements AsyncResult`.\n *\n * @internal\n */\nfunction scopeOf(value: unknown): object {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(\"bind/let requires an object scope — start a do-chain with Do()\");\n  }\n  return value;\n}\n\n/**\n * The sole runtime implementation of {@link AsyncResult}: wraps a\n * `Promise<Result>` constructed never to reject. Operates on the public `Result`\n * union (via `tag`), never on `Res` internals. Never re-exported from `index.ts`.\n *\n * @internal\n */\nexport class AsyncRes<T, E> implements AsyncResult<T, E> {\n  constructor(private readonly promise: Promise<Result<T, E>>) {}\n\n  // oxlint-disable-next-line no-thenable -- AsyncResult is an intentional (success-only) thenable so `await` collapses it to a Result; see the Awaitable type. onrejected is still forwarded so a hypothetical internal rejection settles the await instead of hanging — though the internal promise never rejects.\n  then<R1 = Result<T, E>, R2 = never>(\n    onfulfilled?: ((value: Result<T, E>) => R1 | PromiseLike<R1>) | null,\n    onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null,\n  ): PromiseLike<R1 | R2> {\n    return this.promise.then(onfulfilled, onrejected);\n  }\n\n  map<U>(f: (value: T) => U & NotThenable<U>): AsyncResult<U, E> {\n    return new AsyncRes<U, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return okRes(f(r.value));\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  flatMap<U, E2>(f: (value: T) => Result<U, E2> | AsyncResult<U, E2>): AsyncResult<U, E | E2> {\n    return new AsyncRes<U, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return await f(r.value);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tap<R>(f: (value: T) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Ok\") return r;\n        try {\n          f(r.value);\n          return r;\n        } catch (cause) {\n          return defectRes<T, E>(cause);\n        }\n      }),\n    );\n  }\n\n  flatTap<E2>(\n    f: (value: T) => Result<unknown, E2> | AsyncResult<unknown, E2>,\n  ): AsyncResult<T, E | E2> {\n    return new AsyncRes<T, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          const inner = await f(r.value);\n          // Keep the original value on success; an Err/Defect from `f` wins.\n          return inner.tag === \"Ok\" ? r : passThrough(inner);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  bind<K extends string, U, E2>(\n    name: K,\n    f: (scope: T) => Result<U, E2> | AsyncResult<U, E2>,\n  ): AsyncResult<Bound<T, K, U>, E | E2> {\n    return new AsyncRes<Bound<T, K, U>, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          const inner = await f(r.value);\n          if (inner.tag !== \"Ok\") return passThrough(inner);\n          return okRes({ ...scopeOf(r.value), [name]: inner.value }) as unknown as Result<\n            Bound<T, K, U>,\n            E | E2\n          >;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  let<K extends string, U>(\n    name: K,\n    f: (scope: T) => U & NotThenable<U>,\n  ): AsyncResult<Bound<T, K, U>, E> {\n    return new AsyncRes<Bound<T, K, U>, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return okRes({ ...scopeOf(r.value), [name]: f(r.value) }) as unknown as Result<\n            Bound<T, K, U>,\n            E\n          >;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  as<U>(value: U): AsyncResult<U, E> {\n    return new AsyncRes<U, E>(\n      this.promise.then((r) => (r.tag === \"Ok\" ? okRes<U, E>(value) : passThrough(r))),\n    );\n  }\n\n  mapErr<E2>(f: (error: E) => E2 & NotThenable<E2>): AsyncResult<T, E2> {\n    return new AsyncRes<T, E2>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          return errRes(f(r.error));\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  orElse<U, E2>(f: (error: E) => Result<U, E2> | AsyncResult<U, E2>): AsyncResult<T | U, E2> {\n    return new AsyncRes<T | U, E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          return await f(r.error);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  recover<U>(f: (error: E) => U & NotThenable<U>): AsyncResult<T | U, never> {\n    return new AsyncRes<T | U, never>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          return okRes<T | U, never>(f(r.error));\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tapErr<R>(f: (error: E) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Err\") return r;\n        try {\n          f(r.error);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.error);\n        }\n      }),\n    );\n  }\n\n  flatTapErr<E2>(\n    f: (error: E) => Result<unknown, E2> | AsyncResult<unknown, E2>,\n  ): AsyncResult<T, E | E2> {\n    return new AsyncRes<T, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const inner = await f(r.error);\n          // Keep the original error on success; an Err/Defect from `f` wins.\n          return inner.tag === \"Ok\" ? passThrough(r) : passThrough(inner);\n        } catch (cause) {\n          return observerThrowToDefect(cause, r.error);\n        }\n      }),\n    );\n  }\n\n  recoverDefect<U, E2>(\n    f: (cause: unknown) => Result<U, E2> | AsyncResult<U, E2>,\n  ): AsyncResult<T | U, E | E2> {\n    return new AsyncRes<T | U, E | E2>(\n      this.promise.then(async (r) => {\n        if (r.tag !== \"Defect\") return r;\n        try {\n          return await f(r.cause);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.promise.then((r) => {\n        if (r.tag !== \"Defect\") return r;\n        try {\n          f(r.cause);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.cause);\n        }\n      }),\n    );\n  }\n\n  match<R>(cases: {\n    ok: (value: T) => R;\n    err: (error: E) => R;\n    defect: (cause: unknown) => R;\n  }): Promise<R> {\n    return this.promise.then((r) => r.match(cases));\n  }\n\n  unwrap(): Promise<T> {\n    return this.promise.then((r) => (r as Result<T, never>).unwrap());\n  }\n  unwrapErr(): Promise<E> {\n    return this.promise.then((r) => (r as Result<never, E>).unwrapErr());\n  }\n  unwrapOr<U>(fallback: U): Promise<T | U> {\n    return this.promise.then((r) => r.unwrapOr(fallback));\n  }\n  unwrapOrElse<U>(f: (error: E) => U): Promise<T | U> {\n    return this.promise.then((r) => r.unwrapOrElse(f));\n  }\n  getOrNull(): Promise<T | null> {\n    return this.promise.then((r) => r.getOrNull());\n  }\n  getOrUndefined(): Promise<T | undefined> {\n    return this.promise.then((r) => r.getOrUndefined());\n  }\n}\n","// Result constructors and the standalone narrowing guards.\n\nimport { errRes, okRes } from \"./core.js\";\nimport type { DefectView, ErrView, OkView, Result } from \"./types.js\";\n\n/**\n * Construct a successful {@link Result}.\n *\n * @typeParam T - the success value type.\n * @param value - the success value to wrap.\n *\n * @example\n * ```ts\n * import { Ok } from \"unthrown\";\n *\n * Ok(2).map((n) => n + 1); // => Ok(3)\n * Ok(42).unwrap(); // => 42\n * ```\n *\n * @category Constructors\n */\nexport function Ok<T>(value: T): Result<T, never> {\n  return okRes(value);\n}\n\n/**\n * Construct a failed {@link Result} carrying a **modeled** error.\n *\n * @typeParam E - the modeled error type.\n * @param error - the domain error to wrap.\n *\n * @example\n * ```ts\n * import { Err } from \"unthrown\";\n *\n * Err(\"not_found\").map((n) => n + 1); // => Err(\"not_found\") (map skipped)\n * Err(\"not_found\").unwrapErr(); // => \"not_found\"\n * ```\n *\n * @category Constructors\n */\nexport function Err<E>(error: E): Result<never, E> {\n  return errRes(error);\n}\n\n/**\n * Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.\n *\n * @returns `true` when `r` is `Ok`.\n *\n * @example\n * ```ts\n * import { isOk, Ok, Err, type Result } from \"unthrown\";\n *\n * isOk(Ok(1)); // => true\n * isOk(Err(\"boom\")); // => false\n *\n * declare const r: Result<number, string>;\n * if (isOk(r)) r.value; // number, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isOk<T, E>(r: Result<T, E>): r is OkView<T, E> {\n  return r.tag === \"Ok\";\n}\n/**\n * Type guard: narrow a {@link Result} to its `Err` variant, exposing `.error`.\n *\n * @returns `true` when `r` is `Err`.\n *\n * @example\n * ```ts\n * import { isErr, Ok, Err, type Result } from \"unthrown\";\n *\n * isErr(Err(\"boom\")); // => true\n * isErr(Ok(1)); // => false\n *\n * declare const r: Result<number, string>;\n * if (isErr(r)) r.error; // string, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isErr<T, E>(r: Result<T, E>): r is ErrView<E, T> {\n  return r.tag === \"Err\";\n}\n/**\n * Type guard: narrow a {@link Result} to its `Defect` variant, exposing `.cause`.\n *\n * @remarks\n * A `Defect` has no public constructor — it only arises at a boundary (e.g. a\n * callback throwing inside a combinator). This guard is how you detect one.\n *\n * @returns `true` when `r` is a `Defect`.\n *\n * @example\n * ```ts\n * import { isDefect, Ok } from \"unthrown\";\n *\n * // A throw inside a combinator is captured as a Defect:\n * const r = Ok(1).map(() => {\n *   throw new Error(\"boom\");\n * });\n * isDefect(r); // => true\n * isDefect(Ok(1)); // => false\n *\n * if (isDefect(r)) r.cause; // unknown, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isDefect<T, E>(r: Result<T, E>): r is DefectView<T, E> {\n  return r.tag === \"Defect\";\n}\n","// Do-notation entry point. The `bind` / `let` steps live on the `Result` /\n// `AsyncResult` method surface (core.ts); `Do()` just seeds an empty object\n// scope to grow.\n\nimport { Ok } from \"./constructors.js\";\nimport type { Result } from \"./types.js\";\n\n/**\n * Start a do-notation chain with an empty object scope, grown step by step with\n * `bind` (for `Result`-returning steps) and `let` (for pure values).\n *\n * @remarks\n * Capitalised because `do` is a reserved word. Each step receives the scope\n * accumulated so far; the error types union across `bind`s, and a throw in any\n * step becomes a `Defect`. To go asynchronous, lift the chain with `toAsync()`\n * (then a `bind` may return an `AsyncResult`).\n *\n * @example\n * ```ts\n * import { Do, Ok } from \"unthrown\";\n *\n * const result = Do()\n *   .bind(\"user\", () => findUser(id)) // Result<User, NotFound>\n *   .bind(\"org\", ({ user }) => findOrg(user.orgId)) // Result<Org, NotFound>\n *   .let(\"label\", ({ user, org }) => `${user.name} @ ${org.name}`)\n *   .map(({ user, org, label }) => render(user, org, label));\n * // Result<View, NotFound>\n * ```\n *\n * @example\n * ```ts\n * import { Do, Ok, Err } from \"unthrown\";\n *\n * // Ok path — the scope accumulates:\n * Do()\n *   .bind(\"a\", () => Ok(2))\n *   .let(\"b\", ({ a }) => a * 10)\n *   .map(({ a, b }) => a + b); // => Ok(22)\n *\n * // Err path — the first Err short-circuits the rest:\n * Do()\n *   .bind(\"a\", () => Err(\"boom\"))\n *   .let(\"b\", ({ a }) => a); // => Err(\"boom\")\n * ```\n *\n * @category Do-notation\n */\nexport function Do(): Result<{}, never> {\n  return Ok({});\n}\n","// Defect marker plumbing.\n\nconst DEFECT: unique symbol = Symbol(\"unthrown/Defect\");\n\n/**\n * The opaque marker a `qualify` function returns to triage a cause as\n * **unexpected**.\n *\n * @remarks\n * `qualify` (passed to {@link fromPromise} / {@link fromThrowable}) returns\n * `E | Defect`: either a modeled domain error, or a `Defect` produced by the\n * injected `defect` helper to say \"this failure is not modeled\". A `Defect` is\n * opaque — it carries the original cause for the boundary to convert into the\n * third runtime state of a `Result`. It is **not** a public value; the only way\n * to mint one is the `defect` helper the boundary passes to `qualify`.\n *\n * @internal\n */\nexport type Defect = {\n  readonly [DEFECT]: true;\n  readonly cause: unknown;\n};\n\n/**\n * Wrap a cause as a `Defect` marker — the value returned from a `qualify`\n * function when a failure is **not** a modeled domain error. The boundary\n * (`fromPromise` / `fromThrowable`) passes this in as `qualify`'s second\n * argument, so domain code never imports it.\n *\n * @param cause - the original thrown/rejected value.\n * @returns an opaque Defect marker carrying `cause`.\n *\n * @internal\n */\nexport function defect(cause: unknown): Defect {\n  return { [DEFECT]: true, cause };\n}\n\n/**\n * Internal guard for the qualify-time marker. Distinct from the public\n * {@link isDefect} state guard — this one narrows the `E | Defect` union a\n * `qualify` function returns, not a `Result`.\n *\n * @internal\n */\nexport function isDefectMarker(x: unknown): x is Defect {\n  return (\n    typeof x === \"object\" && x !== null && (x as Record<PropertyKey, unknown>)[DEFECT] === true\n  );\n}\n","// Boundary interop and aggregation. Every throwing/rejecting boundary is forced\n// through `qualify`, which triages each cause into a modeled `E` or a `Defect`;\n// there is no path that yields `unknown` in `E`.\n\nimport { AsyncRes, defectRes, errRes, okRes } from \"./core.js\";\nimport { type Defect, defect, isDefectMarker } from \"./defect.js\";\nimport { Err, Ok } from \"./constructors.js\";\nimport type { AsyncErrOf, AsyncOkOf, AsyncResult, ErrOf, OkOf, Result } from \"./types.js\";\n\n/**\n * Bridge a nullable value into a {@link Result}: absence becomes a **modeled**\n * `Err`. The sanctioned alternative to an `Option` type.\n *\n * @remarks\n * `null` and `undefined` map to `Err(onAbsent())`; any other value (including\n * falsy ones like `0`, `\"\"`, `false`) maps to `Ok`.\n *\n * @typeParam T - the (nullable) value type.\n * @typeParam E - the error produced when the value is absent.\n * @param value - the possibly-absent value.\n * @param onAbsent - lazily produces the error for the absent case.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromNullable } from \"unthrown\";\n *\n * const map = new Map([[\"a\", 1]]);\n * fromNullable(map.get(\"a\"), () => \"absent\").unwrapOr(0); // => 1\n * fromNullable(map.get(\"z\"), () => \"absent\"); // => Err(\"absent\")\n * fromNullable(0, () => \"absent\").unwrapOr(-1); // => 0 (falsy but present)\n * ```\n */\nexport function fromNullable<T, E>(\n  value: T | null | undefined,\n  onAbsent: () => E,\n): Result<NonNullable<T>, E> {\n  return value === null || value === undefined ? Err(onAbsent()) : Ok(value as NonNullable<T>);\n}\n\n/**\n * Wrap a throwing synchronous function so it returns a {@link Result} instead of\n * throwing.\n *\n * @remarks\n * `qualify` **must** triage every thrown cause into a modeled error `E` or a\n * `Defect` (via the injected `defect` helper, its second argument) — there is no\n * path that leaves `unknown` in `E`. A throw inside `qualify` itself is treated\n * as a `Defect`.\n *\n * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of\n * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a\n * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is\n * out-of-band and must not pollute the error channel); reach for\n * {@link fromSafePromise} when every failure is a Defect.\n *\n * @typeParam A - the wrapped function's argument tuple.\n * @typeParam T - the wrapped function's return type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param fn - the throwing function to wrap.\n * @param qualify - triages a thrown `cause` into a modeled `E`, or marks it\n * unmodeled by returning `defect(cause)` (the helper passed as its second arg).\n * @returns a function with the same arguments returning `Result<T, E>`.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromThrowable } from \"unthrown\";\n *\n * // Model the parse failure as an `Err`, everything unexpected as a `Defect`.\n * const parse = fromThrowable(\n *   (text: string) => JSON.parse(text) as unknown,\n *   (cause, defect) =>\n *     cause instanceof SyntaxError ? (\"invalid_json\" as const) : defect(cause),\n * );\n *\n * parse('{\"ok\":true}').unwrapOr(null); // => { ok: true }\n * parse(\"nope\"); // => Err(\"invalid_json\")\n * ```\n */\nexport function fromThrowable<A extends unknown[], T, R>(\n  fn: (...args: A) => T,\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R,\n): (...args: A) => Result<T, Exclude<R, Defect>> {\n  type E = Exclude<R, Defect>;\n  const triage = qualify as (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect;\n  return (...args: A): Result<T, E> => {\n    try {\n      return Ok(fn(...args)) as Result<T, E>;\n    } catch (cause) {\n      return qualifyToResult<T, E>(cause, triage);\n    }\n  };\n}\n\n/**\n * Wrap a `Promise` (or a thunk producing one) as an {@link AsyncResult}, forcing\n * every rejection to be triaged.\n *\n * @remarks\n * `qualify` **must** map each rejection cause into a modeled error `E` or a\n * `Defect` (via the injected `defect` helper, its second argument). The returned\n * `AsyncResult`'s internal promise never rejects; `await`-ing it always yields a\n * `Result`. A throw inside `qualify` is itself a `Defect`.\n *\n * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of\n * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a\n * `qualify` that returns *only* `defect(cause)` yields `E = never`; when every\n * rejection is a Defect, prefer {@link fromSafePromise}.\n *\n * @typeParam T - the resolved value type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param promise - the promise, or a thunk returning one.\n * @param qualify - triages a rejection `cause` into a modeled `E`, or marks it\n * unmodeled by returning `defect(cause)` (the helper passed as its second arg).\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromPromise } from \"unthrown\";\n *\n * // A rejection with a NotFoundError becomes a modeled `Err`; anything else a Defect.\n * const user = await fromPromise(fetchUser(id), (cause, defect) =>\n *   cause instanceof NotFoundError ? (\"not_found\" as const) : defect(cause),\n * );\n *\n * if (user.isOk()) user.value; // => the fetched user\n * // when fetchUser rejects with NotFoundError: user is Err(\"not_found\")\n * ```\n */\nexport function fromPromise<T, R>(\n  promise: Promise<T> | (() => Promise<T>),\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R,\n): AsyncResult<T, Exclude<R, Defect>> {\n  type E = Exclude<R, Defect>;\n  const triage = qualify as (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect;\n  // Promise.resolve() also absorbs a non-thenable passed from untyped code, so\n  // this boundary never throws synchronously — it exists to prevent throws.\n  const p =\n    typeof promise === \"function\" ? Promise.resolve().then(promise) : Promise.resolve(promise);\n  const settled: Promise<Result<T, E>> = p.then(\n    (value) => okRes<T, E>(value),\n    (cause) => qualifyToResult<T, E>(cause, triage),\n  );\n  return new AsyncRes<T, E>(settled);\n}\n\n/**\n * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection\n * becomes a `Defect`.\n *\n * @remarks\n * Use this only when a rejection genuinely indicates a bug rather than an\n * anticipated outcome — the error channel is `never`, so there is nothing to\n * triage. (`await`-ing still yields a `Result`; it never throws.)\n *\n * @typeParam T - the resolved value type.\n * @param promise - the promise, or a thunk returning one.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromSafePromise } from \"unthrown\";\n *\n * (await fromSafePromise(Promise.resolve(3))).unwrap(); // => 3\n * // a rejection becomes a Defect (never a modeled Err):\n * await fromSafePromise(Promise.reject(new Error(\"boom\"))); // => Defect(Error(\"boom\"))\n * ```\n */\nexport function fromSafePromise<T>(\n  promise: Promise<T> | (() => Promise<T>),\n): AsyncResult<T, never> {\n  // Promise.resolve() also absorbs a non-thenable passed from untyped code, so\n  // this boundary never throws synchronously — it exists to prevent throws.\n  const p =\n    typeof promise === \"function\" ? Promise.resolve().then(promise) : Promise.resolve(promise);\n  const settled: Promise<Result<T, never>> = p.then(\n    (value) => okRes<T, never>(value),\n    (cause) => defectRes<T, never>(cause),\n  );\n  return new AsyncRes<T, never>(settled);\n}\n\nfunction qualifyToResult<T, E>(\n  cause: unknown,\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect,\n): Result<T, E> {\n  try {\n    const q = qualify(cause, defect);\n    return isDefectMarker(q) ? defectRes<T, E>(q.cause) : errRes<T, E>(q);\n  } catch (qErr) {\n    // a throw inside qualify is itself a Defect\n    return defectRes<T, E>(qErr);\n  }\n}\n\n/**\n * The success channel of {@link all} / {@link allAsync}: a **positional tuple**\n * for a fixed-length input (including the empty tuple), or a homogeneous\n * **array** for a dynamic one.\n *\n * @remarks\n * The split keys off the input's `length`: a fixed tuple has a literal length\n * (`number extends Rs[\"length\"]` is false → keep the positional `Ts`), while a\n * general array has `length: number` (→ collapse to `Ts[number][]`). Checking\n * length rather than `Rs extends [unknown, ...unknown[]]` keeps `all([])` typed\n * as `Result<[], …>` instead of `Result<never[], …>`.\n *\n * @typeParam Rs - the tuple/array of input `Result` types.\n * @typeParam Ts - per-element extracted success types (`OkOf` for `all`,\n * `AsyncOkOf` for `allAsync`).\n * @internal\n */\ntype AllOk<\n  Rs extends readonly unknown[],\n  Ts extends readonly unknown[],\n> = number extends Rs[\"length\"] ? Ts[number][] : Ts;\n\n/** A record of `Result`s — the input to {@link allFromDict}. */\ntype ResultRecord = Record<string, Result<unknown, unknown>>;\n/** A record of `AsyncResult`s — the input to {@link allFromDictAsync}. */\ntype AsyncResultRecord = Record<string, AsyncResult<unknown, unknown>>;\n\n/**\n * Fold an array of settled `Result`s: first `Err` wins, any `Defect` dominates,\n * else `Ok` of the values array.\n *\n * @internal\n */\nfunction foldArray(results: readonly Result<unknown, unknown>[]): Result<unknown, unknown> {\n  let firstErr: Result<unknown, unknown> | undefined;\n  let firstDefect: Result<unknown, unknown> | undefined;\n  const values: unknown[] = [];\n  for (const r of results) {\n    if (r.tag === \"Defect\") {\n      firstDefect ??= r;\n      break; // any Defect dominates — nothing later can change the outcome\n    } else if (r.tag === \"Err\") firstErr ??= r;\n    else values.push(r.value);\n  }\n  return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/**\n * Fold a record of settled `Result`s with the same rules, else `Ok` of the\n * record of values. Keys are written with `Object.defineProperty` so a\n * caller-supplied `\"__proto__\"` key cannot pollute the prototype.\n *\n * @internal\n */\nfunction foldRecord(results: ResultRecord): Result<unknown, unknown> {\n  let firstErr: Result<unknown, unknown> | undefined;\n  let firstDefect: Result<unknown, unknown> | undefined;\n  const values: Record<string, unknown> = {};\n  for (const [key, r] of Object.entries(results)) {\n    if (r.tag === \"Defect\") {\n      firstDefect ??= r;\n      break; // any Defect dominates — nothing later can change the outcome\n    } else if (r.tag === \"Err\") firstErr ??= r;\n    else\n      Object.defineProperty(values, key, {\n        value: r.value,\n        enumerable: true,\n        writable: true,\n        configurable: true,\n      });\n  }\n  return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/**\n * Collect a tuple/array of {@link Result}s into a single `Result` of all their\n * success values.\n *\n * @remarks\n * Short-circuits on the **first** `Err` (later entries are not inspected for\n * their error); any `Defect` present **dominates**, winning even over an earlier\n * `Err`. A **fixed tuple** keeps its positional types — `all([Ok(1), Ok(\"a\")])`\n * is `Result<[number, string], …>` — while a **dynamic array** `Result<T, E>[]`\n * collapses to `Result<T[], E>` with no cast. For a **record** keyed by name,\n * use {@link allFromDict}.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { all, Ok, Err } from \"unthrown\";\n *\n * all([Ok(1), Ok(\"a\"), Ok(true)]).unwrap(); // => [1, \"a\", true] (typed [number, string, boolean])\n * all([Ok(1), Err(\"e\"), Ok(3)]); // => Err(\"e\") (short-circuits on the first Err)\n * ```\n */\nexport function all<Rs extends readonly Result<unknown, unknown>[]>(\n  results: readonly [...Rs],\n): Result<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>> {\n  return foldArray(results) as unknown as Result<\n    AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>,\n    ErrOf<Rs[number]>\n  >;\n}\n\n/**\n * Collect a **record** of {@link Result}s into a single `Result` of a record of\n * their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is\n * `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for\n * parallel work you'd rather not tuple.\n *\n * @remarks\n * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`\n * dominates. This is **not** error accumulation.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allFromDict, Ok, Err } from \"unthrown\";\n *\n * allFromDict({ id: Ok(1), name: Ok(\"ada\") }).unwrap(); // => { id: 1, name: \"ada\" }\n * allFromDict({ id: Ok(1), name: Err(\"missing\") }); // => Err(\"missing\")\n * ```\n */\nexport function allFromDict<R extends ResultRecord>(\n  results: R,\n): Result<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>> {\n  return foldRecord(results) as unknown as Result<\n    { [K in keyof R]: OkOf<R[K]> },\n    ErrOf<R[keyof R]>\n  >;\n}\n\n/**\n * The asynchronous counterpart of {@link all}: combine a tuple/array of\n * {@link AsyncResult}s into one `AsyncResult` of all their success values.\n *\n * @remarks\n * The inputs are resolved **concurrently** (order preserved); the resolved\n * `Result`s are then folded with the same rules as {@link all} — first `Err`\n * short-circuits, any `Defect` dominates. As ever, the returned `AsyncResult`'s\n * internal promise never rejects. For a **record**, use {@link allFromDictAsync}.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allAsync, fromSafePromise } from \"unthrown\";\n *\n * const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);\n * (await both).unwrap(); // => [1, 2]\n * ```\n */\nexport function allAsync<Rs extends readonly AsyncResult<unknown, unknown>[]>(\n  results: readonly [...Rs],\n): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>> {\n  // Each AsyncResult is a (never-rejecting) thenable, so Promise.all adopts them;\n  // `foldArray` then applies the all() rules. The internal promise never rejects.\n  const settled = Promise.all(results).then((resolved) =>\n    foldArray(resolved as readonly Result<unknown, unknown>[]),\n  );\n  return new AsyncRes(settled) as unknown as AsyncResult<\n    AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>,\n    AsyncErrOf<Rs[number]>\n  >;\n}\n\n/**\n * The asynchronous counterpart of {@link allFromDict}: combine a record of\n * {@link AsyncResult}s into one `AsyncResult` of a record of their values.\n *\n * @remarks\n * Resolved concurrently (order preserved), folded with the {@link all} rules,\n * and the internal promise never rejects.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allFromDictAsync, fromSafePromise } from \"unthrown\";\n *\n * const both = allFromDictAsync({\n *   a: fromSafePromise(Promise.resolve(1)),\n *   b: fromSafePromise(Promise.resolve(\"x\")),\n * });\n * (await both).unwrap(); // => { a: 1, b: \"x\" }\n * ```\n */\nexport function allFromDictAsync<R extends AsyncResultRecord>(\n  results: R,\n): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>> {\n  const entries = Object.entries(results);\n  const settled = Promise.all(entries.map(([, ar]) => ar)).then((resolved) => {\n    // Null-proto accumulator: pairing resolved values back to keys can't pollute.\n    const byKey: ResultRecord = Object.create(null) as ResultRecord;\n    entries.forEach(([key], i) => {\n      byKey[key] = resolved[i]!;\n    });\n    return foldRecord(byKey);\n  });\n  return new AsyncRes(settled) as unknown as AsyncResult<\n    { [K in keyof R]: AsyncOkOf<R[K]> },\n    AsyncErrOf<R[keyof R]>\n  >;\n}\n","// Result facade — a discoverable namespace alias for the standalone entry\n// points. The free functions remain the primary, tree-shakeable API; this\n// object is a separate export, so `import { Ok }` never pulls it in. The value\n// `Result` and the type `Result<T, E>` (types.ts) share a name — the\n// companion-object pattern. See CLAUDE.md → \"Internal design\".\n\nimport { Err, isDefect, isErr, isOk, Ok } from \"./constructors.js\";\nimport { isResult } from \"./core.js\";\nimport { Do } from \"./do.js\";\nimport {\n  all,\n  allAsync,\n  allFromDict,\n  allFromDictAsync,\n  fromNullable,\n  fromPromise,\n  fromSafePromise,\n  fromThrowable,\n} from \"./interop.js\";\nimport type { AsyncResult as AsyncResultType, Result as ResultType } from \"./types.js\";\n\n/**\n * Companion object grouping the **`Result`-producing** entry points under a\n * single, discoverable namespace: {@link Result.Ok}, {@link Result.Err},\n * {@link Result.Do}, {@link Result.fromNullable}, {@link Result.fromThrowable},\n * {@link Result.all}, {@link Result.allFromDict}, {@link Result.isOk},\n * {@link Result.isErr}, {@link Result.isDefect}, {@link Result.isResult}.\n *\n * @remarks\n * Purely additive sugar — each member **is** the corresponding free function.\n * The free functions remain the primary, tree-shakeable API; importing only\n * `{ Ok }` never pulls this object in. The value `Result` and the type\n * {@link Result} share one name (the companion-object pattern).\n *\n * The **async** entry points live on the sibling {@link AsyncResult} companion\n * (`AsyncResult.fromPromise`, `AsyncResult.all`, …), grouped by what they\n * return — a static lives in exactly one namespace.\n *\n * @category Facade\n *\n * @example\n * ```ts\n * import { Result } from \"unthrown\";\n * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).unwrap(); // => 2\n * ```\n */\nexport const Result = {\n  Ok,\n  Err,\n  Do,\n  fromNullable,\n  fromThrowable,\n  all,\n  allFromDict,\n  isOk,\n  isErr,\n  isDefect,\n  isResult,\n} as const;\n\n/**\n * `Result<T, E>` — the core discriminated union. Shares its name with the\n * {@link Result | companion object} above (the value and type are one name); this\n * is the type half.\n *\n * @remarks\n * A `Result` is a discriminated union, so TypeDoc can't list its methods on this\n * alias. Its fluent combinators (`map`, `flatMap`, `match`, `unwrap`, …) are\n * documented one per entry on {@link ResultMethods} — the shared method surface\n * every variant carries. For \"which one do I reach for?\", see the\n * [Choosing a combinator](/guide/choosing-a-combinator) guide.\n *\n * @category Facade\n */\n// Re-alias the Result type into this module so a single `export { Result }`\n// (from index.ts) carries BOTH the companion object above and the type — value\n// and type sharing one name, declaration-merged in one place.\nexport type Result<T, E> = ResultType<T, E>;\n\n/**\n * Companion object grouping the **`AsyncResult`-producing** entry points under\n * the matching namespace: {@link AsyncResult.fromPromise},\n * {@link AsyncResult.fromSafePromise}, {@link AsyncResult.all},\n * {@link AsyncResult.allFromDict}.\n *\n * @remarks\n * The async sibling of {@link Result}. Statics are grouped by what they\n * **return**, so `fromPromise`/`fromSafePromise` and the async aggregates sit\n * here rather than on {@link Result}; the namespace already conveys \"async\", so\n * the aggregates drop the `Async` suffix (`AsyncResult.all` is the free function\n * `allAsync`; `AsyncResult.allFromDict` is `allFromDictAsync`). Like\n * {@link Result}, the free functions remain the primary, tree-shakeable API; the\n * value `AsyncResult` and the type {@link AsyncResult} share one name.\n *\n * @category Facade\n *\n * @example\n * ```ts\n * import { AsyncResult } from \"unthrown\";\n * const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));\n * user.unwrap(); // => the fetched user (on success)\n * ```\n */\nexport const AsyncResult = {\n  fromPromise,\n  fromSafePromise,\n  all: allAsync,\n  allFromDict: allFromDictAsync,\n} as const;\n\n/**\n * `AsyncResult<T, E>` — the async counterpart of {@link Result}. Shares its name\n * with the {@link AsyncResult | companion object} above (value and type are one\n * name); this is the type half.\n *\n * @remarks\n * `AsyncResult` carries the async fluent surface; its combinators (`map`,\n * `flatMap`, `match`, `unwrap`, …) are documented one per entry — with their\n * async signatures — on {@link AsyncResultMethods}. For \"which one do I reach\n * for?\", see the [Choosing a combinator](/guide/choosing-a-combinator) guide.\n *\n * @category Facade\n */\n// Re-alias the AsyncResult type into this module (same companion-object pattern\n// as Result above) so one `export { AsyncResult }` carries value + type.\nexport type AsyncResult<T, E> = AsyncResultType<T, E>;\n","// The TaggedError convention (à la Effect's `Data.TaggedError`) and an\n// exhaustive, zero-dependency fold over a tagged error union.\n\nimport type { AsyncResult, Result } from \"./types.js\";\n\ntype Props = Record<string, unknown>;\n\n/**\n * The instance shape produced by a {@link TaggedError} class: an `Error` plus a\n * `_tag` discriminant and the (readonly) payload fields.\n *\n * @typeParam Tag - the string literal discriminant.\n * @typeParam A - the payload object type.\n *\n * @category Types\n */\nexport type TaggedErrorInstance<Tag extends string, A extends Props> = Error &\n  Readonly<Omit<A, \"name\" | \"message\">> & { readonly _tag: Tag };\n\n/**\n * The class constructor returned by {@link TaggedError}. Generic in its payload:\n * apply it with an instantiation expression at the `extends` site.\n *\n * @remarks\n * When the payload is empty, the constructor takes **no** arguments (the\n * `keyof A extends never ? void : A` trick); otherwise it takes the payload. The\n * `name` and `message` keys are both **rejected** (`name?: never` /\n * `message?: never`) because both are reserved: `name` is the display label, and\n * `message` is the human string owned by `Error`. Set the message the standard\n * way — `override message = \"…\"` (or a constructor override) on the subclass —\n * never as a free-form per-call payload field. The reservations are enforced at\n * the call site, mirroring how {@link TaggedErrorInstance} excludes both.\n *\n * @typeParam Tag - the string literal discriminant.\n *\n * @category Types\n */\nexport type TaggedErrorConstructor<Tag extends string> = {\n  new <A extends Props = {}>(\n    args: keyof A extends never ? void : A & { readonly name?: never; readonly message?: never },\n  ): TaggedErrorInstance<Tag, A>;\n};\n\n/**\n * Build a base class for a tagged error — a class extending `Error` with a\n * `_tag` string discriminant, in the style of Effect's `Data.TaggedError`.\n *\n * @remarks\n * Extend the returned class to declare a concrete error. Supply the payload with\n * an instantiation expression; omit it for a payload-less error. The `message`\n * is **not** a payload field — it is the human string owned by `Error`, not\n * structured data, so it is reserved. Define it once per subclass the standard\n * way, `override message = \"…\"` (it may interpolate the payload via `this`,\n * which the base populates before the subclass field initialiser runs); a\n * payload `message` is rejected at compile time, so contextual detail lives in\n * typed fields, never baked into per-call prose. The `_tag` always reflects\n * `tag` and cannot be overridden by the payload. `name` is likewise reserved —\n * it is the display label (set it with `options.name`); a payload `name` is\n * rejected at compile time (and excluded from the instance type), so it can't\n * shadow `Error.name`.\n *\n * `_tag` is the discriminant used by {@link matchTags}; `Error.name` is the\n * human-facing label in stack traces and logs. By default they coincide, but\n * they can be **decoupled** with `options.name` — so a tag can be namespaced for\n * collision-safety (`\"@my-lib/RetryableError\"`) without that slash-prefixed\n * string leaking into `Error.name`:\n *\n * ```ts\n * class RetryableError extends TaggedError(\"@my-lib/RetryableError\", {\n *   name: \"RetryableError\",\n * }) {\n *   override message = \"operation failed; safe to retry\";\n * }\n *\n * const e = new RetryableError();\n * e._tag;    // \"@my-lib/RetryableError\" — namespaced discriminant\n * e.name;    // \"RetryableError\"          — clean display name\n * e.message; // \"operation failed; safe to retry\" — the standard Error.message\n * ```\n *\n * @typeParam Tag - the string literal discriminant.\n * @param tag - the discriminant value; also the default error `name`.\n * @param options - optional overrides. `options.name` sets `Error.name`\n * independently of `tag` (defaults to `tag`).\n *\n * @category Tagged errors\n *\n * @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class HttpError extends TaggedError(\"HttpError\")<{ status: number }> {}\n *\n * new NotFound()._tag; // => \"NotFound\"\n * new HttpError({ status: 500 }).status; // => 500\n * ```\n */\nexport function TaggedError<Tag extends string>(\n  tag: Tag,\n  options?: { readonly name?: string },\n): TaggedErrorConstructor<Tag> {\n  const displayName = options?.name ?? tag;\n  class TaggedErrorBase extends Error {\n    readonly _tag!: Tag;\n\n    constructor(props?: Props) {\n      super();\n      if (props) Object.assign(this, props);\n      // `_tag`, `name`, and `message` are authoritative — an untyped caller\n      // can't set them via the payload. `_tag`/`name` are re-assigned to their\n      // canonical values; `message` is `Error`'s channel (set per subclass via\n      // `override message = …`, whose field initialiser runs after this\n      // constructor returns), so any payload-supplied `message` is dropped here.\n      (this as { _tag: Tag })._tag = tag;\n      this.name = displayName;\n      delete (this as { message?: unknown }).message;\n      Object.setPrototypeOf(this, new.target.prototype);\n    }\n  }\n\n  return TaggedErrorBase as unknown as TaggedErrorConstructor<Tag>;\n}\n\n/**\n * The handler object {@link matchTags} requires: a branch per error tag, plus\n * `Ok` and `Defect`. Miss a tag and it will not compile — the exhaustiveness is\n * enforced by the type, with no `.exhaustive()` to forget.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the tagged error union.\n * @typeParam R - the folded result type.\n *\n * @category Types\n */\nexport type TagHandlers<T, E extends { _tag: string }, R> = {\n  Ok: (value: T) => R;\n  Defect: (cause: unknown) => R;\n} & { [K in E[\"_tag\"]]: (error: Extract<E, { _tag: K }>) => R };\n\n/**\n * The channel-handler names are reserved: an error tag named `\"Ok\"` or\n * `\"Defect\"` would collide with them inside {@link TagHandlers}, so\n * {@link matchTags} rejects such unions at the call site.\n *\n * @internal\n */\ntype ReservedTagError =\n  'unthrown: error tags \"Ok\" and \"Defect\" are reserved by matchTags — rename the colliding tag (TaggedError\\'s options.name can keep the display name)';\n\n/**\n * Exhaustively fold a {@link Result} (or {@link AsyncResult}) whose error type is\n * a tagged union, dispatching each error to the handler matching its `_tag`.\n *\n * @remarks\n * The `handlers` object must provide `Ok`, `Defect`, and exactly one function\n * per error tag; each tag's handler receives the narrowed error variant. A\n * missing tag is a compile error. For an `AsyncResult`, the fold resolves to a\n * `Promise<R>`. At runtime, an error whose `_tag` has no handler (possible only\n * outside the typed contract) is routed to the `Defect` handler — an unmodeled\n * tag is an unmodeled failure. Tags named `\"Ok\"` or `\"Defect\"` are rejected at\n * compile time.\n *\n * @typeParam T - the success value type.\n * @typeParam E - the tagged error union (`E extends { _tag: string }`).\n * @typeParam R - the folded result type.\n * @param result - the result to fold.\n * @param handlers - one branch per channel/tag.\n *\n * @category Tagged errors\n *\n * @example\n * ```ts\n * import { Ok, Err, matchTags, TaggedError, type Result } from \"unthrown\";\n *\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class Forbidden extends TaggedError(\"Forbidden\")<{ user: string }> {}\n *\n * const fold = (r: Result<number, NotFound | Forbidden>) =>\n *   matchTags(r, {\n *     Ok: (n) => `got ${n}`,\n *     Defect: (cause) => `bug: ${String(cause)}`,\n *     NotFound: () => \"404\",\n *     Forbidden: (e) => `403 for ${e.user}`,\n *   });\n *\n * fold(Ok(1)); // => \"got 1\"\n * fold(Err(new Forbidden({ user: \"ada\" }))); // => \"403 for ada\"\n * ```\n */\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: Result<T, E>,\n  handlers: TagHandlers<T, E, R> &\n    ([Extract<E[\"_tag\"], \"Ok\" | \"Defect\">] extends [never] ? unknown : ReservedTagError),\n): R;\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: AsyncResult<T, E>,\n  handlers: TagHandlers<T, E, R> &\n    ([Extract<E[\"_tag\"], \"Ok\" | \"Defect\">] extends [never] ? unknown : ReservedTagError),\n): Promise<R>;\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: Result<T, E> | AsyncResult<T, E>,\n  handlers: TagHandlers<T, E, R>,\n): R | Promise<R> {\n  const onErr = (error: E): R => {\n    const tag = error._tag as E[\"_tag\"];\n    // `Object.hasOwn` guards against a rogue tag (e.g. \"constructor\") resolving\n    // through the prototype chain to an unrelated `Object.prototype` member —\n    // only an own property of `handlers` counts as a real handler.\n    const handler =\n      tag === \"Ok\" || tag === \"Defect\" || !Object.hasOwn(handlers, tag)\n        ? undefined\n        : (handlers[tag] as unknown as ((e: E) => R) | undefined);\n    // An unhandled or reserved tag can only arise outside the typed contract (a\n    // widened cast, a JS caller). That is an unmodeled failure — route it to the\n    // Defect handler rather than crashing on `undefined(error)`.\n    return handler ? handler(error) : handlers.Defect(error);\n  };\n  // Both Result and AsyncResult share `match`; the cast picks one signature for\n  // the call while the public overloads keep the return type correct.\n  return (result as Result<T, E>).match({ ok: handlers.Ok, err: onErr, defect: handlers.Defect });\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unthrown",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "Explicit errors as values, with a separate defect (panic) channel",
   "keywords": [
     "defect",