unthrown 1.1.0 → 3.0.0

package/dist/index.mjs

@@ -5,6 +5,11 @@
 * `Ok`.
 *
 * @remarks
+* The offending value is exposed two ways: the typed {@link UnwrapError.error}
+* property for programmatic access, and the standard `Error.cause` for the
+* runtime and devtools to chain — when `E` is an `Error` (e.g. a `TaggedError`)
+* its original stack is printed under "caused by".
+*
 * A `Defect` is never wrapped in an `UnwrapError`: its original cause is
 * re-thrown (with its original stack) instead.
 *
@@ -17,7 +22,7 @@ var UnwrapError = class extends Error {
 	*/
 	error;
 	constructor(error) {
-		super("unthrown: called unwrap on a non-matching Result");
+		super("unthrown: called unwrap on a non-matching Result", { cause: error });
 		this.name = "UnwrapError";
 		this.error = error;
 		Object.setPrototypeOf(this, new.target.prototype);
@@ -278,7 +283,7 @@ function passThrough(self) {
 * though, so a primitive `Ok` (e.g. `Ok(5).bind(...)`, or a chain whose value was
 * `map`-ped away from its scope) could reach it. Rather than let `{ ...5 }`
 * silently collapse to `{}` and drop the prior scope, we throw here — the
-* surrounding `try` turns it into a {@link Defect}, surfacing the misuse as the
+* surrounding `try` turns it into a `Defect`, surfacing the misuse as the
 * bug it is (a defect is a bug, not an absent value). A `this: object` constraint
 * was rejected: TypeScript does not hard-enforce a constraint inferred solely
 * from `this`, and it breaks `AsyncRes implements AsyncResult`.
@@ -540,41 +545,6 @@ function isDefect(r) {
 	return r.tag === "Defect";
 }
 //#endregion
-//#region src/defect.ts
-const DEFECT = Symbol("unthrown/Defect");
-/**
-* Wrap a cause as a {@link Defect} — the value you return from a `qualify`
-* function when a failure is **not** a modeled domain error.
-*
-* @param cause - the original thrown/rejected value.
-* @returns an opaque Defect marker carrying `cause`.
-*
-* @example
-* ```ts
-* import { fromPromise, Defect } from "unthrown";
-*
-* const user = fromPromise(fetchUser(id), (cause) =>
-*   cause instanceof NotFoundError ? cause : Defect(cause),
-* );
-* ```
-*/
-function Defect(cause) {
-	return {
-		[DEFECT]: true,
-		cause
-	};
-}
-/**
-* Internal guard for the qualify-time marker. Distinct from the public
-* {@link isDefect} state guard — this one narrows the `E | Defect` union a
-* `qualify` function returns, not a `Result`.
-*
-* @internal
-*/
-function isDefectMarker(x) {
-	return typeof x === "object" && x !== null && x[DEFECT] === true;
-}
-//#endregion
 //#region src/do.ts
 /**
 * Start a do-notation chain with an empty object scope, grown step by step with
@@ -602,6 +572,36 @@ function Do() {
 	return Ok({});
 }
 //#endregion
+//#region src/defect.ts
+const DEFECT = Symbol("unthrown/Defect");
+/**
+* Wrap a cause as a `Defect` marker — the value returned from a `qualify`
+* function when a failure is **not** a modeled domain error. The boundary
+* (`fromPromise` / `fromThrowable`) passes this in as `qualify`'s second
+* argument, so domain code never imports it.
+*
+* @param cause - the original thrown/rejected value.
+* @returns an opaque Defect marker carrying `cause`.
+*
+* @internal
+*/
+function defect(cause) {
+	return {
+		[DEFECT]: true,
+		cause
+	};
+}
+/**
+* Internal guard for the qualify-time marker. Distinct from the public
+* {@link isDefect} state guard — this one narrows the `E | Defect` union a
+* `qualify` function returns, not a `Result`.
+*
+* @internal
+*/
+function isDefectMarker(x) {
+	return typeof x === "object" && x !== null && x[DEFECT] === true;
+}
+//#endregion
 //#region src/interop.ts
 /**
 * Bridge a nullable value into a {@link Result}: absence becomes a **modeled**
@@ -631,12 +631,13 @@ function fromNullable(value, onAbsent) {
 *
 * @remarks
 * `qualify` **must** triage every thrown cause into a modeled error `E` or a
-* {@link Defect} (via {@link Defect}) — there is no path that leaves `unknown`
-* in `E`. A throw inside `qualify` itself is treated as a `Defect`.
+* `Defect` (via the injected `defect` helper, its second argument) — there is no
+* path that leaves `unknown` in `E`. A throw inside `qualify` itself is treated
+* as a `Defect`.
 *
 * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
 * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
-* `qualify` that returns *only* `Defect(cause)` yields `E = never` (a Defect is
+* `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is
 * out-of-band and must not pollute the error channel); reach for
 * {@link fromSafePromise} when every failure is a Defect.
 *
@@ -645,13 +646,14 @@ function fromNullable(value, onAbsent) {
 * @typeParam R - `qualify`'s return type; the modeled error `E` is
 * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).
 * @param fn - the throwing function to wrap.
-* @param qualify - triages a thrown cause into `E` or a `Defect`.
+* @param qualify - triages a thrown `cause` into a modeled `E`, or marks it
+* unmodeled by returning `defect(cause)` (the helper passed as its second arg).
 * @returns a function with the same arguments returning `Result<T, E>`.
 *
 * @example
 * ```ts
-* import { fromThrowable, Defect } from "unthrown";
-* const parse = fromThrowable(JSON.parse, (cause) => Defect(cause));
+* import { fromThrowable } from "unthrown";
+* const parse = fromThrowable(JSON.parse, (cause, defect) => defect(cause));
 * parse("{}").unwrap();
 * ```
 */
@@ -671,26 +673,27 @@ function fromThrowable(fn, qualify) {
 *
 * @remarks
 * `qualify` **must** map each rejection cause into a modeled error `E` or a
-* {@link Defect}. The returned `AsyncResult`'s internal promise never rejects;
-* `await`-ing it always yields a `Result`. A throw inside `qualify` is itself a
-* `Defect`.
+* `Defect` (via the injected `defect` helper, its second argument). The returned
+* `AsyncResult`'s internal promise never rejects; `await`-ing it always yields a
+* `Result`. A throw inside `qualify` is itself a `Defect`.
 *
 * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
 * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
-* `qualify` that returns *only* `Defect(cause)` yields `E = never`; when every
+* `qualify` that returns *only* `defect(cause)` yields `E = never`; when every
 * rejection is a Defect, prefer {@link fromSafePromise}.
 *
 * @typeParam T - the resolved value type.
 * @typeParam R - `qualify`'s return type; the modeled error `E` is
 * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).
 * @param promise - the promise, or a thunk returning one.
-* @param qualify - triages a rejection cause into `E` or a `Defect`.
+* @param qualify - triages a rejection `cause` into a modeled `E`, or marks it
+* unmodeled by returning `defect(cause)` (the helper passed as its second arg).
 *
 * @example
 * ```ts
-* import { fromPromise, Defect } from "unthrown";
-* const user = await fromPromise(fetchUser(id), (cause) =>
-*   cause instanceof NotFoundError ? ("not_found" as const) : Defect(cause),
+* import { fromPromise } from "unthrown";
+* const user = await fromPromise(fetchUser(id), (cause, defect) =>
+*   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
 * );
 * ```
 */
@@ -715,7 +718,7 @@ function fromSafePromise(promise) {
 }
 function qualifyToResult(cause, qualify) {
 	try {
-		const q = qualify(cause);
+		const q = qualify(cause, defect);
 		return isDefectMarker(q) ? defectRes(q.cause) : errRes(q);
 	} catch (qErr) {
 		return defectRes(qErr);
@@ -844,13 +847,11 @@ function allFromDictAsync(results) {
 //#endregion
 //#region src/facade.ts
 /**
-* Companion object grouping the standalone entry points under a single,
-* discoverable namespace: {@link Result.Ok}, {@link Result.Err},
-* {@link Result.Defect}, {@link Result.fromNullable}, {@link Result.fromThrowable},
-* {@link Result.fromPromise}, {@link Result.fromSafePromise}, {@link Result.all},
-* {@link Result.allAsync}, {@link Result.allFromDict},
-* {@link Result.allFromDictAsync}, {@link Result.isOk}, {@link Result.isErr},
-* {@link Result.isDefect}, {@link Result.isResult}.
+* Companion object grouping the **`Result`-producing** entry points under a
+* single, discoverable namespace: {@link Result.Ok}, {@link Result.Err},
+* {@link Result.Do}, {@link Result.fromNullable}, {@link Result.fromThrowable},
+* {@link Result.all}, {@link Result.allFromDict}, {@link Result.isOk},
+* {@link Result.isErr}, {@link Result.isDefect}, {@link Result.isResult}.
 *
 * @remarks
 * Purely additive sugar — each member **is** the corresponding free function.
@@ -858,6 +859,10 @@ function allFromDictAsync(results) {
 * `{ Ok }` never pulls this object in. The value `Result` and the type
 * {@link Result} share one name (the companion-object pattern).
 *
+* The **async** entry points live on the sibling {@link AsyncResult} companion
+* (`AsyncResult.fromPromise`, `AsyncResult.all`, …), grouped by what they
+* return — a static lives in exactly one namespace.
+*
 * @example
 * ```ts
 * import { Result } from "unthrown";
@@ -867,21 +872,43 @@ function allFromDictAsync(results) {
 const Result = {
 	Ok,
 	Err,
-	Defect,
 	Do,
 	fromNullable,
 	fromThrowable,
-	fromPromise,
-	fromSafePromise,
 	all,
-	allAsync,
 	allFromDict,
-	allFromDictAsync,
 	isOk,
 	isErr,
 	isDefect,
 	isResult
 };
+/**
+* Companion object grouping the **`AsyncResult`-producing** entry points under
+* the matching namespace: {@link AsyncResult.fromPromise},
+* {@link AsyncResult.fromSafePromise}, {@link AsyncResult.all},
+* {@link AsyncResult.allFromDict}.
+*
+* @remarks
+* The async sibling of {@link Result}. Statics are grouped by what they
+* **return**, so `fromPromise`/`fromSafePromise` and the async aggregates sit
+* here rather than on {@link Result}; the namespace already conveys "async", so
+* the aggregates drop the `Async` suffix (`AsyncResult.all` is the free function
+* `allAsync`; `AsyncResult.allFromDict` is `allFromDictAsync`). Like
+* {@link Result}, the free functions remain the primary, tree-shakeable API; the
+* value `AsyncResult` and the type {@link AsyncResult} share one name.
+*
+* @example
+* ```ts
+* import { AsyncResult } from "unthrown";
+* const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));
+* ```
+*/
+const AsyncResult = {
+	fromPromise,
+	fromSafePromise,
+	all: allAsync,
+	allFromDict: allFromDictAsync
+};
 //#endregion
 //#region src/tagged.ts
 /**
@@ -950,6 +977,6 @@ function matchTags(result, handlers) {
 	});
 }
 //#endregion
-export { Defect, Do, Err, Ok, Result, TaggedError, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, isResult, matchTags };
+export { AsyncResult, Do, Err, Ok, Result, TaggedError, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, isResult, matchTags };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/core.ts","../src/constructors.ts","../src/defect.ts","../src/do.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 { AsyncResult, Bound, DefectView, ErrView, OkView, Result } 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 * 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 */\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\");\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): 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(this: Result<T, E>, f: (value: T) => void): 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,\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): 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): 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(this: Result<T, E>, f: (error: E) => void): Result<T, E> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      f(this.error);\n      return this;\n    } catch (cause) {\n      return defectRes(cause);\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 defectRes(cause);\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(this: Result<T, E>, f: (cause: unknown) => void): Result<T, E> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      f(this.cause);\n      return this;\n    } catch (cause) {\n      return defectRes(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(this: Result<T, E>, fallback: T): T {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return fallback;\n  }\n\n  unwrapOrElse(this: Result<T, E>, f: (error: E) => T): T {\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  return Object.assign(Object.create(RESULT_PROTO), {\n    tag: \"Ok\" as const,\n    value,\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.assign(Object.create(RESULT_PROTO), {\n    tag: \"Err\" as const,\n    error,\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.assign(Object.create(RESULT_PROTO), {\n    tag: \"Defect\" as const,\n    cause,\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 */\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 * 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 {@link 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) {\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): 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(f: (value: T) => void): 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>(name: K, f: (scope: T) => U): 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): 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): 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(f: (error: E) => void): 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 defectRes<T, E>(cause);\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 defectRes(cause);\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(f: (cause: unknown) => void): 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 defectRes<T, E>(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(fallback: T): Promise<T> {\n    return this.promise.then((r) => r.unwrapOr(fallback));\n  }\n  unwrapOrElse(f: (error: E) => T): Promise<T> {\n    return this.promise.then((r) => {\n      if (r.tag === \"Ok\") return r.value;\n      if (r.tag === \"Defect\") throw r.cause;\n      return f(r.error);\n    });\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 * Ok(42).unwrap(); // 42\n * ```\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 * Err(\"not_found\").unwrapErr(); // \"not_found\"\n * ```\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, type Result } from \"unthrown\";\n * declare const r: Result<number, string>;\n * if (isOk(r)) r.value; // number, narrowed\n * ```\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 */\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 * @returns `true` when `r` is a `Defect`.\n */\nexport function isDefect<T, E>(r: Result<T, E>): r is DefectView<T, E> {\n  return r.tag === \"Defect\";\n}\n","// Defect marker plumbing.\n\nconst DEFECT: unique symbol = Symbol(\"unthrown/Defect\");\n\n/**\n * The marker a `qualify` function returns to triage a cause as **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\n * {@link Defect} to say \"this failure is not modeled\". A `Defect` is opaque —\n * it carries the original cause for the boundary to convert into the third\n * runtime state of a `Result`.\n */\nexport type Defect = {\n  readonly [DEFECT]: true;\n  readonly cause: unknown;\n};\n\n/**\n * Wrap a cause as a {@link Defect} — the value you return from a `qualify`\n * function when a failure is **not** a modeled domain error.\n *\n * @param cause - the original thrown/rejected value.\n * @returns an opaque Defect marker carrying `cause`.\n *\n * @example\n * ```ts\n * import { fromPromise, Defect } from \"unthrown\";\n *\n * const user = fromPromise(fetchUser(id), (cause) =>\n *   cause instanceof NotFoundError ? cause : Defect(cause),\n * );\n * ```\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","// 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 */\nexport function Do(): Result<{}, never> {\n  return Ok({});\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, 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 * @example\n * ```ts\n * import { fromNullable } from \"unthrown\";\n * fromNullable(map.get(key), () => \"missing\").unwrap();\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 * {@link Defect} (via {@link Defect}) — there is no path that leaves `unknown`\n * in `E`. A throw inside `qualify` itself is treated 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 `E` or a `Defect`.\n * @returns a function with the same arguments returning `Result<T, E>`.\n *\n * @example\n * ```ts\n * import { fromThrowable, Defect } from \"unthrown\";\n * const parse = fromThrowable(JSON.parse, (cause) => Defect(cause));\n * parse(\"{}\").unwrap();\n * ```\n */\nexport function fromThrowable<A extends unknown[], T, R>(\n  fn: (...args: A) => T,\n  qualify: (cause: unknown) => R,\n): (...args: A) => Result<T, Exclude<R, Defect>> {\n  type E = Exclude<R, Defect>;\n  const triage = qualify as (cause: unknown) => 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 * {@link Defect}. The returned `AsyncResult`'s internal promise never rejects;\n * `await`-ing it always yields a `Result`. A throw inside `qualify` is itself a\n * `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 `E` or a `Defect`.\n *\n * @example\n * ```ts\n * import { fromPromise, Defect } from \"unthrown\";\n * const user = await fromPromise(fetchUser(id), (cause) =>\n *   cause instanceof NotFoundError ? (\"not_found\" as const) : Defect(cause),\n * );\n * ```\n */\nexport function fromPromise<T, R>(\n  promise: Promise<T> | (() => Promise<T>),\n  qualify: (cause: unknown) => R,\n): AsyncResult<T, Exclude<R, Defect>> {\n  type E = Exclude<R, Defect>;\n  const triage = qualify as (cause: unknown) => E | Defect;\n  const p = typeof promise === \"function\" ? Promise.resolve().then(promise) : 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 */\nexport function fromSafePromise<T>(\n  promise: Promise<T> | (() => Promise<T>),\n): AsyncResult<T, never> {\n  const p = typeof promise === \"function\" ? Promise.resolve().then(promise) : 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) => E | Defect,\n): Result<T, E> {\n  try {\n    const q = qualify(cause);\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\") firstDefect ??= r;\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\") firstDefect ??= r;\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 * @example\n * ```ts\n * import { all, Ok } from \"unthrown\";\n * all([Ok(1), Ok(\"a\"), Ok(true)]).unwrap(); // [1, \"a\", true] (typed [number, string, boolean])\n * all([Ok(1), Ok(2)] as Result<number, never>[]).unwrap(); // number[]\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 * @example\n * ```ts\n * import { allFromDict, Ok } from \"unthrown\";\n * allFromDict({ id: Ok(1), name: Ok(\"ada\") }).unwrap(); // { id: 1, name: \"ada\" }\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 * @example\n * ```ts\n * import { allAsync, fromSafePromise } from \"unthrown\";\n * await allAsync([fromSafePromise(a()), fromSafePromise(b())]);\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 * @example\n * ```ts\n * import { allFromDictAsync, fromSafePromise } from \"unthrown\";\n * await allFromDictAsync({ a: fromSafePromise(a()), b: fromSafePromise(b()) });\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] as Result<unknown, unknown>;\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 { Defect } from \"./defect.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 { Result as ResultType } from \"./types.js\";\n\n/**\n * Companion object grouping the standalone entry points under a single,\n * discoverable namespace: {@link Result.Ok}, {@link Result.Err},\n * {@link Result.Defect}, {@link Result.fromNullable}, {@link Result.fromThrowable},\n * {@link Result.fromPromise}, {@link Result.fromSafePromise}, {@link Result.all},\n * {@link Result.allAsync}, {@link Result.allFromDict},\n * {@link Result.allFromDictAsync}, {@link Result.isOk}, {@link Result.isErr},\n * {@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 * @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  Defect,\n  Do,\n  fromNullable,\n  fromThrowable,\n  fromPromise,\n  fromSafePromise,\n  all,\n  allAsync,\n  allFromDict,\n  allFromDictAsync,\n  isOk,\n  isErr,\n  isDefect,\n  isResult,\n} as const;\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","// 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 */\nexport type TaggedErrorInstance<Tag extends string, A extends Props> = Error &\n  Readonly<A> & { 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.\n *\n * @typeParam Tag - the string literal discriminant.\n */\nexport type TaggedErrorConstructor<Tag extends string> = {\n  new <A extends Props = {}>(args: keyof A extends never ? void : A): 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.\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 * @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 */\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 * 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>`.\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 * @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class Forbidden extends TaggedError(\"Forbidden\")<{ user: string }> {}\n *\n * declare const 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 */\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: Result<T, E>,\n  handlers: TagHandlers<T, E, R>,\n): R;\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: AsyncResult<T, E>,\n  handlers: TagHandlers<T, E, R>,\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 handler = handlers[error._tag as E[\"_tag\"]] as unknown as (e: E) => R;\n    return handler(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 { AsyncResult, Bound, DefectView, ErrView, OkView, Result } 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 */\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): 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(this: Result<T, E>, f: (value: T) => void): 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,\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): 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): 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(this: Result<T, E>, f: (error: E) => void): Result<T, E> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      f(this.error);\n      return this;\n    } catch (cause) {\n      return defectRes(cause);\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 defectRes(cause);\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(this: Result<T, E>, f: (cause: unknown) => void): Result<T, E> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      f(this.cause);\n      return this;\n    } catch (cause) {\n      return defectRes(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(this: Result<T, E>, fallback: T): T {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return fallback;\n  }\n\n  unwrapOrElse(this: Result<T, E>, f: (error: E) => T): T {\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  return Object.assign(Object.create(RESULT_PROTO), {\n    tag: \"Ok\" as const,\n    value,\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.assign(Object.create(RESULT_PROTO), {\n    tag: \"Err\" as const,\n    error,\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.assign(Object.create(RESULT_PROTO), {\n    tag: \"Defect\" as const,\n    cause,\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 */\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 * 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) {\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): 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(f: (value: T) => void): 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>(name: K, f: (scope: T) => U): 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): 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): 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(f: (error: E) => void): 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 defectRes<T, E>(cause);\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 defectRes(cause);\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(f: (cause: unknown) => void): 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 defectRes<T, E>(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(fallback: T): Promise<T> {\n    return this.promise.then((r) => r.unwrapOr(fallback));\n  }\n  unwrapOrElse(f: (error: E) => T): Promise<T> {\n    return this.promise.then((r) => {\n      if (r.tag === \"Ok\") return r.value;\n      if (r.tag === \"Defect\") throw r.cause;\n      return f(r.error);\n    });\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 * Ok(42).unwrap(); // 42\n * ```\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 * Err(\"not_found\").unwrapErr(); // \"not_found\"\n * ```\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, type Result } from \"unthrown\";\n * declare const r: Result<number, string>;\n * if (isOk(r)) r.value; // number, narrowed\n * ```\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 */\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 * @returns `true` when `r` is a `Defect`.\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 */\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 * @example\n * ```ts\n * import { fromNullable } from \"unthrown\";\n * fromNullable(map.get(key), () => \"missing\").unwrap();\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 * @example\n * ```ts\n * import { fromThrowable } from \"unthrown\";\n * const parse = fromThrowable(JSON.parse, (cause, defect) => defect(cause));\n * parse(\"{}\").unwrap();\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 * @example\n * ```ts\n * import { fromPromise } from \"unthrown\";\n * const user = await fromPromise(fetchUser(id), (cause, defect) =>\n *   cause instanceof NotFoundError ? (\"not_found\" as const) : defect(cause),\n * );\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  const p = typeof promise === \"function\" ? Promise.resolve().then(promise) : 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 */\nexport function fromSafePromise<T>(\n  promise: Promise<T> | (() => Promise<T>),\n): AsyncResult<T, never> {\n  const p = typeof promise === \"function\" ? Promise.resolve().then(promise) : 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\") firstDefect ??= r;\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\") firstDefect ??= r;\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 * @example\n * ```ts\n * import { all, Ok } from \"unthrown\";\n * all([Ok(1), Ok(\"a\"), Ok(true)]).unwrap(); // [1, \"a\", true] (typed [number, string, boolean])\n * all([Ok(1), Ok(2)] as Result<number, never>[]).unwrap(); // number[]\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 * @example\n * ```ts\n * import { allFromDict, Ok } from \"unthrown\";\n * allFromDict({ id: Ok(1), name: Ok(\"ada\") }).unwrap(); // { id: 1, name: \"ada\" }\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 * @example\n * ```ts\n * import { allAsync, fromSafePromise } from \"unthrown\";\n * await allAsync([fromSafePromise(a()), fromSafePromise(b())]);\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 * @example\n * ```ts\n * import { allFromDictAsync, fromSafePromise } from \"unthrown\";\n * await allFromDictAsync({ a: fromSafePromise(a()), b: fromSafePromise(b()) });\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] as Result<unknown, unknown>;\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 * @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// 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 * @example\n * ```ts\n * import { AsyncResult } from \"unthrown\";\n * const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));\n * ```\n */\nexport const AsyncResult = {\n  fromPromise,\n  fromSafePromise,\n  all: allAsync,\n  allFromDict: allFromDictAsync,\n} as const;\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 */\nexport type TaggedErrorInstance<Tag extends string, A extends Props> = Error &\n  Readonly<A> & { 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.\n *\n * @typeParam Tag - the string literal discriminant.\n */\nexport type TaggedErrorConstructor<Tag extends string> = {\n  new <A extends Props = {}>(args: keyof A extends never ? void : A): 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.\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 * @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 */\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 * 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>`.\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 * @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class Forbidden extends TaggedError(\"Forbidden\")<{ user: string }> {}\n *\n * declare const 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 */\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: Result<T, E>,\n  handlers: TagHandlers<T, E, R>,\n): R;\nexport function matchTags<T, E extends { _tag: string }, R>(\n  result: AsyncResult<T, E>,\n  handlers: TagHandlers<T, E, R>,\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 handler = handlers[error._tag as E[\"_tag\"]] as unknown as (e: E) => R;\n    return handler(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":";;;;;;;;;;;;;;;;;AAkCA,IAAa,cAAb,cAA8C,MAAM;;;;;CAKlD;CACA,YAAY,OAAU;EACpB,MAAM,oDAAoD,EAAE,OAAO,MAAM,CAAC;EAC1E,KAAK,OAAO;EACZ,KAAK,QAAQ;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CAClD;AACF;;;;;;;;AASA,IAAM,MAAN,MAAgB;CACd,IAA2B,GAAkC;EAC3D,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GACF,OAAO,MAAM,EAAE,KAAK,KAAK,CAAC;EAC5B,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,QAAmC,GAAmD;EACpF,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GACF,OAAO,EAAE,KAAK,KAAK;EACrB,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,IAAwB,GAAqC;EAC3D,IAAI,KAAK,QAAQ,MAAM,OAAO;EAC9B,IAAI;GACF,EAAE,KAAK,KAAK;GACZ,OAAO;EACT,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,QAAgC,GAAyD;EACvF,IAAI,KAAK,QAAQ,MAAM,OAAO;EAC9B,IAAI;GACF,MAAM,IAAI,EAAE,KAAK,KAAK;GAEtB,OAAO,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;EAC9C,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,KAEE,MACA,GACgC;EAChC,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GACF,MAAM,IAAI,EAAE,KAAK,KAAK;GACtB,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GAGxC,OAAO,MAAM;IAAE,GAAG,QAAQ,KAAK,KAAK;KAAI,OAAO,EAAE;GAAM,CAAC;EAI1D,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,IAEE,MACA,GAC2B;EAC3B,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GACF,OAAO,MAAM;IAAE,GAAG,QAAQ,KAAK,KAAK;KAAI,OAAO,EAAE,KAAK,KAAK;GAAE,CAAC;EAIhE,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,GAA0B,OAAwB;EAChD,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,OAAO,MAAM,KAAK;CACpB;CAEA,OAA+B,GAAoC;EACjE,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,OAAO,OAAO,EAAE,KAAK,KAAK,CAAC;EAC7B,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,OAAkC,GAAmD;EACnF,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,OAAO,EAAE,KAAK,KAAK;EACrB,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,QAA+B,GAA0C;EACvE,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,OAAO,MAAM,EAAE,KAAK,KAAK,CAAC;EAC5B,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,OAA2B,GAAqC;EAC9D,IAAI,KAAK,QAAQ,OAAO,OAAO;EAC/B,IAAI;GACF,EAAE,KAAK,KAAK;GACZ,OAAO;EACT,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,WAAmC,GAAyD;EAC1F,IAAI,KAAK,QAAQ,OAAO,OAAO;EAC/B,IAAI;GACF,MAAM,IAAI,EAAE,KAAK,KAAK;GAEtB,OAAO,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;EAC9C,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,cAEE,GACuB;EACvB,IAAI,KAAK,QAAQ,UAAU,OAAO;EAClC,IAAI;GACF,OAAO,EAAE,KAAK,KAAK;EACrB,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,UAA8B,GAA2C;EACvE,IAAI,KAAK,QAAQ,UAAU,OAAO;EAClC,IAAI;GACF,EAAE,KAAK,KAAK;GACZ,OAAO;EACT,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,MAEE,OAKG;EACH,QAAQ,KAAK,KAAb;GACE,KAAK,MACH,OAAO,MAAM,GAAG,KAAK,KAAK;GAC5B,KAAK,OACH,OAAO,MAAM,IAAI,KAAK,KAAK;GAC7B,KAAK,UACH,OAAO,MAAM,OAAO,KAAK,KAAK;EAClC;CACF;CAEA,SAA8B;EAC5B,QAAQ,KAAK,KAAb;GACE,KAAK,MACH,OAAO,KAAK;GACd,KAAK,OACH,MAAM,IAAI,YAAY,KAAK,KAAK;GAClC,KAAK,UACH,MAAM,KAAK;EACf;CACF;CAEA,YAAiC;EAC/B,QAAQ,KAAK,KAAb;GACE,KAAK,OACH,OAAO,KAAK;GACd,KAAK,MACH,MAAM,IAAI,YAAY,KAAK,KAAK;GAClC,KAAK,UACH,MAAM,KAAK;EACf;CACF;CAEA,SAA6B,UAAgB;EAC3C,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,OAAO;CACT;CAEA,aAAiC,GAAuB;EACtD,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,OAAO,EAAE,KAAK,KAAK;CACrB;CAEA,YAAwC;EACtC,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,OAAO;CACT;CAEA,iBAAkD;EAChD,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;CAExC;CAEA,OAA+C;EAC7C,OAAO,KAAK,QAAQ;CACtB;CAEA,QAAiD;EAC/C,OAAO,KAAK,QAAQ;CACtB;CAEA,WAAuD;EACrD,OAAO,KAAK,QAAQ;CACtB;CAEA,UAA+C;EAC7C,OAAO,IAAI,SAAe,QAAQ,QAAQ,IAAI,CAAC;CACjD;AACF;AAEA,MAAM,eAAe,IAAI;;;;;;AAOzB,SAAgB,MAAY,OAAwB;CAClD,OAAO,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EAChD,KAAK;EACL;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,OAAa,OAAwB;CACnD,OAAO,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EAChD,KAAK;EACL;CACF,CAAC;AACH;;;;;;AAOA,SAAgB,UAAgB,OAA8B;CAC5D,OAAO,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EAChD,KAAK;EACL;CACF,CAAC;AACH;;;;;;;;;;;;;AAcA,SAAgB,SAAS,GAA2C;CAClE,OAAO,aAAa;AACtB;;;;;;;;;;;AAYA,SAAS,YAAkB,MAA8C;CACvE,OAAO;AACT;;;;;;;;;;;;;;;;;;;AAoBA,SAAS,QAAQ,OAAwB;CACvC,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,MAAM,IAAI,UAAU,gEAAgE;CAEtF,OAAO;AACT;;;;;;;;AASA,IAAa,WAAb,MAAa,SAA4C;CAC1B;CAA7B,YAAY,SAAiD;EAAhC,KAAA,UAAA;CAAiC;CAG9D,KACE,aACA,YACsB;EACtB,OAAO,KAAK,QAAQ,KAAK,aAAa,UAAU;CAClD;CAEA,IAAO,GAAuC;EAC5C,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,OAAO,MAAM,EAAE,EAAE,KAAK,CAAC;GACzB,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,QAAe,GAA6E;EAC1F,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,OAAO,MAAM,EAAE,EAAE,KAAK;GACxB,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,IAAI,GAA0C;EAC5C,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,MAAM,OAAO;GAC3B,IAAI;IACF,EAAE,EAAE,KAAK;IACT,OAAO;GACT,SAAS,OAAO;IACd,OAAO,UAAgB,KAAK;GAC9B;EACF,CAAC,CACH;CACF;CAEA,QACE,GACwB;EACxB,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAE7B,OAAO,MAAM,QAAQ,OAAO,IAAI,YAAY,KAAK;GACnD,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,KACE,MACA,GACqC;EACrC,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,IAAI,MAAM,QAAQ,MAAM,OAAO,YAAY,KAAK;IAChD,OAAO,MAAM;KAAE,GAAG,QAAQ,EAAE,KAAK;MAAI,OAAO,MAAM;IAAM,CAAC;GAI3D,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,IAAyB,MAAS,GAAoD;EACpF,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,OAAO,MAAM;KAAE,GAAG,QAAQ,EAAE,KAAK;MAAI,OAAO,EAAE,EAAE,KAAK;IAAE,CAAC;GAI1D,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,GAAM,OAA6B;EACjC,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAO,EAAE,QAAQ,OAAO,MAAY,KAAK,IAAI,YAAY,CAAC,CAAE,CACjF;CACF;CAEA,OAAW,GAAyC;EAClD,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,OAAO,OAAO,EAAE,EAAE,KAAK,CAAC;GAC1B,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,OAAc,GAA6E;EACzF,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,OAAO,MAAM,EAAE,EAAE,KAAK;GACxB,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,QAAW,GAA+C;EACxD,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,OAAO,MAAoB,EAAE,EAAE,KAAK,CAAC;GACvC,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,OAAO,GAA0C;EAC/C,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,OAAO,OAAO;GAC5B,IAAI;IACF,EAAE,EAAE,KAAK;IACT,OAAO;GACT,SAAS,OAAO;IACd,OAAO,UAAgB,KAAK;GAC9B;EACF,CAAC,CACH;CACF;CAEA,WACE,GACwB;EACxB,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAE7B,OAAO,MAAM,QAAQ,OAAO,YAAY,CAAC,IAAI,YAAY,KAAK;GAChE,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,cACE,GAC4B;EAC5B,OAAO,IAAI,SACT,KAAK,QAAQ,KAAK,OAAO,MAAM;GAC7B,IAAI,EAAE,QAAQ,UAAU,OAAO;GAC/B,IAAI;IACF,OAAO,MAAM,EAAE,EAAE,KAAK;GACxB,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,UAAU,GAAgD;EACxD,OAAO,IAAI,SACT,KAAK,QAAQ,MAAM,MAAM;GACvB,IAAI,EAAE,QAAQ,UAAU,OAAO;GAC/B,IAAI;IACF,EAAE,EAAE,KAAK;IACT,OAAO;GACT,SAAS,OAAO;IACd,OAAO,UAAgB,KAAK;GAC9B;EACF,CAAC,CACH;CACF;CAEA,MAAS,OAIM;EACb,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,MAAM,KAAK,CAAC;CAChD;CAEA,SAAqB;EACnB,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,OAAO,CAAC;CAC5C;CACA,YAAwB;EACtB,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,CAAC;CAC/C;CACA,SAAS,UAAyB;EAChC,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,SAAS,QAAQ,CAAC;CACtD;CACA,aAAa,GAAgC;EAC3C,OAAO,KAAK,QAAQ,MAAM,MAAM;GAC9B,IAAI,EAAE,QAAQ,MAAM,OAAO,EAAE;GAC7B,IAAI,EAAE,QAAQ,UAAU,MAAM,EAAE;GAChC,OAAO,EAAE,EAAE,KAAK;EAClB,CAAC;CACH;CACA,YAA+B;EAC7B,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,UAAU,CAAC;CAC/C;CACA,iBAAyC;EACvC,OAAO,KAAK,QAAQ,MAAM,MAAM,EAAE,eAAe,CAAC;CACpD;AACF;;;;;;;;;;;;;;;AClmBA,SAAgB,GAAM,OAA4B;CAChD,OAAO,MAAM,KAAK;AACpB;;;;;;;;;;;;;AAcA,SAAgB,IAAO,OAA4B;CACjD,OAAO,OAAO,KAAK;AACrB;;;;;;;;;;;;;AAcA,SAAgB,KAAW,GAAoC;CAC7D,OAAO,EAAE,QAAQ;AACnB;;;;;;AAMA,SAAgB,MAAY,GAAqC;CAC/D,OAAO,EAAE,QAAQ;AACnB;;;;;;AAMA,SAAgB,SAAe,GAAwC;CACrE,OAAO,EAAE,QAAQ;AACnB;;;;;;;;;;;;;;;;;;;;;;;;;ACtCA,SAAgB,KAAwB;CACtC,OAAO,GAAG,CAAC,CAAC;AACd;;;AC7BA,MAAM,SAAwB,OAAO,iBAAiB;;;;;;;;;;;;AAgCtD,SAAgB,OAAO,OAAwB;CAC7C,OAAO;GAAG,SAAS;EAAM;CAAM;AACjC;;;;;;;;AASA,SAAgB,eAAe,GAAyB;CACtD,OACE,OAAO,MAAM,YAAY,MAAM,QAAS,EAAmC,YAAY;AAE3F;;;;;;;;;;;;;;;;;;;;;;ACrBA,SAAgB,aACd,OACA,UAC2B;CAC3B,OAAO,UAAU,QAAQ,UAAU,KAAA,IAAY,IAAI,SAAS,CAAC,IAAI,GAAG,KAAuB;AAC7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,cACd,IACA,SAC+C;CAE/C,MAAM,SAAS;CACf,QAAQ,GAAG,SAA0B;EACnC,IAAI;GACF,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC;EACvB,SAAS,OAAO;GACd,OAAO,gBAAsB,OAAO,MAAM;EAC5C;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,YACd,SACA,SACoC;CAEpC,MAAM,SAAS;CAMf,OAAO,IAAI,UALD,OAAO,YAAY,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAA,CACnC,MACtC,UAAU,MAAY,KAAK,IAC3B,UAAU,gBAAsB,OAAO,MAAM,CAEhB,CAAC;AACnC;;;;;;;;;;;;;AAcA,SAAgB,gBACd,SACuB;CAMvB,OAAO,IAAI,UALD,OAAO,YAAY,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAA,CAC/B,MAC1C,UAAU,MAAgB,KAAK,IAC/B,UAAU,UAAoB,KAAK,CAEF,CAAC;AACvC;AAEA,SAAS,gBACP,OACA,SACc;CACd,IAAI;EACF,MAAM,IAAI,QAAQ,OAAO,MAAM;EAC/B,OAAO,eAAe,CAAC,IAAI,UAAgB,EAAE,KAAK,IAAI,OAAa,CAAC;CACtE,SAAS,MAAM;EAEb,OAAO,UAAgB,IAAI;CAC7B;AACF;;;;;;;AAmCA,SAAS,UAAU,SAAwE;CACzF,IAAI;CACJ,IAAI;CACJ,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,KAAK,SACd,IAAI,EAAE,QAAQ,UAAU,gBAAgB;MACnC,IAAI,EAAE,QAAQ,OAAO,aAAa;MAClC,OAAO,KAAK,EAAE,KAAK;CAE1B,OAAO,eAAe,YAAY,GAAG,MAAM;AAC7C;;;;;;;;AASA,SAAS,WAAW,SAAiD;CACnE,IAAI;CACJ,IAAI;CACJ,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,CAAC,KAAK,MAAM,OAAO,QAAQ,OAAO,GAC3C,IAAI,EAAE,QAAQ,UAAU,gBAAgB;MACnC,IAAI,EAAE,QAAQ,OAAO,aAAa;MAErC,OAAO,eAAe,QAAQ,KAAK;EACjC,OAAO,EAAE;EACT,YAAY;EACZ,UAAU;EACV,cAAc;CAChB,CAAC;CAEL,OAAO,eAAe,YAAY,GAAG,MAAM;AAC7C;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,IACd,SACwE;CACxE,OAAO,UAAU,OAAO;AAI1B;;;;;;;;;;;;;;;;;AAkBA,SAAgB,YACd,SAC2D;CAC3D,OAAO,WAAW,OAAO;AAI3B;;;;;;;;;;;;;;;;;AAkBA,SAAgB,SACd,SACuF;CAMvF,OAAO,IAAI,SAHK,QAAQ,IAAI,OAAO,CAAC,CAAC,MAAM,aACzC,UAAU,QAA+C,CAEjC,CAAC;AAI7B;;;;;;;;;;;;;;;AAgBA,SAAgB,iBACd,SAC0E;CAC1E,MAAM,UAAU,OAAO,QAAQ,OAAO;CAStC,OAAO,IAAI,SARK,QAAQ,IAAI,QAAQ,KAAK,GAAG,QAAQ,EAAE,CAAC,CAAC,CAAC,MAAM,aAAa;EAE1E,MAAM,QAAsB,OAAO,OAAO,IAAI;EAC9C,QAAQ,SAAS,CAAC,MAAM,MAAM;GAC5B,MAAM,OAAO,SAAS;EACxB,CAAC;EACD,OAAO,WAAW,KAAK;CACzB,CAC0B,CAAC;AAI7B;;;;;;;;;;;;;;;;;;;;;;;;;;AC7SA,MAAa,SAAS;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,cAAc;CACzB;CACA;CACA,KAAK;CACL,aAAa;AACf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClBA,SAAgB,YACd,KACA,SAC6B;CAC7B,MAAM,cAAc,SAAS,QAAQ;CACrC,MAAM,wBAAwB,MAAM;EAClC;EAEA,YAAY,OAAe;GACzB,MAAM,OAAO,QAAQ,eAAe,WAAY,MAAM,aAAwB,KAAA,CAAS;GACvF,IAAI,OAAO,OAAO,OAAO,MAAM,KAAK;GAGpC,KAAwB,OAAO;GAC/B,KAAK,OAAO;GACZ,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAClD;CACF;CAEA,OAAO;AACT;AAsDA,SAAgB,UACd,QACA,UACgB;CAChB,MAAM,SAAS,UAAgB;EAC7B,MAAM,UAAU,SAAS,MAAM;EAC/B,OAAO,QAAQ,KAAK;CACtB;CAGA,OAAQ,OAAwB,MAAM;EAAE,IAAI,SAAS;EAAI,KAAK;EAAO,QAAQ,SAAS;CAAO,CAAC;AAChG"}