unthrown 5.0.0-beta.4 → 5.0.0-beta.5

package/README.md

@@ -7,9 +7,14 @@
 [API Reference](https://btravstack.github.io/unthrown/api/core/)
 
 ```sh
-pnpm add unthrown
+pnpm add unthrown ts-pattern
 ```
 
+`ts-pattern` (`^5`) is a peer dependency — it powers the exhaustive error
+matchers and is re-exported as `match` / `P`. Declaring it a peer means you own
+the single copy, so `import { P } from "ts-pattern"` composes with unthrown's
+matchers.
+
 ```ts
 import { fromPromise, P, TaggedError } from "unthrown";
 
@@ -22,7 +27,7 @@ const user = fromPromise(fetchUser(id), (cause, defect) =>
 
 const status = await user.match({
   ok: () => 200,
-  err: (matcher) => matcher.with(P._, () => 404), // `err` takes the exhaustive matcher
+  errCases: (matcher) => matcher.with(P._, () => 404), // `errCases` takes the exhaustive matcher
   defect: () => 500,
 });
 ```
@@ -34,11 +39,15 @@ const status = await user.match({
   to triage each failure into a modeled error or a defect.
 - **Tagged errors** — `TaggedError(tag)` + `tag(t)`, folded exhaustively through
   `match`'s ts-pattern error matcher.
-- One tiny runtime dependency (`ts-pattern`), ESM-first, dual CJS/ESM.
+- One tiny runtime dependency (`ts-pattern`, a peer you share), ESM-first, dual
+  CJS/ESM.
 
 See the [full documentation](https://btravstack.github.io/unthrown/) for the guide
 and complete API.
 
+**Upgrading from 4.x?** See
+[Upgrade from 4.x to 5.0](https://btravstack.github.io/unthrown/how-to/upgrade-to-v5).
+
 ## License
 
 [MIT](https://github.com/btravstack/unthrown/blob/main/LICENSE) © Benoit TRAVERS

package/dist/index.cjs

@@ -232,7 +232,7 @@ var Res = class {
 	match(cases) {
 		switch (this.tag) {
 			case "Ok": return cases.ok(this.value);
-			case "Err": return cases.err((0, ts_pattern.match)(this.error)).run();
+			case "Err": return cases.errCases((0, ts_pattern.match)(this.error)).run();
 			case "Defect": return cases.defect(this.cause);
 		}
 	}
@@ -357,7 +357,8 @@ function defectRes(cause) {
 * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)
 *
 * const x: unknown = Ok(1);
-* if (isResult(x)) x.match({ ok: () => 1, err: () => 0, defect: () => -1 });
+* if (isResult(x))
+*   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });
 * ```
 *
 * @category Guards

package/dist/index.d.cts

@@ -411,25 +411,26 @@ type ResultMethods<out T, out E> = {
    * is typically the single place a pipeline is handled at the edge — mapping
    * `Ok`/`Err`/`Defect` to (for example) 2xx / 4xx / 5xx with no `try`/`catch`.
    *
-   * The `err` handler does not take a single blanket callback: it receives
+   * The `errCases` handler does not take a single blanket callback: it receives
    * `match(error)` (an {@link ErrMatcher}) and **matches the error exhaustively**,
-   * exactly like the error combinators. Chain `.with(pattern, handler)` and
-   * **return the un-terminated builder** — `match` calls `.exhaustive()` itself,
-   * so a missing case is a compile error at the call site (no `.exhaustive()` to
-   * forget). Use `.with(P._, …)` for a uniform catch-all. Unlike the combinators
-   * the branches receive **no `defect` helper** — `match` is total elimination
-   * to a value, with no `Defect` output channel; the `defect` case handles a
-   * `Result` that already carries one. (A `Result` is also a discriminated
-   * union — for richer whole-`Result` matching, `match(result).with(…)`.)
+   * exactly like the error combinators — which is why the key carries the same
+   * `…Cases` suffix. Chain `.with(pattern, handler)` and **return the
+   * un-terminated builder** — `match` calls `.exhaustive()` itself, so a missing
+   * case is a compile error at the call site (no `.exhaustive()` to forget). Use
+   * `.with(P._, …)` for a uniform catch-all. Unlike the combinators the branches
+   * receive **no `defect` helper** — `match` is total elimination to a value,
+   * with no `Defect` output channel; the `defect` case handles a `Result` that
+   * already carries one. (A `Result` is also a discriminated union — for richer
+   * whole-`Result` matching, `match(result).with(…)`.)
    *
    * @typeParam ROk - the `ok` handler return type.
    * @typeParam RDefect - the `defect` handler return type.
-   * @typeParam M - the exhaustive builder the `err` handler returns.
-   * @param cases - the `ok`/`defect` handlers plus the `err` matcher builder.
+   * @typeParam M - the exhaustive builder the `errCases` handler returns.
+   * @param cases - the `ok`/`defect` handlers plus the `errCases` matcher builder.
    */
   match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {
     ok: (value: T) => ROk;
-    err: (matcher: ErrMatcher<E>) => M;
+    errCases: (matcher: ErrMatcher<E>) => M;
     defect: (cause: unknown) => RDefect;
   }): ROk | RDefect | MatchOut<M>;
   /**
@@ -515,7 +516,7 @@ type ResultMethods<out T, out E> = {
    * @throws the modeled `error` on `Err`; re-throws the original `cause` on a
    * `Defect` (a panic, like the rest of the `getOr…` family).
    */
-  getOrThrow(this: [E] extends [never] ? never : Result$1<T, E>): T;
+  getOrThrow(this: [E] extends [never] ? "unthrown: getOrThrow is unnecessary here — the Err channel is empty (E = never), so there is nothing to throw. Use get() instead." : Result$1<T, E>): T;
   /** Whether this result is `Ok` — narrows `this` to its {@link OkView} on `true`. */
   isOk(): this is OkView<T, E>;
   /** Whether this result is `Err` — narrows `this` to its {@link ErrView} on `true`. */
@@ -637,7 +638,7 @@ type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
  *
  * const message = half(10).match({
  *   ok: (n) => `got ${n}`,
- *   err: (matcher) => matcher.with(P._, (e) => `failed: ${e}`),
+ *   errCases: (matcher) => matcher.with(P._, (e) => `failed: ${e}`),
  *   defect: (cause) => `bug: ${String(cause)}`,
  * });
  * ```
@@ -816,12 +817,12 @@ type AsyncResultMethods<out T, out E> = {
   tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): AsyncResult$1<T, E>;
   /**
    * Asynchronous {@link ResultMethods.match | match}. Handlers are synchronous
-   * (the `err` handler returns an exhaustive {@link ErrMatcher} builder, no
+   * (the `errCases` handler returns an exhaustive {@link ErrMatcher} builder, no
    * `defect` helper); resolves to a `Promise` of the folded value.
    */
   match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {
     ok: (value: T) => ROk;
-    err: (matcher: ErrMatcher<E>) => M;
+    errCases: (matcher: ErrMatcher<E>) => M;
     defect: (cause: unknown) => RDefect;
   }): Promise<ROk | RDefect | MatchOut<M>>;
   /**
@@ -850,7 +851,7 @@ type AsyncResultMethods<out T, out E> = {
    * on a `Defect`), rather than throwing synchronously. Gated the same way: it
    * compiles only when the error channel is non-empty (`E` is not `never`).
    */
-  getOrThrow(this: [E] extends [never] ? never : AsyncResult$1<T, E>): Promise<T>;
+  getOrThrow(this: [E] extends [never] ? "unthrown: getOrThrow is unnecessary here — the Err channel is empty (E = never), so there is nothing to throw. Use get() instead." : AsyncResult$1<T, E>): Promise<T>;
 };
 /**
  * The asynchronous counterpart of {@link Result}: an awaitable wrapper carrying
@@ -1173,7 +1174,8 @@ declare class GetError<E = unknown> extends Error {
  * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)
  *
  * const x: unknown = Ok(1);
- * if (isResult(x)) x.match({ ok: () => 1, err: () => 0, defect: () => -1 });
+ * if (isResult(x))
+ *   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });
  * ```
  *
  * @category Guards

package/dist/index.d.cts.map

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

package/dist/index.d.mts

@@ -411,25 +411,26 @@ type ResultMethods<out T, out E> = {
    * is typically the single place a pipeline is handled at the edge — mapping
    * `Ok`/`Err`/`Defect` to (for example) 2xx / 4xx / 5xx with no `try`/`catch`.
    *
-   * The `err` handler does not take a single blanket callback: it receives
+   * The `errCases` handler does not take a single blanket callback: it receives
    * `match(error)` (an {@link ErrMatcher}) and **matches the error exhaustively**,
-   * exactly like the error combinators. Chain `.with(pattern, handler)` and
-   * **return the un-terminated builder** — `match` calls `.exhaustive()` itself,
-   * so a missing case is a compile error at the call site (no `.exhaustive()` to
-   * forget). Use `.with(P._, …)` for a uniform catch-all. Unlike the combinators
-   * the branches receive **no `defect` helper** — `match` is total elimination
-   * to a value, with no `Defect` output channel; the `defect` case handles a
-   * `Result` that already carries one. (A `Result` is also a discriminated
-   * union — for richer whole-`Result` matching, `match(result).with(…)`.)
+   * exactly like the error combinators — which is why the key carries the same
+   * `…Cases` suffix. Chain `.with(pattern, handler)` and **return the
+   * un-terminated builder** — `match` calls `.exhaustive()` itself, so a missing
+   * case is a compile error at the call site (no `.exhaustive()` to forget). Use
+   * `.with(P._, …)` for a uniform catch-all. Unlike the combinators the branches
+   * receive **no `defect` helper** — `match` is total elimination to a value,
+   * with no `Defect` output channel; the `defect` case handles a `Result` that
+   * already carries one. (A `Result` is also a discriminated union — for richer
+   * whole-`Result` matching, `match(result).with(…)`.)
    *
    * @typeParam ROk - the `ok` handler return type.
    * @typeParam RDefect - the `defect` handler return type.
-   * @typeParam M - the exhaustive builder the `err` handler returns.
-   * @param cases - the `ok`/`defect` handlers plus the `err` matcher builder.
+   * @typeParam M - the exhaustive builder the `errCases` handler returns.
+   * @param cases - the `ok`/`defect` handlers plus the `errCases` matcher builder.
    */
   match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {
     ok: (value: T) => ROk;
-    err: (matcher: ErrMatcher<E>) => M;
+    errCases: (matcher: ErrMatcher<E>) => M;
     defect: (cause: unknown) => RDefect;
   }): ROk | RDefect | MatchOut<M>;
   /**
@@ -515,7 +516,7 @@ type ResultMethods<out T, out E> = {
    * @throws the modeled `error` on `Err`; re-throws the original `cause` on a
    * `Defect` (a panic, like the rest of the `getOr…` family).
    */
-  getOrThrow(this: [E] extends [never] ? never : Result$1<T, E>): T;
+  getOrThrow(this: [E] extends [never] ? "unthrown: getOrThrow is unnecessary here — the Err channel is empty (E = never), so there is nothing to throw. Use get() instead." : Result$1<T, E>): T;
   /** Whether this result is `Ok` — narrows `this` to its {@link OkView} on `true`. */
   isOk(): this is OkView<T, E>;
   /** Whether this result is `Err` — narrows `this` to its {@link ErrView} on `true`. */
@@ -637,7 +638,7 @@ type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
  *
  * const message = half(10).match({
  *   ok: (n) => `got ${n}`,
- *   err: (matcher) => matcher.with(P._, (e) => `failed: ${e}`),
+ *   errCases: (matcher) => matcher.with(P._, (e) => `failed: ${e}`),
  *   defect: (cause) => `bug: ${String(cause)}`,
  * });
  * ```
@@ -816,12 +817,12 @@ type AsyncResultMethods<out T, out E> = {
   tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): AsyncResult$1<T, E>;
   /**
    * Asynchronous {@link ResultMethods.match | match}. Handlers are synchronous
-   * (the `err` handler returns an exhaustive {@link ErrMatcher} builder, no
+   * (the `errCases` handler returns an exhaustive {@link ErrMatcher} builder, no
    * `defect` helper); resolves to a `Promise` of the folded value.
    */
   match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {
     ok: (value: T) => ROk;
-    err: (matcher: ErrMatcher<E>) => M;
+    errCases: (matcher: ErrMatcher<E>) => M;
     defect: (cause: unknown) => RDefect;
   }): Promise<ROk | RDefect | MatchOut<M>>;
   /**
@@ -850,7 +851,7 @@ type AsyncResultMethods<out T, out E> = {
    * on a `Defect`), rather than throwing synchronously. Gated the same way: it
    * compiles only when the error channel is non-empty (`E` is not `never`).
    */
-  getOrThrow(this: [E] extends [never] ? never : AsyncResult$1<T, E>): Promise<T>;
+  getOrThrow(this: [E] extends [never] ? "unthrown: getOrThrow is unnecessary here — the Err channel is empty (E = never), so there is nothing to throw. Use get() instead." : AsyncResult$1<T, E>): Promise<T>;
 };
 /**
  * The asynchronous counterpart of {@link Result}: an awaitable wrapper carrying
@@ -1173,7 +1174,8 @@ declare class GetError<E = unknown> extends Error {
  * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)
  *
  * const x: unknown = Ok(1);
- * if (isResult(x)) x.match({ ok: () => 1, err: () => 0, defect: () => -1 });
+ * if (isResult(x))
+ *   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });
  * ```
  *
  * @category Guards

package/dist/index.d.mts.map

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

package/dist/index.mjs

@@ -231,7 +231,7 @@ var Res = class {
 	match(cases) {
 		switch (this.tag) {
 			case "Ok": return cases.ok(this.value);
-			case "Err": return cases.err(match$1(this.error)).run();
+			case "Err": return cases.errCases(match$1(this.error)).run();
 			case "Defect": return cases.defect(this.cause);
 		}
 	}
@@ -356,7 +356,8 @@ function defectRes(cause) {
 * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)
 *
 * const x: unknown = Ok(1);
-* if (isResult(x)) x.match({ ok: () => 1, err: () => 0, defect: () => -1 });
+* if (isResult(x))
+*   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });
 * ```
 *
 * @category Guards

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["match","#promise"],"sources":["../src/defect.ts","../src/core.ts","../src/constructors.ts","../src/do.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"sourcesContent":["// 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  // Frozen like Result instances: the marker is an opaque triage token, and a\n  // mutated one must not be able to smuggle a different cause past a boundary.\n  return Object.freeze({ [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","// 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 { match } from \"ts-pattern\";\n\nimport { type Defect, defect, isDefectMarker } from \"./defect.js\";\nimport type {\n  AsyncResult,\n  Bound,\n  DefectView,\n  ErrMatcher,\n  ErrOf,\n  ErrView,\n  ExhaustiveMatch,\n  FailureView,\n  MatchErrOut,\n  MatchOut,\n  NotThenable,\n  OkOf,\n  OkView,\n  Result,\n} from \"./types.js\";\n\n/**\n * Thrown by a {@link Result}'s `get` / `getErr` when the assertion is\n * wrong on a *modeled* result — `get()` on an `Err`, or `getErr()` on an\n * `Ok`.\n *\n * @remarks\n * The offending value is exposed two ways: the typed {@link GetError.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 a `GetError`: its original cause is\n * re-thrown (with its original stack) instead.\n *\n * `get()` and `getErr()` are type-gated (`this: Result<T, never>` /\n * `Result<never, E>`), so the wrong-variant branch that throws this is\n * unreachable through well-typed code — it remains only as a defensive guard\n * against unsound runtime misuse (e.g. an `as` cast past the gate).\n *\n * @typeParam E - the type of the {@link GetError.error} it carries.\n *\n * @category Errors\n */\nexport class GetError<E = unknown> extends Error {\n  /**\n   * The offending value: the `Err` error for `get()`, or the `Ok` value for\n   * `getErr()`.\n   */\n  readonly error: E;\n  constructor(error: E) {\n    super(\"unthrown: get() / getErr() called on a non-matching Result variant\", { cause: error });\n    this.name = \"GetError\";\n    this.error = error;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\n/**\n * Method holder for {@link Result}. Never instantiated with `new` and never\n * exported; the builders below attach its prototype to plain objects. Every\n * method types `this` as the public `Result` union, so it narrows on `tag`.\n *\n * @internal\n */\nclass Res<T, E> {\n  map<U>(this: Result<T, E>, f: (value: T) => U & NotThenable<U>): Result<U, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return okRes(f(this.value));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatMap<U, E2>(this: Result<T, E>, f: (value: T) => Result<U, E2>): Result<U, E | E2> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      const r = f(this.value);\n      return isResult(r) ? r : nonResultCallbackDefect();\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tap<R>(this: Result<T, E>, f: (value: T) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Ok\") return this;\n    try {\n      f(this.value);\n      return this;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatTap<E2>(this: Result<T, E>, f: (value: T) => Result<unknown, E2>): Result<T, E | E2> {\n    if (this.tag !== \"Ok\") return this;\n    try {\n      const r = f(this.value);\n      if (!isResult(r)) return nonResultCallbackDefect();\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 (!isResult(r)) return nonResultCallbackDefect();\n      if (r.tag !== \"Ok\") return passThrough(r);\n      // The merged scope can't be spelled at the type level (a computed key\n      // widens to an index signature), so the constructed Ok is cast to `Bound`.\n      return okRes({ ...scopeOf(this.value), [name]: r.value }) as unknown as Result<\n        Bound<T, K, U>,\n        E | E2\n      >;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  let<K extends string, U>(\n    this: Result<T, E>,\n    name: K,\n    f: (scope: T) => U & NotThenable<U>,\n  ): Result<Bound<T, K, U>, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return okRes({ ...scopeOf(this.value), [name]: f(this.value) }) as unknown as Result<\n        Bound<T, K, U>,\n        E\n      >;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  as<U>(this: Result<T, E>, value: U): Result<U, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    return okRes(value);\n  }\n\n  discard(this: Result<T, E>): Result<void, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    // explicit <void, E>: inference from the argument would land on undefined, not void\n    return okRes<void, E>(undefined);\n  }\n\n  // The type-guard/boolean overload pair lives on the public surface\n  // (`ResultMethods`); this single implementation signature covers both.\n  ensure<E2>(\n    this: Result<T, E>,\n    predicate: (value: T) => boolean,\n    onFail: (value: T) => E2,\n  ): Result<T, E | E2> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      // A passing value flows through as the SAME Ok (the passThrough\n      // philosophy: nothing changed, so nothing is reallocated).\n      return predicate(this.value) ? this : errRes(onFail(this.value));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  mapErrCases<M extends ExhaustiveMatch<unknown>>(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M,\n  ): Result<T, MatchErrOut<M>> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      const out = runMatch(f, this.error);\n      if (isDefectMarker(out)) return defectRes(out.cause);\n      return errRes(out as MatchErrOut<M>);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatMapErrCases<M extends ExhaustiveMatch<Result<unknown, unknown> | Defect>>(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M,\n  ): Result<T | OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      const out = runMatch(f, this.error);\n      if (isDefectMarker(out)) return defectRes(out.cause);\n      if (!isResult(out)) return nonResultCallbackDefect();\n      return out as Result<OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>>;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  recoverErrCases<M extends ExhaustiveMatch<unknown>>(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M,\n  ): Result<T | MatchErrOut<M>, never> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      const out = runMatch(f, this.error);\n      if (isDefectMarker(out)) return defectRes(out.cause);\n      return okRes(out as MatchErrOut<M>);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tapErrCases(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<unknown>,\n  ): Result<T, E> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      runMatch(f, this.error);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.error);\n    }\n  }\n\n  flatTapErrCases<M extends ExhaustiveMatch<Result<unknown, unknown>>>(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M,\n  ): Result<T, E | ErrOf<MatchOut<M>>> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      const r = runMatch(f, this.error);\n      if (!isResult(r)) return nonResultCallbackDefect();\n      // Keep the original error on the effect's success; an Err/Defect threads through.\n      return r.tag === \"Ok\" ? this : passThrough(r);\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.error);\n    }\n  }\n\n  recoverDefect<U, E2>(\n    this: Result<T, E>,\n    f: (cause: unknown) => Result<U, E2>,\n  ): Result<T | U, E | E2> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      const r = f(this.cause);\n      return isResult(r) ? r : nonResultCallbackDefect();\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tapDefect<R>(this: Result<T, E>, f: (cause: unknown) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      f(this.cause);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.cause);\n    }\n  }\n\n  tapFailure<R>(\n    this: Result<T, E>,\n    f: (failure: FailureView<E, T>) => R & NotThenable<R>,\n  ): Result<T, E> {\n    if (this.tag === \"Ok\") return this;\n    try {\n      f(this);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.tag === \"Err\" ? this.error : this.cause);\n    }\n  }\n\n  match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(\n    this: Result<T, E>,\n    cases: {\n      ok: (value: T) => ROk;\n      err: (matcher: ErrMatcher<E>) => M;\n      defect: (cause: unknown) => RDefect;\n    },\n  ): ROk | RDefect | MatchOut<M> {\n    switch (this.tag) {\n      case \"Ok\":\n        return cases.ok(this.value);\n      case \"Err\":\n        // The `err` handler returns the un-terminated builder; `.run()` executes\n        // `.exhaustive()`. Type-forced exhaustive for well-typed callers; a value\n        // slipping past the types (widened cast, JS caller) with no matching case\n        // throws ts-pattern's `NonExhaustiveError` — `match` is an edge eliminator,\n        // so it surfaces rather than being caught into a Defect.\n        return cases.err(match(this.error) as ErrMatcher<E>).run() as MatchOut<M>;\n      case \"Defect\":\n        return cases.defect(this.cause);\n    }\n  }\n\n  get(this: Result<T, E>): T {\n    switch (this.tag) {\n      case \"Ok\":\n        return this.value;\n      case \"Err\":\n        throw new GetError(this.error);\n      case \"Defect\":\n        throw this.cause; // rethrow original cause, original stack\n    }\n  }\n\n  getErr(this: Result<T, E>): E {\n    switch (this.tag) {\n      case \"Err\":\n        return this.error;\n      case \"Ok\":\n        throw new GetError(this.value);\n      case \"Defect\":\n        throw this.cause;\n    }\n  }\n\n  getOr<U>(this: Result<T, E>, fallback: U): T | U {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return fallback;\n  }\n\n  getOrElse<U>(this: Result<T, E>, f: (error: E) => U): T | U {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return f(this.error);\n  }\n\n  getOrNull(this: Result<T, E>): T | null {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return null;\n  }\n\n  getOrUndefined(this: Result<T, E>): T | undefined {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return undefined;\n  }\n\n  getOrThrow(this: Result<T, E>): T {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    throw this.error;\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\n/**\n * Cross-copy brand: `Symbol.for` yields the same symbol in every copy of the\n * library (the dual CJS/ESM build, a duplicated install, another realm), so\n * {@link isResult} can recognise a `Result` built by another copy whose `Res`\n * class fails the `instanceof` check. Defined non-enumerably on the prototype,\n * before it is frozen.\n *\n * @internal\n */\nconst RESULT_BRAND = Symbol.for(\"unthrown.Result\");\n\nconst RESULT_PROTO = Res.prototype;\nObject.defineProperty(RESULT_PROTO, RESULT_BRAND, { value: true });\n// Frozen prototype: the shared combinators cannot be swapped out from under\n// every instance (the instances themselves are frozen by the builders below).\nObject.freeze(RESULT_PROTO);\n\n/**\n * Construct an `Ok` result — a plain object on the {@link Res} prototype.\n *\n * @internal\n */\nexport function okRes<T, E>(value: T): Result<T, E> {\n  // Frozen so the `readonly` surface is real at runtime: a variant cannot be\n  // forged by mutating `tag`/payload after construction.\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Ok\" as const,\n      value,\n    }),\n  ) as OkView<T, E>;\n}\n\n/**\n * Construct an `Err` result.\n *\n * @internal\n */\nexport function errRes<T, E>(error: E): Result<T, E> {\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Err\" as const,\n      error,\n    }),\n  ) as ErrView<E, T>;\n}\n\n/**\n * Construct a `Defect` result.\n *\n * @internal\n */\nexport function defectRes<T, E>(cause: unknown): Result<T, E> {\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Defect\" as const,\n      cause,\n    }),\n  ) as DefectView<T, E>;\n}\n\n/**\n * Type guard: is `x` a {@link Result} (any of `Ok` / `Err` / `Defect`)?\n *\n * @remarks\n * Unlike {@link isOk} / {@link isErr} / {@link isDefect}, which narrow a value\n * already known to be a `Result`, this narrows from `unknown` — useful at an\n * untyped boundary. It checks the value carries the `Result` prototype\n * (`instanceof` first, falling back to the `Symbol.for(\"unthrown.Result\")`\n * brand the prototype carries — so a `Result` built by **another copy** of\n * unthrown, e.g. the CJS and ESM builds loaded side by side, is still\n * recognised). A look-alike plain object (`{ tag: \"Ok\" }`) carries neither and\n * is **not** matched. An `AsyncResult` is not a `Result` and returns `false`.\n *\n * @returns `true` when `x` is a `Result` produced by this library.\n *\n * @example\n * ```ts\n * import { isResult, Ok } from \"unthrown\";\n *\n * isResult(Ok(1)); // => true\n * isResult({ tag: \"Ok\" }); // => false (look-alike, wrong prototype)\n * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)\n *\n * const x: unknown = Ok(1);\n * if (isResult(x)) x.match({ ok: () => 1, err: () => 0, defect: () => -1 });\n * ```\n *\n * @category Guards\n */\nexport function isResult(x: unknown): x is Result<unknown, unknown> {\n  if (x instanceof Res) return true;\n  // Dual-copy / cross-realm fallback: another copy of unthrown has its own\n  // `Res`, so `instanceof` fails — but its prototype carries the shared\n  // `Symbol.for` brand. Reading the brand off the prototype chain keeps the\n  // guarantee that a structural look-alike (no unthrown prototype) still fails.\n  // Fail-closed: this guard exists for untyped boundaries, so a hostile input\n  // (a Proxy `get` trap or a throwing getter at the brand key) is `false`,\n  // never a throw.\n  try {\n    return (\n      (typeof x === \"object\" || typeof x === \"function\") &&\n      x !== null &&\n      Reflect.get(x, RESULT_BRAND) === true\n    );\n  } catch {\n    return false;\n  }\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 * The Defect minted when a callback constrained to return a `Result` returns\n * something else — reachable only from untyped/cast callers (in typed code the\n * constraint is a compile error). The combinator-side sibling of the\n * aggregates' non-`Result`-element guard: surface the out-of-contract value as\n * a `Defect` here rather than letting a poison value throw a raw `TypeError`\n * further down the pipeline.\n *\n * @internal\n */\nfunction nonResultCallbackDefect<T, E>(): Result<T, E> {\n  return defectRes(new TypeError(\"unthrown: a combinator callback returned a non-Result value\"));\n}\n\n/**\n * Drive an error-combinator callback: build `match(error)`, hand it (plus the\n * injected `defect`) to the callback, and `.run()` the returned exhaustive\n * builder to its output. `.run()` executes `.exhaustive()` — type-forced\n * exhaustive, so it always matches for well-typed callers; a value that slips\n * through the types (a widened cast, a JS caller) throws `NonExhaustiveError`,\n * which the caller's `try/catch` turns into a `Defect` — an unmodeled failure.\n *\n * @internal\n */\nfunction runMatch<E>(\n  f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => { run: () => unknown },\n  error: E,\n): unknown {\n  return f(match(error) as ErrMatcher<E>, defect).run();\n}\n\n/**\n * A throw inside a *failure observer* (`tapErrCases` / `tapDefect` / `flatTapErrCases`)\n * must not destroy the failure being observed — that is the exact place (e.g. a\n * failing error-logger) where losing the underlying failure hurts most. The\n * resulting Defect aggregates both: `errors[0]` is the observer's throw,\n * `errors[1]` the original failure.\n *\n * @internal\n */\nfunction observerThrowToDefect<T, E>(thrown: unknown, original: unknown): Result<T, E> {\n  return defectRes(\n    new AggregateError(\n      [thrown, original],\n      \"unthrown: a failure-observer callback threw; errors[0] is the callback's throw, errors[1] the original failure\",\n    ),\n  );\n}\n\n/**\n * Validate that a `bind`/`let` scope is a real (non-null) object before merging a\n * key into it.\n *\n * @remarks\n * Do-notation accumulates an **object** scope: a chain starts at `Do()` (an\n * empty object) and every `bind`/`let` returns an object, so in typed code the\n * scope is always an object. The method lives on the general `Result` surface,\n * though, so a primitive `Ok` (e.g. `Ok(5).bind(...)`, or a chain whose value was\n * `map`-ped away from its scope) could reach it. Rather than let `{ ...5 }`\n * silently collapse to `{}` and drop the prior scope, we throw here — the\n * surrounding `try` turns it into a `Defect`, surfacing the misuse as the\n * bug it is (a defect is a bug, not an absent value). A `this: object` constraint\n * was rejected: TypeScript does not hard-enforce a constraint inferred solely\n * from `this`, and it breaks `AsyncRes implements AsyncResult`.\n *\n * @internal\n */\nfunction scopeOf(value: unknown): object {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(\"bind/let requires an object scope — start a do-chain with Do()\");\n  }\n  return value;\n}\n\n/**\n * The sole runtime implementation of {@link AsyncResult}: wraps a\n * `Promise<Result>` constructed never to reject. Operates on the public `Result`\n * union (via `tag`), never on `Res` internals. Never re-exported from `index.ts`.\n *\n * @internal\n */\nexport class AsyncRes<T, E> implements AsyncResult<T, E> {\n  // A native #private field: invisible to property access and untouchable even\n  // via Object.defineProperty, so the wrapped promise cannot be tampered with.\n  readonly #promise: Promise<Result<T, E>>;\n\n  constructor(promise: Promise<Result<T, E>>) {\n    this.#promise = promise;\n  }\n\n  // oxlint-disable-next-line no-thenable -- AsyncResult is an intentional (success-only) thenable so `await` collapses it to a Result; see the Awaitable type. onrejected is still forwarded so a hypothetical internal rejection settles the await instead of hanging — though the internal promise never rejects.\n  then<R1 = Result<T, E>, R2 = never>(\n    onfulfilled?: ((value: Result<T, E>) => R1 | PromiseLike<R1>) | null,\n    onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null,\n  ): PromiseLike<R1 | R2> {\n    return this.#promise.then(onfulfilled, onrejected);\n  }\n\n  map<U>(f: (value: T) => U & NotThenable<U>): AsyncResult<U, E> {\n    return new AsyncRes<U, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return okRes(f(r.value));\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  flatMap<U, E2>(f: (value: T) => Result<U, E2> | AsyncResult<U, E2>): AsyncResult<U, E | E2> {\n    return new AsyncRes<U, E | E2>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          const inner = await f(r.value);\n          return isResult(inner) ? inner : nonResultCallbackDefect<U, E | E2>();\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tap<R>(f: (value: T) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Ok\") return r;\n        try {\n          f(r.value);\n          return r;\n        } catch (cause) {\n          return defectRes<T, E>(cause);\n        }\n      }),\n    );\n  }\n\n  flatTap<E2>(\n    f: (value: T) => Result<unknown, E2> | AsyncResult<unknown, E2>,\n  ): AsyncResult<T, E | E2> {\n    return new AsyncRes<T, E | E2>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          const inner = await f(r.value);\n          if (!isResult(inner)) return nonResultCallbackDefect();\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 (!isResult(inner)) return nonResultCallbackDefect();\n          if (inner.tag !== \"Ok\") return passThrough(inner);\n          return okRes({ ...scopeOf(r.value), [name]: inner.value }) as unknown as Result<\n            Bound<T, K, U>,\n            E | E2\n          >;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  let<K extends string, U>(\n    name: K,\n    f: (scope: T) => U & NotThenable<U>,\n  ): AsyncResult<Bound<T, K, U>, E> {\n    return new AsyncRes<Bound<T, K, U>, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return okRes({ ...scopeOf(r.value), [name]: f(r.value) }) as unknown as Result<\n            Bound<T, K, U>,\n            E\n          >;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  as<U>(value: U): AsyncResult<U, E> {\n    return new AsyncRes<U, E>(\n      this.#promise.then((r) => (r.tag === \"Ok\" ? okRes<U, E>(value) : passThrough(r))),\n    );\n  }\n\n  discard(): AsyncResult<void, E> {\n    return new AsyncRes<void, E>(\n      this.#promise.then((r) => (r.tag === \"Ok\" ? okRes<void, E>(undefined) : passThrough(r))),\n    );\n  }\n\n  // Like the matcher methods below, `ensure` is typed loosely here (`never`\n  // channels) because TypeScript cannot relate this single implementation\n  // signature to the public type-guard/boolean overload pair across the\n  // class/`implements` boundary; `AsyncResultMethods` re-imposes the precision.\n  ensure(\n    predicate: (value: T) => boolean,\n    onFail: (value: T) => unknown,\n  ): AsyncResult<never, never> {\n    return new AsyncRes<never, never>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          // A passing value flows through as the same Ok (see the sync `ensure`).\n          return (predicate(r.value) ? r : errRes(onFail(r.value))) as Result<never, never>;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  // The precise generic-M matcher signatures live on the public surface\n  // (`AsyncResultMethods`); TypeScript cannot unify them across the\n  // class/`implements` boundary (relating the two generic signatures fails to\n  // equate `MatchErrOut<M>` on each side), so these implementations are typed\n  // loosely — `never` error channels keep the returns bivariantly compatible —\n  // and the interface re-imposes the precision, mirroring how `get`'s `this`\n  // gate is re-imposed in `types.ts`.\n  mapErrCases(\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<unknown>,\n  ): AsyncResult<T, never> {\n    return new AsyncRes<T, never>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const out = runMatch(f, r.error);\n          if (isDefectMarker(out)) return defectRes<T, never>(out.cause);\n          return errRes<T, never>(out as never);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  flatMapErrCases(\n    f: (\n      matcher: ErrMatcher<E>,\n      defect: (cause: unknown) => Defect,\n    ) => ExhaustiveMatch<Result<unknown, unknown> | AsyncResult<unknown, unknown> | Defect>,\n  ): AsyncResult<T, never> {\n    return new AsyncRes<T, never>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const out = runMatch(f, r.error);\n          if (isDefectMarker(out)) return defectRes<T, never>(out.cause);\n          const inner = await (out as Result<unknown, unknown> | AsyncResult<unknown, unknown>);\n          if (!isResult(inner)) return nonResultCallbackDefect<T, never>();\n          return inner as Result<T, never>;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  recoverErrCases(\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<unknown>,\n  ): AsyncResult<T, never> {\n    return new AsyncRes<T, never>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const out = runMatch(f, r.error);\n          if (isDefectMarker(out)) return defectRes<T, never>(out.cause);\n          return okRes<T, never>(out as T);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tapErrCases(\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<unknown>,\n  ): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Err\") return r;\n        try {\n          runMatch(f, r.error);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.error);\n        }\n      }),\n    );\n  }\n\n  flatTapErrCases(\n    f: (\n      matcher: ErrMatcher<E>,\n      defect: (cause: unknown) => Defect,\n    ) => ExhaustiveMatch<Result<unknown, unknown> | AsyncResult<unknown, unknown>>,\n  ): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const inner = await (runMatch(f, r.error) as\n            | Result<unknown, unknown>\n            | AsyncResult<unknown, unknown>);\n          if (!isResult(inner)) return nonResultCallbackDefect();\n          // Keep the original error on success; an Err/Defect from the effect wins.\n          return inner.tag === \"Ok\" ? passThrough(r) : passThrough(inner);\n        } catch (cause) {\n          return observerThrowToDefect(cause, r.error);\n        }\n      }),\n    );\n  }\n\n  recoverDefect<U, E2>(\n    f: (cause: unknown) => Result<U, E2> | AsyncResult<U, E2>,\n  ): AsyncResult<T | U, E | E2> {\n    return new AsyncRes<T | U, E | E2>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Defect\") return r;\n        try {\n          const inner = await f(r.cause);\n          return isResult(inner) ? inner : nonResultCallbackDefect<T | U, E | E2>();\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Defect\") return r;\n        try {\n          f(r.cause);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.cause);\n        }\n      }),\n    );\n  }\n\n  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then((r) => {\n        if (r.tag === \"Ok\") return r;\n        try {\n          f(r);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.tag === \"Err\" ? r.error : r.cause);\n        }\n      }),\n    );\n  }\n\n  match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {\n    ok: (value: T) => ROk;\n    err: (matcher: ErrMatcher<E>) => M;\n    defect: (cause: unknown) => RDefect;\n  }): Promise<ROk | RDefect | MatchOut<M>> {\n    return this.#promise.then((r) => r.match(cases));\n  }\n\n  get(): Promise<T> {\n    return this.#promise.then((r) => (r as Result<T, never>).get());\n  }\n  getErr(): Promise<E> {\n    return this.#promise.then((r) => (r as Result<never, E>).getErr());\n  }\n  getOr<U>(fallback: U): Promise<T | U> {\n    return this.#promise.then((r) => r.getOr(fallback));\n  }\n  getOrElse<U>(f: (error: E) => U): Promise<T | U> {\n    return this.#promise.then((r) => r.getOrElse(f));\n  }\n  getOrNull(): Promise<T | null> {\n    return this.#promise.then((r) => r.getOrNull());\n  }\n  getOrUndefined(): Promise<T | undefined> {\n    return this.#promise.then((r) => r.getOrUndefined());\n  }\n  getOrThrow(): Promise<T> {\n    // The cast sidesteps `getOrThrow`'s `this` gate (non-empty error channel),\n    // re-imposed on the public `AsyncResultMethods` signature — mirroring `get`.\n    return this.#promise.then((r) => (r as Result<T, unknown>).getOrThrow());\n  }\n}\n\n// Same hardening as `Res.prototype` above: the shared async combinators cannot\n// be swapped out from under every instance. (The wrapped promise is already a\n// native #private field, unreachable from outside.)\nObject.freeze(AsyncRes.prototype);\n","// Result constructors and the standalone narrowing guards.\n\nimport { errRes, okRes } from \"./core.js\";\nimport type { AsyncResult, DefectView, ErrView, OkView, Result } from \"./types.js\";\n\n/**\n * Construct a successful `void` {@link Result} — `Result<void, never>` —\n * sparing you `Ok(undefined)` and typing the success channel `void`, not\n * `undefined`.\n *\n * @example\n * ```ts\n * import { Ok } from \"unthrown\";\n *\n * Ok(); // => a void success: Result<void, never>\n * ```\n *\n * @category Constructors\n */\nexport function Ok(): Result<void, never>;\n/**\n * Construct a successful {@link Result}.\n *\n * @typeParam T - the success value type.\n * @param value - the success value to wrap.\n *\n * @example\n * ```ts\n * import { Ok } from \"unthrown\";\n *\n * Ok(2).map((n) => n + 1); // => Ok(3)\n * Ok(42).get(); // => 42\n * ```\n *\n * @category Constructors\n */\nexport function Ok<T>(value: T): Result<T, never>;\nexport function Ok<T>(value?: T): Result<T, never> {\n  // The only way in with no argument is the no-arg overload, which fixes the\n  // result type to void — exactly what the omitted undefined inhabits.\n  // Invisible to callers.\n  return okRes(value as T);\n}\n\n/**\n * Construct a failed {@link Result} carrying a **modeled** error.\n *\n * @typeParam E - the modeled error type.\n * @param error - the domain error to wrap.\n *\n * @example\n * ```ts\n * import { Err } from \"unthrown\";\n *\n * Err(\"not_found\").map((n) => n + 1); // => Err(\"not_found\") (map skipped)\n * Err(\"not_found\").getErr(); // => \"not_found\"\n * ```\n *\n * @category Constructors\n */\nexport function Err<E>(error: E): Result<never, E> {\n  return errRes(error);\n}\n\n/**\n * Construct a successful `void` {@link AsyncResult} — `AsyncResult<void, never>`\n * — the pre-lifted form of the no-arg {@link Ok}, sparing you\n * `Ok(undefined).toAsync()`.\n *\n * @example\n * ```ts\n * import { OkAsync } from \"unthrown\";\n *\n * OkAsync(); // => a void success: AsyncResult<void, never>\n * ```\n *\n * @category Constructors\n */\nexport function OkAsync(): AsyncResult<void, never>;\n/**\n * Construct a successful {@link AsyncResult} from a pure value — the pre-lifted\n * form of {@link Ok}, sparing you `Ok(value).toAsync()`.\n *\n * @remarks\n * Reach for this on the synchronous/early branch of an `AsyncResult`-returning\n * function, so both branches share one return type without a trailing\n * `.toAsync()`. Named with the `Async` suffix the async free functions carry\n * (`allAsync`, `allFromDictAsync`); the {@link AsyncResult} companion aliases it\n * as `AsyncResult.Ok` (the namespace already says \"async\", so the suffix drops).\n *\n * @typeParam T - the success value type.\n * @param value - the success value to wrap.\n *\n * @example\n * ```ts\n * import { OkAsync, type AsyncResult } from \"unthrown\";\n *\n * function loadItems(ids: string[]): AsyncResult<Item[], never> {\n *   if (ids.length === 0) return OkAsync([]); // no more Ok([]).toAsync()\n *   return itemRepository.load(ids);\n * }\n * ```\n *\n * @category Constructors\n */\nexport function OkAsync<T>(value: T): AsyncResult<T, never>;\nexport function OkAsync<T>(value?: T): AsyncResult<T, never> {\n  // Same deliberate cast as `Ok` above: argument-less means the no-arg\n  // overload already fixed the type to `void`.\n  return Ok(value as T).toAsync();\n}\n\n/**\n * Construct a failed {@link AsyncResult} carrying a **modeled** error — the\n * pre-lifted form of {@link Err}, sparing you `Err(error).toAsync()`.\n *\n * @remarks\n * The error-channel mirror of {@link OkAsync}; see it for the naming and the\n * `AsyncResult.Err` companion alias.\n *\n * @typeParam E - the modeled error type.\n * @param error - the domain error to wrap.\n *\n * @example\n * ```ts\n * import { ErrAsync } from \"unthrown\";\n *\n * ErrAsync(\"not_found\"); // AsyncResult<never, string>\n * ```\n *\n * @category Constructors\n */\nexport function ErrAsync<E>(error: E): AsyncResult<never, E> {\n  return Err(error).toAsync();\n}\n\n/**\n * Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.\n *\n * @returns `true` when `r` is `Ok`.\n *\n * @example\n * ```ts\n * import { isOk, Ok, Err, type Result } from \"unthrown\";\n *\n * isOk(Ok(1)); // => true\n * isOk(Err(\"boom\")); // => false\n *\n * declare const r: Result<number, string>;\n * if (isOk(r)) r.value; // number, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isOk<T, E>(r: Result<T, E>): r is OkView<T, E> {\n  return r.tag === \"Ok\";\n}\n/**\n * Type guard: narrow a {@link Result} to its `Err` variant, exposing `.error`.\n *\n * @returns `true` when `r` is `Err`.\n *\n * @example\n * ```ts\n * import { isErr, Ok, Err, type Result } from \"unthrown\";\n *\n * isErr(Err(\"boom\")); // => true\n * isErr(Ok(1)); // => false\n *\n * declare const r: Result<number, string>;\n * if (isErr(r)) r.error; // string, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isErr<T, E>(r: Result<T, E>): r is ErrView<E, T> {\n  return r.tag === \"Err\";\n}\n/**\n * Type guard: narrow a {@link Result} to its `Defect` variant, exposing `.cause`.\n *\n * @remarks\n * A `Defect` has no public constructor — it only arises at a boundary (e.g. a\n * callback throwing inside a combinator). This guard is how you detect one.\n *\n * @returns `true` when `r` is a `Defect`.\n *\n * @example\n * ```ts\n * import { isDefect, Ok } from \"unthrown\";\n *\n * // A throw inside a combinator is captured as a Defect:\n * const r = Ok(1).map(() => {\n *   throw new Error(\"boom\");\n * });\n * isDefect(r); // => true\n * isDefect(Ok(1)); // => false\n *\n * if (isDefect(r)) r.cause; // unknown, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isDefect<T, E>(r: Result<T, E>): r is DefectView<T, E> {\n  return r.tag === \"Defect\";\n}\n","// Do-notation entry point. The `bind` / `let` steps live on the `Result` /\n// `AsyncResult` method surface (core.ts); `Do()` just seeds an empty object\n// scope to grow.\n\nimport { Ok } from \"./constructors.js\";\nimport type { AsyncResult, Result } from \"./types.js\";\n\n/**\n * Start a do-notation chain with an empty object scope, grown step by step with\n * `bind` (for `Result`-returning steps) and `let` (for pure values).\n *\n * @remarks\n * Capitalised because `do` is a reserved word. Each step receives the scope\n * accumulated so far; the error types union across `bind`s, and a throw in any\n * step becomes a `Defect`. To go asynchronous, lift the chain with `toAsync()`\n * (then a `bind` may return an `AsyncResult`).\n *\n * @example\n * ```ts\n * import { Do, Ok } from \"unthrown\";\n *\n * const result = Do()\n *   .bind(\"user\", () => findUser(id)) // Result<User, NotFound>\n *   .bind(\"org\", ({ user }) => findOrg(user.orgId)) // Result<Org, NotFound>\n *   .let(\"label\", ({ user, org }) => `${user.name} @ ${org.name}`)\n *   .map(({ user, org, label }) => render(user, org, label));\n * // Result<View, NotFound>\n * ```\n *\n * @example\n * ```ts\n * import { Do, Ok, Err } from \"unthrown\";\n *\n * // Ok path — the scope accumulates:\n * Do()\n *   .bind(\"a\", () => Ok(2))\n *   .let(\"b\", ({ a }) => a * 10)\n *   .map(({ a, b }) => a + b); // => Ok(22)\n *\n * // Err path — the first Err short-circuits the rest:\n * Do()\n *   .bind(\"a\", () => Err(\"boom\"))\n *   .let(\"b\", ({ a }) => a); // => Err(\"boom\")\n * ```\n *\n * @category Do-notation\n */\nexport function Do(): Result<{}, never> {\n  return Ok({});\n}\n\n/**\n * Start an **asynchronous** do-notation chain with an empty object scope — the\n * pre-lifted form of {@link Do}, sparing you `Do().toAsync()`.\n *\n * @remarks\n * From here a `bind` may return a `Result` **or** an `AsyncResult`; the scope\n * accumulates exactly as in a sync {@link Do} chain, and a throw in any step\n * becomes a `Defect`. Named with the `Async` suffix the async free functions\n * carry (`OkAsync`, `allAsync`); the {@link AsyncResult} companion aliases it as\n * `AsyncResult.Do` (the namespace already says \"async\", so the suffix drops).\n *\n * @example\n * ```ts\n * import { DoAsync, Ok } from \"unthrown\";\n *\n * const result = await DoAsync()\n *   .bind(\"user\", () => findUser(id)) // AsyncResult<User, NotFound>\n *   .bind(\"plan\", ({ user }) => Ok(user.plan)) // a sync Result is accepted too\n *   .let(\"label\", ({ user, plan }) => `${user.name} on ${plan}`);\n * // Result<{ user: User; plan: Plan; label: string }, NotFound>\n * ```\n *\n * @category Do-notation\n */\nexport function DoAsync(): AsyncResult<{}, never> {\n  return Do().toAsync();\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 { Err, Ok } from \"./constructors.js\";\nimport { AsyncRes, defectRes, errRes, isResult, okRes } from \"./core.js\";\nimport { type Defect, defect, isDefectMarker } from \"./defect.js\";\nimport type {\n  AsyncErrOf,\n  AsyncOkOf,\n  AsyncResult,\n  ErrOf,\n  NotThenable,\n  OkOf,\n  Result,\n} from \"./types.js\";\n\n/**\n * Bridge a nullable value into a {@link Result}: absence becomes a **modeled**\n * `Err`. The sanctioned alternative to an `Option` type.\n *\n * @remarks\n * `null` and `undefined` map to `Err(onAbsent())`; any other value (including\n * falsy ones like `0`, `\"\"`, `false`) maps to `Ok`.\n *\n * @typeParam T - the (nullable) value type.\n * @typeParam E - the error produced when the value is absent.\n * @param value - the possibly-absent value.\n * @param onAbsent - lazily produces the error for the absent case.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromNullable } from \"unthrown\";\n *\n * const map = new Map([[\"a\", 1]]);\n * fromNullable(map.get(\"a\"), () => \"absent\").getOr(0); // => 1\n * fromNullable(map.get(\"z\"), () => \"absent\"); // => Err(\"absent\")\n * fromNullable(0, () => \"absent\").getOr(-1); // => 0 (falsy but present)\n * ```\n */\nexport function fromNullable<T, E>(\n  value: T | null | undefined,\n  onAbsent: () => E,\n): Result<NonNullable<T>, E> {\n  return value === null || value === undefined ? Err(onAbsent()) : Ok(value as NonNullable<T>);\n}\n\n/**\n * Wrap a throwing synchronous function so it returns a {@link Result} instead of\n * throwing.\n *\n * @remarks\n * `qualify` **must** triage every thrown cause into a modeled error `E` or a\n * `Defect` (via the injected `defect` helper, its second argument) — there is no\n * path that leaves `unknown` in `E`. A throw inside `qualify` itself is treated\n * as a `Defect`. `qualify` is **synchronous**: an `async` qualify is rejected at\n * compile time ({@link NotThenable}) — its `Promise` would land in `E` un-triaged\n * — and a thenable slipped past the types at runtime becomes a `Defect` (never\n * an `Err(Promise)`), its orphaned rejection silenced.\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 fromSafeThrowable} when every throw is a Defect.\n *\n * @typeParam A - the wrapped function's argument tuple.\n * @typeParam T - the wrapped function's return type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param fn - the throwing function to wrap.\n * @param qualify - triages a thrown `cause` into a modeled `E`, or marks it\n * unmodeled by returning `defect(cause)` (the helper passed as its second arg).\n * @returns a function with the same arguments returning `Result<T, E>`.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromThrowable } from \"unthrown\";\n *\n * // Model the parse failure as an `Err`, everything unexpected as a `Defect`.\n * const parse = fromThrowable(\n *   (text: string) => JSON.parse(text) as unknown,\n *   (cause, defect) =>\n *     cause instanceof SyntaxError ? (\"invalid_json\" as const) : defect(cause),\n * );\n *\n * parse('{\"ok\":true}').getOr(null); // => { ok: true }\n * parse(\"nope\"); // => Err(\"invalid_json\")\n * ```\n */\nexport function fromThrowable<A extends unknown[], T, R>(\n  fn: (...args: A) => T,\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R & NotThenable<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 throwing synchronous function asserted **not** to fail in any modeled\n * way: any throw becomes a `Defect`.\n *\n * @remarks\n * The synchronous counterpart of {@link fromSafePromise}. Use it only when a\n * throw genuinely indicates a bug rather than an anticipated outcome — the\n * error channel is `never`, so there is nothing to triage; there is no\n * `qualify`. When some throws *are* anticipated, reach for\n * {@link fromThrowable} and triage them.\n *\n * @typeParam A - the wrapped function's argument tuple.\n * @typeParam T - the wrapped function's return type.\n * @param fn - the throwing function to wrap.\n * @returns a function with the same arguments returning `Result<T, never>`.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromSafeThrowable } from \"unthrown\";\n *\n * // A decode failure here is a bug (the row came from our own schema), so\n * // every throw is a defect — no throwaway `(cause, defect) => defect(cause)`.\n * const decode = fromSafeThrowable((row: Row) => userSchema.parse(row));\n *\n * decode(row); // => Result<User, never> — a throw becomes a Defect\n * ```\n */\nexport function fromSafeThrowable<A extends unknown[], T>(\n  fn: (...args: A) => T,\n): (...args: A) => Result<T, never> {\n  return (...args: A): Result<T, never> => {\n    try {\n      return Ok(fn(...args));\n    } catch (cause) {\n      return defectRes<T, never>(cause);\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`. `qualify` is\n * **synchronous**: an `async` qualify is rejected at compile time\n * ({@link NotThenable}), and a thenable slipped past the types at runtime\n * becomes a `Defect` (never an `Err(Promise)`), its orphaned rejection silenced.\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 * @param _guard - compile-time only; never pass it. The phantom rest-tuple that\n * enforces \"qualify is synchronous\": an `async` qualify makes this demand an\n * impossible extra argument (whose type spells out the error), while a\n * synchronous one leaves it empty. Encoded here — not on `qualify`'s return\n * type — so `T`'s inference from `promise` is undisturbed.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromPromise } from \"unthrown\";\n *\n * // A rejection with a NotFoundError becomes a modeled `Err`; anything else a Defect.\n * const user = await fromPromise(fetchUser(id), (cause, defect) =>\n *   cause instanceof NotFoundError ? (\"not_found\" as const) : defect(cause),\n * );\n *\n * if (user.isOk()) user.value; // => the fetched user\n * // when fetchUser rejects with NotFoundError: user is Err(\"not_found\")\n * ```\n */\nexport function fromPromise<T, R>(\n  promise: Promise<T> | (() => Promise<T>),\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R,\n  // Phantom rest-tuple guard — the async-qualify ban, encoded OFF the callback's\n  // return type: `R & NotThenable<R>` there made TS defer qualify's inference,\n  // which collapsed `T` to `unknown` for an inline `.then(…)` chain argument.\n  // With the conditional here instead, an async qualify demands an impossible\n  // third argument (compile error carrying the message) while `T`/`R` infer\n  // normally. Nothing is ever passed at runtime.\n  //\n  // `Extract` (not `[R] extends [PromiseLike<…>]`) so the ban also fires when\n  // only SOME arms of a union return are thenable (`E | Promise<X>` — a\n  // sometimes-async qualify is still an unqualified rejection path), and it\n  // vacuously admits the always-throwing qualify (`R = never` extracts to\n  // `never`) with no special case. The runtime thenable→Defect net in\n  // `qualifyToResult` stays as the last resort for untyped callers.\n  ..._guard: [Extract<R, PromiseLike<unknown>>] extends [never]\n    ? []\n    : [\"unthrown: qualify must be synchronous — its Promise would land in E un-triaged\"]\n): AsyncResult<T, Exclude<R, Defect>> {\n  type E = Exclude<R, Defect>;\n  const triage = qualify as (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect;\n  // Promise.resolve() also absorbs a non-thenable passed from untyped code, so\n  // this boundary never throws synchronously — it exists to prevent throws.\n  const p =\n    typeof promise === \"function\" ? Promise.resolve().then(promise) : Promise.resolve(promise);\n  const settled: Promise<Result<T, E>> = p.then(\n    (value) => okRes<T, E>(value),\n    (cause) => qualifyToResult<T, E>(cause, triage),\n  );\n  return new AsyncRes<T, E>(settled);\n}\n\n/**\n * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection\n * becomes a `Defect`.\n *\n * @remarks\n * Use this only when a rejection genuinely indicates a bug rather than an\n * anticipated outcome — the error channel is `never`, so there is nothing to\n * triage. (`await`-ing still yields a `Result`; it never throws.) The\n * synchronous counterpart is {@link fromSafeThrowable}.\n *\n * @typeParam T - the resolved value type.\n * @param promise - the promise, or a thunk returning one.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromSafePromise } from \"unthrown\";\n *\n * (await fromSafePromise(Promise.resolve(3))).get(); // => 3\n * // a rejection becomes a Defect (never a modeled Err):\n * await fromSafePromise(Promise.reject(new Error(\"boom\"))); // => Defect(Error(\"boom\"))\n * ```\n */\nexport function fromSafePromise<T>(\n  promise: Promise<T> | (() => Promise<T>),\n): AsyncResult<T, never> {\n  // Promise.resolve() also absorbs a non-thenable passed from untyped code, so\n  // this boundary never throws synchronously — it exists to prevent throws.\n  const p =\n    typeof promise === \"function\" ? Promise.resolve().then(promise) : Promise.resolve(promise);\n  const settled: Promise<Result<T, never>> = p.then(\n    (value) => okRes<T, never>(value),\n    (cause) => defectRes<T, never>(cause),\n  );\n  return new AsyncRes<T, never>(settled);\n}\n\nfunction qualifyToResult<T, E>(\n  cause: unknown,\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect,\n): Result<T, E> {\n  try {\n    const q = qualify(cause, defect);\n    if (isDefectMarker(q)) return defectRes<T, E>(q.cause);\n    if (isThenable(q)) {\n      // An async `qualify` slipped past the compile-time NotThenable ban\n      // (untyped/JS caller). Its Promise must never become the modeled error —\n      // the boundary would be un-triaged — so surface a Defect instead. Also\n      // adopt-and-silence the orphaned thenable: if the async qualify later\n      // rejects, that rejection must not float as an unhandled rejection.\n      void Promise.resolve(q).then(undefined, () => undefined);\n      return defectRes<T, E>(\n        new TypeError(\n          \"unthrown: qualify must be synchronous — it returned a thenable; triage the cause without awaiting\",\n        ),\n      );\n    }\n    return 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 * Runtime thenable probe for the belt-and-braces guard above. Called inside the\n * caller's `try`, so even a hostile `.then` getter lands on the Defect path.\n *\n * @internal\n */\nfunction isThenable(x: unknown): boolean {\n  return (\n    (typeof x === \"object\" || typeof x === \"function\") &&\n    x !== null &&\n    typeof (x as { then?: unknown }).then === \"function\"\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 */\n/** The Defect minted for an out-of-contract non-`Result` element in an aggregate. */\nfunction nonResultDefect(): Result<unknown, unknown> {\n  return defectRes(new TypeError(\"unthrown: aggregate received a non-Result element\"));\n}\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 (!isResult(r)) {\n      // Out-of-contract element (a hole/undefined/non-Result, reachable only via\n      // untyped or cast input). Surface it as a Defect — an unexpected failure —\n      // rather than throwing on `.tag` (sync) or rejecting the internal promise\n      // (async). A Defect dominates, so break.\n      firstDefect ??= nonResultDefect();\n      break;\n    }\n    if (r.tag === \"Defect\") {\n      firstDefect ??= r;\n      break; // any Defect dominates — nothing later can change the outcome\n    } else if (r.tag === \"Err\") firstErr ??= r;\n    else values.push(r.value);\n  }\n  return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/**\n * Fold a record of settled `Result`s with the same rules, else `Ok` of the\n * record of values. Keys are written with `Object.defineProperty` so a\n * caller-supplied `\"__proto__\"` key cannot pollute the prototype.\n *\n * @internal\n */\nfunction foldRecord(results: ResultRecord): Result<unknown, unknown> {\n  let firstErr: Result<unknown, unknown> | undefined;\n  let firstDefect: Result<unknown, unknown> | undefined;\n  const values: Record<string, unknown> = {};\n  for (const [key, r] of Object.entries(results)) {\n    if (!isResult(r)) {\n      firstDefect ??= nonResultDefect(); // out-of-contract element → Defect (see foldArray)\n      break;\n    }\n    if (r.tag === \"Defect\") {\n      firstDefect ??= r;\n      break; // any Defect dominates — nothing later can change the outcome\n    } else if (r.tag === \"Err\") firstErr ??= r;\n    else\n      Object.defineProperty(values, key, {\n        value: r.value,\n        enumerable: true,\n        writable: true,\n        configurable: true,\n      });\n  }\n  return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/**\n * Collect a tuple/array of {@link Result}s into a single `Result` of all their\n * success values.\n *\n * @remarks\n * Short-circuits on the **first** `Err` (later entries are not inspected for\n * their error); any `Defect` present **dominates**, winning even over an earlier\n * `Err`. A **fixed tuple** keeps its positional types — `all([Ok(1), Ok(\"a\")])`\n * is `Result<[number, string], …>` — while a **dynamic array** `Result<T, E>[]`\n * collapses to `Result<T[], E>` with no cast. For a **record** keyed by name,\n * use {@link allFromDict}.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { all, Ok, Err } from \"unthrown\";\n *\n * all([Ok(1), Ok(\"a\"), Ok(true)]).get(); // => [1, \"a\", true] (typed [number, string, boolean])\n * all([Ok(1), Err(\"e\"), Ok(3)]); // => Err(\"e\") (short-circuits on the first Err)\n * ```\n */\nexport function all<Rs extends readonly Result<unknown, unknown>[]>(\n  results: readonly [...Rs],\n): Result<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>> {\n  return foldArray(results) as unknown as Result<\n    AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>,\n    ErrOf<Rs[number]>\n  >;\n}\n\n/**\n * Collect a **record** of {@link Result}s into a single `Result` of a record of\n * their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is\n * `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for\n * parallel work you'd rather not tuple.\n *\n * @remarks\n * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`\n * dominates. This is **not** error accumulation.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allFromDict, Ok, Err } from \"unthrown\";\n *\n * allFromDict({ id: Ok(1), name: Ok(\"ada\") }).get(); // => { id: 1, name: \"ada\" }\n * allFromDict({ id: Ok(1), name: Err(\"missing\") }); // => Err(\"missing\")\n * ```\n */\nexport function allFromDict<R extends ResultRecord>(\n  results: R,\n): Result<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>> {\n  return foldRecord(results) as unknown as Result<\n    { [K in keyof R]: OkOf<R[K]> },\n    ErrOf<R[keyof R]>\n  >;\n}\n\n/**\n * The asynchronous counterpart of {@link all}: combine a tuple/array of\n * {@link AsyncResult}s into one `AsyncResult` of all their success values.\n *\n * @remarks\n * The inputs are resolved **concurrently** (order preserved); the resolved\n * `Result`s are then folded with the same rules as {@link all} — first `Err`\n * short-circuits, any `Defect` dominates. As ever, the returned `AsyncResult`'s\n * internal promise never rejects. For a **record**, use {@link allFromDictAsync}.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allAsync, fromSafePromise } from \"unthrown\";\n *\n * const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);\n * (await both).get(); // => [1, 2]\n * ```\n */\nexport function allAsync<Rs extends readonly AsyncResult<unknown, unknown>[]>(\n  results: readonly [...Rs],\n): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>> {\n  // Each library AsyncResult is a never-rejecting thenable, so Promise.all\n  // adopts them; `foldArray` then applies the all() rules. Adopt every input\n  // defensively — a cast/untyped rejecting thenable becomes a `Defect` rather\n  // than rejecting the internal promise (the \"internal promise never rejects\"\n  // invariant holds even for out-of-contract input).\n  const settled = Promise.all(\n    results.map((r) =>\n      Promise.resolve(r).then(\n        (x) => x,\n        (cause) => defectRes(cause),\n      ),\n    ),\n  ).then((resolved) => foldArray(resolved as readonly Result<unknown, unknown>[]));\n  return new AsyncRes(settled) as unknown as AsyncResult<\n    AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>,\n    AsyncErrOf<Rs[number]>\n  >;\n}\n\n/**\n * The asynchronous counterpart of {@link allFromDict}: combine a record of\n * {@link AsyncResult}s into one `AsyncResult` of a record of their values.\n *\n * @remarks\n * Resolved concurrently (order preserved), folded with the {@link all} rules,\n * and the internal promise never rejects.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allFromDictAsync, fromSafePromise } from \"unthrown\";\n *\n * const both = allFromDictAsync({\n *   a: fromSafePromise(Promise.resolve(1)),\n *   b: fromSafePromise(Promise.resolve(\"x\")),\n * });\n * (await both).get(); // => { a: 1, b: \"x\" }\n * ```\n */\nexport function allFromDictAsync<R extends AsyncResultRecord>(\n  results: R,\n): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>> {\n  const entries = Object.entries(results);\n  const settled = Promise.all(\n    // Adopt each input defensively (see `allAsync`): a rejecting thenable\n    // becomes a `Defect`, so the internal promise never rejects.\n    entries.map(([, ar]) =>\n      Promise.resolve(ar).then(\n        (x) => x,\n        (cause) => defectRes(cause),\n      ),\n    ),\n  ).then((resolved) => {\n    // Null-proto accumulator: pairing resolved values back to keys can't pollute.\n    const byKey: ResultRecord = Object.create(null) as ResultRecord;\n    entries.forEach(([key], i) => {\n      byKey[key] = resolved[i]!;\n    });\n    return foldRecord(byKey);\n  });\n  return new AsyncRes(settled) as unknown as AsyncResult<\n    { [K in keyof R]: AsyncOkOf<R[K]> },\n    AsyncErrOf<R[keyof R]>\n  >;\n}\n","// Result facade — a discoverable namespace alias for the standalone entry\n// points. The free functions remain the primary, tree-shakeable API; this\n// object is a separate export, so `import { Ok }` never pulls it in. The value\n// `Result` and the type `Result<T, E>` (types.ts) share a name — the\n// companion-object pattern. See CLAUDE.md → \"Internal design\".\n\nimport { Err, ErrAsync, isDefect, isErr, isOk, Ok, OkAsync } from \"./constructors.js\";\nimport { isResult } from \"./core.js\";\nimport { Do, DoAsync } from \"./do.js\";\nimport {\n  all,\n  allAsync,\n  allFromDict,\n  allFromDictAsync,\n  fromNullable,\n  fromPromise,\n  fromSafePromise,\n  fromSafeThrowable,\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.fromSafeThrowable}, {@link Result.all},\n * {@link Result.allFromDict}, {@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 * The **async** entry points live on the sibling {@link AsyncResult} companion\n * (`AsyncResult.fromPromise`, `AsyncResult.all`, …), grouped by what they\n * return — a static lives in exactly one namespace.\n *\n * @category Facade\n *\n * @example\n * ```ts\n * import { Result } from \"unthrown\";\n * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).get(); // => 2\n * ```\n */\nexport const Result = {\n  Ok,\n  Err,\n  Do,\n  fromNullable,\n  fromThrowable,\n  fromSafeThrowable,\n  all,\n  allFromDict,\n  isOk,\n  isErr,\n  isDefect,\n  isResult,\n} as const;\n\n/**\n * `Result<T, E>` — the core discriminated union. Shares its name with the\n * {@link Result | companion object} above (the value and type are one name); this\n * is the type half.\n *\n * @remarks\n * A `Result` is a discriminated union, so TypeDoc can't list its methods on this\n * alias. Its fluent combinators (`map`, `flatMap`, `match`, `get`, …) are\n * documented one per entry on {@link ResultMethods} — the shared method surface\n * every variant carries. For \"which one do I reach for?\", see the\n * [Choosing a combinator](/reference/combinators) guide.\n *\n * @category Facade\n */\n// Re-alias the Result type into this module so a single `export { Result }`\n// (from index.ts) carries BOTH the companion object above and the type — value\n// and type sharing one name, declaration-merged in one place.\nexport type Result<T, E> = ResultType<T, E>;\n\n/**\n * Companion object grouping the **`AsyncResult`-producing** entry points under\n * the matching namespace: {@link AsyncResult.Ok}, {@link AsyncResult.Err},\n * {@link AsyncResult.Do}, {@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 the pre-lifted constructors, `fromPromise`/`fromSafePromise`,\n * and the async aggregates sit here rather than on {@link Result}; the namespace\n * already conveys \"async\", so the members drop the `Async` suffix their free\n * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is\n * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;\n * `AsyncResult.allFromDict` is\n * `allFromDictAsync`). Like {@link Result}, the free functions remain the\n * primary, tree-shakeable API; the value `AsyncResult` and the type\n * {@link AsyncResult} share one name.\n *\n * @category Facade\n *\n * @example\n * ```ts\n * import { AsyncResult } from \"unthrown\";\n * const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));\n * user.get(); // => the fetched user (on success)\n * ```\n */\nexport const AsyncResult = {\n  Ok: OkAsync,\n  Err: ErrAsync,\n  Do: DoAsync,\n  fromPromise,\n  fromSafePromise,\n  all: allAsync,\n  allFromDict: allFromDictAsync,\n} as const;\n\n/**\n * `AsyncResult<T, E>` — the async counterpart of {@link Result}. Shares its name\n * with the {@link AsyncResult | companion object} above (value and type are one\n * name); this is the type half.\n *\n * @remarks\n * `AsyncResult` carries the async fluent surface; its combinators (`map`,\n * `flatMap`, `match`, `get`, …) are documented one per entry — with their\n * async signatures — on {@link AsyncResultMethods}. For \"which one do I reach\n * for?\", see the [Choosing a combinator](/reference/combinators) guide.\n *\n * @category Facade\n */\n// Re-alias the AsyncResult type into this module (same companion-object pattern\n// as Result above) so one `export { AsyncResult }` carries value + type.\nexport type AsyncResult<T, E> = AsyncResultType<T, E>;\n","// The TaggedError convention (à la Effect's `Data.TaggedError`) and the\n// `tag(t)` ts-pattern pattern for matching a tagged error union.\n\ntype Props = Record<string, unknown>;\n\n/**\n * The instance shape produced by a {@link TaggedError} class: an `Error` plus a\n * `_tag` discriminant and the (readonly) payload fields.\n *\n * @typeParam Tag - the string literal discriminant.\n * @typeParam A - the payload object type.\n *\n * @category Types\n */\nexport type TaggedErrorInstance<Tag extends string, A extends Props> = Error &\n  Readonly<Omit<A, \"name\" | \"message\" | \"stack\">> & { readonly _tag: Tag };\n\n/**\n * The class constructor returned by {@link TaggedError}. Generic in its payload:\n * apply it with an instantiation expression at the `extends` site.\n *\n * @remarks\n * When the payload is empty, the constructor takes **no** arguments (the\n * `keyof A extends never ? void : A` trick); otherwise it takes the payload. The\n * `name`, `message`, and `stack` keys are all **rejected** (`?: never`) because\n * all three are reserved: `name` is the display label, `message` is the human\n * string owned by `Error`, and `stack` is `Error`'s trace. Set the message the\n * standard way — `override message = \"…\"` (or a constructor override) on the\n * subclass — never as a free-form per-call payload field. The reservations are\n * enforced at the call site, mirroring how {@link TaggedErrorInstance} excludes\n * all three. (`cause` is deliberately **not** reserved: `Error.cause` is\n * `unknown`, so a typed payload `cause` is a legitimate structured field.)\n *\n * @typeParam Tag - the string literal discriminant.\n *\n * @category Types\n */\nexport type TaggedErrorConstructor<Tag extends string> = {\n  new <A extends Props = {}>(\n    args: keyof A extends never\n      ? void\n      : A & { readonly name?: never; readonly message?: never; readonly stack?: never },\n  ): TaggedErrorInstance<Tag, A>;\n};\n\n/**\n * Build a base class for a tagged error — a class extending `Error` with a\n * `_tag` string discriminant, in the style of Effect's `Data.TaggedError`.\n *\n * @remarks\n * Extend the returned class to declare a concrete error. Supply the payload with\n * an instantiation expression; omit it for a payload-less error. The `message`\n * is **not** a payload field — it is the human string owned by `Error`, not\n * structured data, so it is reserved. Define it once per subclass the standard\n * way, `override message = \"…\"` (it may interpolate the payload via `this`,\n * which the base populates before the subclass field initialiser runs); a\n * payload `message` is rejected at compile time, so contextual detail lives in\n * typed fields, never baked into per-call prose. The `_tag` always reflects\n * `tag` and cannot be overridden by the payload. `name` is likewise reserved —\n * it is the display label (set it with `options.name`); a payload `name` is\n * rejected at compile time (and excluded from the instance type), so it can't\n * shadow `Error.name`. `stack` is reserved the same way — it is `Error`'s\n * trace, and even an untyped payload `stack` cannot clobber the real one.\n * `cause` is deliberately **not** reserved: `Error.cause` is typed `unknown`,\n * so a payload `cause` (e.g. a wrapped driver error) is a legitimate,\n * *narrowing* structured field.\n *\n * `_tag` is the discriminant matched by {@link tag} in the error combinators\n * (`result.mapErrCases((matcher) => matcher.with(tag(\"NotFound\"), …))`) and in\n * `match`; `Error.name` is the human-facing label in stack traces and logs. By\n * default they coincide, but\n * they can be **decoupled** with `options.name` — so a tag can be namespaced for\n * collision-safety (`\"@my-lib/RetryableError\"`) without that slash-prefixed\n * string leaking into `Error.name`:\n *\n * ```ts\n * class RetryableError extends TaggedError(\"@my-lib/RetryableError\", {\n *   name: \"RetryableError\",\n * }) {\n *   override message = \"operation failed; safe to retry\";\n * }\n *\n * const e = new RetryableError();\n * e._tag;    // \"@my-lib/RetryableError\" — namespaced discriminant\n * e.name;    // \"RetryableError\"          — clean display name\n * e.message; // \"operation failed; safe to retry\" — the standard Error.message\n * ```\n *\n * @typeParam Tag - the string literal discriminant.\n * @param tag - the discriminant value; also the default error `name`.\n * @param options - optional overrides. `options.name` sets `Error.name`\n * independently of `tag` (defaults to `tag`).\n *\n * @category Tagged errors\n *\n * @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class HttpError extends TaggedError(\"HttpError\")<{ status: number }> {}\n *\n * new NotFound()._tag; // => \"NotFound\"\n * new HttpError({ status: 500 }).status; // => 500\n * ```\n */\nexport function TaggedError<Tag extends string>(\n  tag: Tag,\n  options?: { readonly name?: string },\n): TaggedErrorConstructor<Tag> {\n  const displayName = options?.name ?? tag;\n  class TaggedErrorBase extends Error {\n    readonly _tag!: Tag;\n\n    constructor(props?: Props) {\n      super();\n      if (props) {\n        // `stack` is reserved like `name`/`message`: it is `Error`'s trace, not\n        // payload data. Capture the genuine trace as a string (V8 exposes\n        // `stack` as a lazy accessor whose setter would happily store a payload\n        // value), let the payload land, then re-assert the real trace as a\n        // plain data property — an untyped caller cannot clobber it. (`cause`\n        // is deliberately allowed through: `Error.cause` is `unknown`, so a\n        // typed payload `cause` is a legitimate structured field.)\n        const stack = this.stack;\n        Object.assign(this, props);\n        delete (this as { stack?: unknown }).stack;\n        if (stack !== undefined) {\n          Object.defineProperty(this, \"stack\", {\n            value: stack,\n            writable: true,\n            enumerable: false,\n            configurable: true,\n          });\n        }\n      }\n      // `_tag`, `name`, and `message` are authoritative — an untyped caller\n      // can't set them via the payload. `_tag`/`name` are re-assigned to their\n      // canonical values; `message` is `Error`'s channel (set per subclass via\n      // `override message = …`, whose field initialiser runs after this\n      // constructor returns), so any payload-supplied `message` is dropped here.\n      (this as { _tag: Tag })._tag = tag;\n      this.name = displayName;\n      delete (this as { message?: unknown }).message;\n      Object.setPrototypeOf(this, new.target.prototype);\n    }\n  }\n\n  return TaggedErrorBase as unknown as TaggedErrorConstructor<Tag>;\n}\n\n/**\n * A `ts-pattern` pattern matching any value whose `_tag` equals `value` — a\n * {@link TaggedError}, or any discriminated member. Equivalent to the object\n * pattern `{ _tag: value }`, but reads better inside an error-matching\n * combinator and narrows to the matching variant, payload included.\n *\n * @typeParam Tag - the string literal tag to match.\n * @param value - the `_tag` to match.\n *\n * @category Tagged errors\n *\n * @example\n * ```ts\n * result.mapErrCases((matcher) =>\n *   matcher\n *     .with(tag(\"NotFound\"), () => new NotFoundException())\n *     .with(tag(\"Conflict\"), (e) => new ConflictException(e.key)),\n * );\n * ```\n */\nexport function tag<const Tag extends string>(value: Tag): { _tag: Tag } {\n  return { _tag: value };\n}\n"],"mappings":";;AAEA,MAAM,SAAwB,OAAO,iBAAiB;;;;;;;;;;;;AAgCtD,SAAgB,OAAO,OAAwB;CAG7C,OAAO,OAAO,OAAO;GAAG,SAAS;EAAM;CAAM,CAAC;AAChD;;;;;;;;AASA,SAAgB,eAAe,GAAyB;CACtD,OACE,OAAO,MAAM,YAAY,MAAM,QAAS,EAAmC,YAAY;AAE3F;;;;;;;;;;;;;;;;;;;;;;;;;;ACQA,IAAa,WAAb,cAA2C,MAAM;;;;;CAK/C;CACA,YAAY,OAAU;EACpB,MAAM,sEAAsE,EAAE,OAAO,MAAM,CAAC;EAC5F,KAAK,OAAO;EACZ,KAAK,QAAQ;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CAClD;AACF;;;;;;;;AASA,IAAM,MAAN,MAAgB;CACd,IAA2B,GAAmD;EAC5E,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,MAAM,IAAI,EAAE,KAAK,KAAK;GACtB,OAAO,SAAS,CAAC,IAAI,IAAI,wBAAwB;EACnD,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,IAA2B,GAAmD;EAC5E,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;GACtB,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,wBAAwB;GAEjD,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,CAAC,SAAS,CAAC,GAAG,OAAO,wBAAwB;GACjD,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,UAA6C;EAC3C,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAE9C,OAAO,MAAe,KAAA,CAAS;CACjC;CAIA,OAEE,WACA,QACmB;EACnB,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GAGF,OAAO,UAAU,KAAK,KAAK,IAAI,OAAO,OAAO,OAAO,KAAK,KAAK,CAAC;EACjE,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,YAEE,GAC2B;EAC3B,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,MAAM,MAAM,SAAS,GAAG,KAAK,KAAK;GAClC,IAAI,eAAe,GAAG,GAAG,OAAO,UAAU,IAAI,KAAK;GACnD,OAAO,OAAO,GAAqB;EACrC,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,gBAEE,GACmD;EACnD,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,MAAM,MAAM,SAAS,GAAG,KAAK,KAAK;GAClC,IAAI,eAAe,GAAG,GAAG,OAAO,UAAU,IAAI,KAAK;GACnD,IAAI,CAAC,SAAS,GAAG,GAAG,OAAO,wBAAwB;GACnD,OAAO;EACT,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,gBAEE,GACmC;EACnC,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,MAAM,MAAM,SAAS,GAAG,KAAK,KAAK;GAClC,IAAI,eAAe,GAAG,GAAG,OAAO,UAAU,IAAI,KAAK;GACnD,OAAO,MAAM,GAAqB;EACpC,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,YAEE,GACc;EACd,IAAI,KAAK,QAAQ,OAAO,OAAO;EAC/B,IAAI;GACF,SAAS,GAAG,KAAK,KAAK;GACtB,OAAO;EACT,SAAS,OAAO;GACd,OAAO,sBAAsB,OAAO,KAAK,KAAK;EAChD;CACF;CAEA,gBAEE,GACmC;EACnC,IAAI,KAAK,QAAQ,OAAO,OAAO;EAC/B,IAAI;GACF,MAAM,IAAI,SAAS,GAAG,KAAK,KAAK;GAChC,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,wBAAwB;GAEjD,OAAO,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;EAC9C,SAAS,OAAO;GACd,OAAO,sBAAsB,OAAO,KAAK,KAAK;EAChD;CACF;CAEA,cAEE,GACuB;EACvB,IAAI,KAAK,QAAQ,UAAU,OAAO;EAClC,IAAI;GACF,MAAM,IAAI,EAAE,KAAK,KAAK;GACtB,OAAO,SAAS,CAAC,IAAI,IAAI,wBAAwB;EACnD,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,UAAiC,GAAyD;EACxF,IAAI,KAAK,QAAQ,UAAU,OAAO;EAClC,IAAI;GACF,EAAE,KAAK,KAAK;GACZ,OAAO;EACT,SAAS,OAAO;GACd,OAAO,sBAAsB,OAAO,KAAK,KAAK;EAChD;CACF;CAEA,WAEE,GACc;EACd,IAAI,KAAK,QAAQ,MAAM,OAAO;EAC9B,IAAI;GACF,EAAE,IAAI;GACN,OAAO;EACT,SAAS,OAAO;GACd,OAAO,sBAAsB,OAAO,KAAK,QAAQ,QAAQ,KAAK,QAAQ,KAAK,KAAK;EAClF;CACF;CAEA,MAEE,OAK6B;EAC7B,QAAQ,KAAK,KAAb;GACE,KAAK,MACH,OAAO,MAAM,GAAG,KAAK,KAAK;GAC5B,KAAK,OAMH,OAAO,MAAM,IAAIA,QAAM,KAAK,KAAK,CAAkB,CAAC,CAAC,IAAI;GAC3D,KAAK,UACH,OAAO,MAAM,OAAO,KAAK,KAAK;EAClC;CACF;CAEA,MAA2B;EACzB,QAAQ,KAAK,KAAb;GACE,KAAK,MACH,OAAO,KAAK;GACd,KAAK,OACH,MAAM,IAAI,SAAS,KAAK,KAAK;GAC/B,KAAK,UACH,MAAM,KAAK;EACf;CACF;CAEA,SAA8B;EAC5B,QAAQ,KAAK,KAAb;GACE,KAAK,OACH,OAAO,KAAK;GACd,KAAK,MACH,MAAM,IAAI,SAAS,KAAK,KAAK;GAC/B,KAAK,UACH,MAAM,KAAK;EACf;CACF;CAEA,MAA6B,UAAoB;EAC/C,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,OAAO;CACT;CAEA,UAAiC,GAA2B;EAC1D,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,aAAkC;EAChC,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,MAAM,KAAK;CACb;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;;;;;;;;;;AAWA,MAAM,eAAe,OAAO,IAAI,iBAAiB;AAEjD,MAAM,eAAe,IAAI;AACzB,OAAO,eAAe,cAAc,cAAc,EAAE,OAAO,KAAK,CAAC;AAGjE,OAAO,OAAO,YAAY;;;;;;AAO1B,SAAgB,MAAY,OAAwB;CAGlD,OAAO,OAAO,OACZ,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EACzC,KAAK;EACL;CACF,CAAC,CACH;AACF;;;;;;AAOA,SAAgB,OAAa,OAAwB;CACnD,OAAO,OAAO,OACZ,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EACzC,KAAK;EACL;CACF,CAAC,CACH;AACF;;;;;;AAOA,SAAgB,UAAgB,OAA8B;CAC5D,OAAO,OAAO,OACZ,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EACzC,KAAK;EACL;CACF,CAAC,CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,SAAS,GAA2C;CAClE,IAAI,aAAa,KAAK,OAAO;CAQ7B,IAAI;EACF,QACG,OAAO,MAAM,YAAY,OAAO,MAAM,eACvC,MAAM,QACN,QAAQ,IAAI,GAAG,YAAY,MAAM;CAErC,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;AAYA,SAAS,YAAkB,MAA8C;CACvE,OAAO;AACT;;;;;;;;;;;AAYA,SAAS,0BAA8C;CACrD,OAAO,0BAAU,IAAI,UAAU,6DAA6D,CAAC;AAC/F;;;;;;;;;;;AAYA,SAAS,SACP,GACA,OACS;CACT,OAAO,EAAEA,QAAM,KAAK,GAAoB,MAAM,CAAC,CAAC,IAAI;AACtD;;;;;;;;;;AAWA,SAAS,sBAA4B,QAAiB,UAAiC;CACrF,OAAO,UACL,IAAI,eACF,CAAC,QAAQ,QAAQ,GACjB,gHACF,CACF;AACF;;;;;;;;;;;;;;;;;;;AAoBA,SAAS,QAAQ,OAAwB;CACvC,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACpE,MAAM,IAAI,UAAU,gEAAgE;CAEtF,OAAO;AACT;;;;;;;;AASA,IAAa,WAAb,MAAa,SAA4C;CAGvD;CAEA,YAAY,SAAgC;EAC1C,KAAKC,WAAW;CAClB;CAGA,KACE,aACA,YACsB;EACtB,OAAO,KAAKA,SAAS,KAAK,aAAa,UAAU;CACnD;CAEA,IAAO,GAAwD;EAC7D,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,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,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,OAAO,SAAS,KAAK,IAAI,QAAQ,wBAAmC;GACtE,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,IAAO,GAAwD;EAC7D,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,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,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,wBAAwB;IAErD,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,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,wBAAwB;IACrD,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,IACE,MACA,GACgC;EAChC,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,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,KAAKA,SAAS,MAAM,MAAO,EAAE,QAAQ,OAAO,MAAY,KAAK,IAAI,YAAY,CAAC,CAAE,CAClF;CACF;CAEA,UAAgC;EAC9B,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAO,EAAE,QAAQ,OAAO,MAAe,KAAA,CAAS,IAAI,YAAY,CAAC,CAAE,CACzF;CACF;CAMA,OACE,WACA,QAC2B;EAC3B,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IAEF,OAAQ,UAAU,EAAE,KAAK,IAAI,IAAI,OAAO,OAAO,EAAE,KAAK,CAAC;GACzD,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CASA,YACE,GACuB;EACvB,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,MAAM,SAAS,GAAG,EAAE,KAAK;IAC/B,IAAI,eAAe,GAAG,GAAG,OAAO,UAAoB,IAAI,KAAK;IAC7D,OAAO,OAAiB,GAAY;GACtC,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,gBACE,GAIuB;EACvB,OAAO,IAAI,SACT,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,MAAM,SAAS,GAAG,EAAE,KAAK;IAC/B,IAAI,eAAe,GAAG,GAAG,OAAO,UAAoB,IAAI,KAAK;IAC7D,MAAM,QAAQ,MAAO;IACrB,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,wBAAkC;IAC/D,OAAO;GACT,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,gBACE,GACuB;EACvB,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,MAAM,SAAS,GAAG,EAAE,KAAK;IAC/B,IAAI,eAAe,GAAG,GAAG,OAAO,UAAoB,IAAI,KAAK;IAC7D,OAAO,MAAgB,GAAQ;GACjC,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,YACE,GACmB;EACnB,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,OAAO,OAAO;GAC5B,IAAI;IACF,SAAS,GAAG,EAAE,KAAK;IACnB,OAAO;GACT,SAAS,OAAO;IACd,OAAO,sBAA4B,OAAO,EAAE,KAAK;GACnD;EACF,CAAC,CACH;CACF;CAEA,gBACE,GAImB;EACnB,OAAO,IAAI,SACT,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,QAAQ,MAAO,SAAS,GAAG,EAAE,KAAK;IAGxC,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,wBAAwB;IAErD,OAAO,MAAM,QAAQ,OAAO,YAAY,CAAC,IAAI,YAAY,KAAK;GAChE,SAAS,OAAO;IACd,OAAO,sBAAsB,OAAO,EAAE,KAAK;GAC7C;EACF,CAAC,CACH;CACF;CAEA,cACE,GAC4B;EAC5B,OAAO,IAAI,SACT,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,UAAU,OAAO;GAC/B,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,OAAO,SAAS,KAAK,IAAI,QAAQ,wBAAuC;GAC1E,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,UAAa,GAA8D;EACzE,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,UAAU,OAAO;GAC/B,IAAI;IACF,EAAE,EAAE,KAAK;IACT,OAAO;GACT,SAAS,OAAO;IACd,OAAO,sBAA4B,OAAO,EAAE,KAAK;GACnD;EACF,CAAC,CACH;CACF;CAEA,WAAc,GAA0E;EACtF,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,MAAM,OAAO;GAC3B,IAAI;IACF,EAAE,CAAC;IACH,OAAO;GACT,SAAS,OAAO;IACd,OAAO,sBAA4B,OAAO,EAAE,QAAQ,QAAQ,EAAE,QAAQ,EAAE,KAAK;GAC/E;EACF,CAAC,CACH;CACF;CAEA,MAAwD,OAIf;EACvC,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,MAAM,KAAK,CAAC;CACjD;CAEA,MAAkB;EAChB,OAAO,KAAKA,SAAS,MAAM,MAAO,EAAuB,IAAI,CAAC;CAChE;CACA,SAAqB;EACnB,OAAO,KAAKA,SAAS,MAAM,MAAO,EAAuB,OAAO,CAAC;CACnE;CACA,MAAS,UAA6B;EACpC,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,MAAM,QAAQ,CAAC;CACpD;CACA,UAAa,GAAoC;EAC/C,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,UAAU,CAAC,CAAC;CACjD;CACA,YAA+B;EAC7B,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,UAAU,CAAC;CAChD;CACA,iBAAyC;EACvC,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,eAAe,CAAC;CACrD;CACA,aAAyB;EAGvB,OAAO,KAAKA,SAAS,MAAM,MAAO,EAAyB,WAAW,CAAC;CACzE;AACF;AAKA,OAAO,OAAO,SAAS,SAAS;;;ACt3BhC,SAAgB,GAAM,OAA6B;CAIjD,OAAO,MAAM,KAAU;AACzB;;;;;;;;;;;;;;;;;AAkBA,SAAgB,IAAO,OAA4B;CACjD,OAAO,OAAO,KAAK;AACrB;AA4CA,SAAgB,QAAW,OAAkC;CAG3D,OAAO,GAAG,KAAU,CAAC,CAAC,QAAQ;AAChC;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,SAAY,OAAiC;CAC3D,OAAO,IAAI,KAAK,CAAC,CAAC,QAAQ;AAC5B;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,KAAW,GAAoC;CAC7D,OAAO,EAAE,QAAQ;AACnB;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,MAAY,GAAqC;CAC/D,OAAO,EAAE,QAAQ;AACnB;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,SAAe,GAAwC;CACrE,OAAO,EAAE,QAAQ;AACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9JA,SAAgB,KAAwB;CACtC,OAAO,GAAG,CAAC,CAAC;AACd;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,UAAkC;CAChD,OAAO,GAAG,CAAC,CAAC,QAAQ;AACtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA,SAAgB,aACd,OACA,UAC2B;CAC3B,OAAO,UAAU,QAAQ,UAAU,KAAA,IAAY,IAAI,SAAS,CAAC,IAAI,GAAG,KAAuB;AAC7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,kBACd,IACkC;CAClC,QAAQ,GAAG,SAA8B;EACvC,IAAI;GACF,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC;EACvB,SAAS,OAAO;GACd,OAAO,UAAoB,KAAK;EAClC;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,YACd,SACA,SAcA,GAAG,QAGiC;CAEpC,MAAM,SAAS;CASf,OAAO,IAAI,UALT,OAAO,YAAY,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAQ,QAAQ,OAAO,EAAA,CAClD,MACtC,UAAU,MAAY,KAAK,IAC3B,UAAU,gBAAsB,OAAO,MAAM,CAEhB,CAAC;AACnC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,gBACd,SACuB;CASvB,OAAO,IAAI,UALT,OAAO,YAAY,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAQ,QAAQ,OAAO,EAAA,CAC9C,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,IAAI,eAAe,CAAC,GAAG,OAAO,UAAgB,EAAE,KAAK;EACrD,IAAI,WAAW,CAAC,GAAG;GAMjB,QAAa,QAAQ,CAAC,CAAC,CAAC,KAAK,KAAA,SAAiB,KAAA,CAAS;GACvD,OAAO,0BACL,IAAI,UACF,mGACF,CACF;EACF;EACA,OAAO,OAAa,CAAC;CACvB,SAAS,MAAM;EAEb,OAAO,UAAgB,IAAI;CAC7B;AACF;;;;;;;AAQA,SAAS,WAAW,GAAqB;CACvC,QACG,OAAO,MAAM,YAAY,OAAO,MAAM,eACvC,MAAM,QACN,OAAQ,EAAyB,SAAS;AAE9C;;;;;;;;AAoCA,SAAS,kBAA4C;CACnD,OAAO,0BAAU,IAAI,UAAU,mDAAmD,CAAC;AACrF;AAEA,SAAS,UAAU,SAAwE;CACzF,IAAI;CACJ,IAAI;CACJ,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,KAAK,SAAS;EACvB,IAAI,CAAC,SAAS,CAAC,GAAG;GAKhB,gBAAgB,gBAAgB;GAChC;EACF;EACA,IAAI,EAAE,QAAQ,UAAU;GACtB,gBAAgB;GAChB;EACF,OAAO,IAAI,EAAE,QAAQ,OAAO,aAAa;OACpC,OAAO,KAAK,EAAE,KAAK;CAC1B;CACA,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,GAAG;EAC9C,IAAI,CAAC,SAAS,CAAC,GAAG;GAChB,gBAAgB,gBAAgB;GAChC;EACF;EACA,IAAI,EAAE,QAAQ,UAAU;GACtB,gBAAgB;GAChB;EACF,OAAO,IAAI,EAAE,QAAQ,OAAO,aAAa;OAEvC,OAAO,eAAe,QAAQ,KAAK;GACjC,OAAO,EAAE;GACT,YAAY;GACZ,UAAU;GACV,cAAc;EAChB,CAAC;CACL;CACA,OAAO,eAAe,YAAY,GAAG,MAAM;AAC7C;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,IACd,SACwE;CACxE,OAAO,UAAU,OAAO;AAI1B;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,YACd,SAC2D;CAC3D,OAAO,WAAW,OAAO;AAI3B;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,SACd,SACuF;CAcvF,OAAO,IAAI,SARK,QAAQ,IACtB,QAAQ,KAAK,MACX,QAAQ,QAAQ,CAAC,CAAC,CAAC,MAChB,MAAM,IACN,UAAU,UAAU,KAAK,CAC5B,CACF,CACF,CAAC,CAAC,MAAM,aAAa,UAAU,QAA+C,CACpD,CAAC;AAI7B;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,iBACd,SAC0E;CAC1E,MAAM,UAAU,OAAO,QAAQ,OAAO;CAkBtC,OAAO,IAAI,SAjBK,QAAQ,IAGtB,QAAQ,KAAK,GAAG,QACd,QAAQ,QAAQ,EAAE,CAAC,CAAC,MACjB,MAAM,IACN,UAAU,UAAU,KAAK,CAC5B,CACF,CACF,CAAC,CAAC,MAAM,aAAa;EAEnB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClfA,MAAa,SAAS;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAa,cAAc;CACzB,IAAI;CACJ,KAAK;CACL,IAAI;CACJ;CACA;CACA,KAAK;CACL,aAAa;AACf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACdA,SAAgB,YACd,KACA,SAC6B;CAC7B,MAAM,cAAc,SAAS,QAAQ;CACrC,MAAM,wBAAwB,MAAM;EAClC;EAEA,YAAY,OAAe;GACzB,MAAM;GACN,IAAI,OAAO;IAQT,MAAM,QAAQ,KAAK;IACnB,OAAO,OAAO,MAAM,KAAK;IACzB,OAAQ,KAA6B;IACrC,IAAI,UAAU,KAAA,GACZ,OAAO,eAAe,MAAM,SAAS;KACnC,OAAO;KACP,UAAU;KACV,YAAY;KACZ,cAAc;IAChB,CAAC;GAEL;GAMA,KAAwB,OAAO;GAC/B,KAAK,OAAO;GACZ,OAAQ,KAA+B;GACvC,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAClD;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,IAA8B,OAA2B;CACvE,OAAO,EAAE,MAAM,MAAM;AACvB"}
+{"version":3,"file":"index.mjs","names":["match","#promise"],"sources":["../src/defect.ts","../src/core.ts","../src/constructors.ts","../src/do.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"sourcesContent":["// 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  // Frozen like Result instances: the marker is an opaque triage token, and a\n  // mutated one must not be able to smuggle a different cause past a boundary.\n  return Object.freeze({ [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","// 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 { match } from \"ts-pattern\";\n\nimport { type Defect, defect, isDefectMarker } from \"./defect.js\";\nimport type {\n  AsyncResult,\n  Bound,\n  DefectView,\n  ErrMatcher,\n  ErrOf,\n  ErrView,\n  ExhaustiveMatch,\n  FailureView,\n  MatchErrOut,\n  MatchOut,\n  NotThenable,\n  OkOf,\n  OkView,\n  Result,\n} from \"./types.js\";\n\n/**\n * Thrown by a {@link Result}'s `get` / `getErr` when the assertion is\n * wrong on a *modeled* result — `get()` on an `Err`, or `getErr()` on an\n * `Ok`.\n *\n * @remarks\n * The offending value is exposed two ways: the typed {@link GetError.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 a `GetError`: its original cause is\n * re-thrown (with its original stack) instead.\n *\n * `get()` and `getErr()` are type-gated (`this: Result<T, never>` /\n * `Result<never, E>`), so the wrong-variant branch that throws this is\n * unreachable through well-typed code — it remains only as a defensive guard\n * against unsound runtime misuse (e.g. an `as` cast past the gate).\n *\n * @typeParam E - the type of the {@link GetError.error} it carries.\n *\n * @category Errors\n */\nexport class GetError<E = unknown> extends Error {\n  /**\n   * The offending value: the `Err` error for `get()`, or the `Ok` value for\n   * `getErr()`.\n   */\n  readonly error: E;\n  constructor(error: E) {\n    super(\"unthrown: get() / getErr() called on a non-matching Result variant\", { cause: error });\n    this.name = \"GetError\";\n    this.error = error;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\n/**\n * Method holder for {@link Result}. Never instantiated with `new` and never\n * exported; the builders below attach its prototype to plain objects. Every\n * method types `this` as the public `Result` union, so it narrows on `tag`.\n *\n * @internal\n */\nclass Res<T, E> {\n  map<U>(this: Result<T, E>, f: (value: T) => U & NotThenable<U>): Result<U, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return okRes(f(this.value));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatMap<U, E2>(this: Result<T, E>, f: (value: T) => Result<U, E2>): Result<U, E | E2> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      const r = f(this.value);\n      return isResult(r) ? r : nonResultCallbackDefect();\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tap<R>(this: Result<T, E>, f: (value: T) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Ok\") return this;\n    try {\n      f(this.value);\n      return this;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatTap<E2>(this: Result<T, E>, f: (value: T) => Result<unknown, E2>): Result<T, E | E2> {\n    if (this.tag !== \"Ok\") return this;\n    try {\n      const r = f(this.value);\n      if (!isResult(r)) return nonResultCallbackDefect();\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 (!isResult(r)) return nonResultCallbackDefect();\n      if (r.tag !== \"Ok\") return passThrough(r);\n      // The merged scope can't be spelled at the type level (a computed key\n      // widens to an index signature), so the constructed Ok is cast to `Bound`.\n      return okRes({ ...scopeOf(this.value), [name]: r.value }) as unknown as Result<\n        Bound<T, K, U>,\n        E | E2\n      >;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  let<K extends string, U>(\n    this: Result<T, E>,\n    name: K,\n    f: (scope: T) => U & NotThenable<U>,\n  ): Result<Bound<T, K, U>, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      return okRes({ ...scopeOf(this.value), [name]: f(this.value) }) as unknown as Result<\n        Bound<T, K, U>,\n        E\n      >;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  as<U>(this: Result<T, E>, value: U): Result<U, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    return okRes(value);\n  }\n\n  discard(this: Result<T, E>): Result<void, E> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    // explicit <void, E>: inference from the argument would land on undefined, not void\n    return okRes<void, E>(undefined);\n  }\n\n  // The type-guard/boolean overload pair lives on the public surface\n  // (`ResultMethods`); this single implementation signature covers both.\n  ensure<E2>(\n    this: Result<T, E>,\n    predicate: (value: T) => boolean,\n    onFail: (value: T) => E2,\n  ): Result<T, E | E2> {\n    if (this.tag !== \"Ok\") return passThrough(this);\n    try {\n      // A passing value flows through as the SAME Ok (the passThrough\n      // philosophy: nothing changed, so nothing is reallocated).\n      return predicate(this.value) ? this : errRes(onFail(this.value));\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  mapErrCases<M extends ExhaustiveMatch<unknown>>(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M,\n  ): Result<T, MatchErrOut<M>> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      const out = runMatch(f, this.error);\n      if (isDefectMarker(out)) return defectRes(out.cause);\n      return errRes(out as MatchErrOut<M>);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  flatMapErrCases<M extends ExhaustiveMatch<Result<unknown, unknown> | Defect>>(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M,\n  ): Result<T | OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      const out = runMatch(f, this.error);\n      if (isDefectMarker(out)) return defectRes(out.cause);\n      if (!isResult(out)) return nonResultCallbackDefect();\n      return out as Result<OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>>;\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  recoverErrCases<M extends ExhaustiveMatch<unknown>>(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M,\n  ): Result<T | MatchErrOut<M>, never> {\n    if (this.tag !== \"Err\") return passThrough(this);\n    try {\n      const out = runMatch(f, this.error);\n      if (isDefectMarker(out)) return defectRes(out.cause);\n      return okRes(out as MatchErrOut<M>);\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tapErrCases(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<unknown>,\n  ): Result<T, E> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      runMatch(f, this.error);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.error);\n    }\n  }\n\n  flatTapErrCases<M extends ExhaustiveMatch<Result<unknown, unknown>>>(\n    this: Result<T, E>,\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M,\n  ): Result<T, E | ErrOf<MatchOut<M>>> {\n    if (this.tag !== \"Err\") return this;\n    try {\n      const r = runMatch(f, this.error);\n      if (!isResult(r)) return nonResultCallbackDefect();\n      // Keep the original error on the effect's success; an Err/Defect threads through.\n      return r.tag === \"Ok\" ? this : passThrough(r);\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.error);\n    }\n  }\n\n  recoverDefect<U, E2>(\n    this: Result<T, E>,\n    f: (cause: unknown) => Result<U, E2>,\n  ): Result<T | U, E | E2> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      const r = f(this.cause);\n      return isResult(r) ? r : nonResultCallbackDefect();\n    } catch (cause) {\n      return defectRes(cause);\n    }\n  }\n\n  tapDefect<R>(this: Result<T, E>, f: (cause: unknown) => R & NotThenable<R>): Result<T, E> {\n    if (this.tag !== \"Defect\") return this;\n    try {\n      f(this.cause);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.cause);\n    }\n  }\n\n  tapFailure<R>(\n    this: Result<T, E>,\n    f: (failure: FailureView<E, T>) => R & NotThenable<R>,\n  ): Result<T, E> {\n    if (this.tag === \"Ok\") return this;\n    try {\n      f(this);\n      return this;\n    } catch (cause) {\n      return observerThrowToDefect(cause, this.tag === \"Err\" ? this.error : this.cause);\n    }\n  }\n\n  match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(\n    this: Result<T, E>,\n    cases: {\n      ok: (value: T) => ROk;\n      errCases: (matcher: ErrMatcher<E>) => M;\n      defect: (cause: unknown) => RDefect;\n    },\n  ): ROk | RDefect | MatchOut<M> {\n    switch (this.tag) {\n      case \"Ok\":\n        return cases.ok(this.value);\n      case \"Err\":\n        // The `errCases` handler returns the un-terminated builder; `.run()`\n        // executes `.exhaustive()`. Type-forced exhaustive for well-typed\n        // callers; a value slipping past the types (widened cast, JS caller) with\n        // no matching case throws ts-pattern's `NonExhaustiveError` — `match` is\n        // an edge eliminator, so it surfaces rather than being caught into a Defect.\n        return cases.errCases(match(this.error) as ErrMatcher<E>).run() as MatchOut<M>;\n      case \"Defect\":\n        return cases.defect(this.cause);\n    }\n  }\n\n  get(this: Result<T, E>): T {\n    switch (this.tag) {\n      case \"Ok\":\n        return this.value;\n      case \"Err\":\n        throw new GetError(this.error);\n      case \"Defect\":\n        throw this.cause; // rethrow original cause, original stack\n    }\n  }\n\n  getErr(this: Result<T, E>): E {\n    switch (this.tag) {\n      case \"Err\":\n        return this.error;\n      case \"Ok\":\n        throw new GetError(this.value);\n      case \"Defect\":\n        throw this.cause;\n    }\n  }\n\n  getOr<U>(this: Result<T, E>, fallback: U): T | U {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return fallback;\n  }\n\n  getOrElse<U>(this: Result<T, E>, f: (error: E) => U): T | U {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return f(this.error);\n  }\n\n  getOrNull(this: Result<T, E>): T | null {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return null;\n  }\n\n  getOrUndefined(this: Result<T, E>): T | undefined {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    return undefined;\n  }\n\n  getOrThrow(this: Result<T, E>): T {\n    if (this.tag === \"Ok\") return this.value;\n    if (this.tag === \"Defect\") throw this.cause;\n    throw this.error;\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\n/**\n * Cross-copy brand: `Symbol.for` yields the same symbol in every copy of the\n * library (the dual CJS/ESM build, a duplicated install, another realm), so\n * {@link isResult} can recognise a `Result` built by another copy whose `Res`\n * class fails the `instanceof` check. Defined non-enumerably on the prototype,\n * before it is frozen.\n *\n * @internal\n */\nconst RESULT_BRAND = Symbol.for(\"unthrown.Result\");\n\nconst RESULT_PROTO = Res.prototype;\nObject.defineProperty(RESULT_PROTO, RESULT_BRAND, { value: true });\n// Frozen prototype: the shared combinators cannot be swapped out from under\n// every instance (the instances themselves are frozen by the builders below).\nObject.freeze(RESULT_PROTO);\n\n/**\n * Construct an `Ok` result — a plain object on the {@link Res} prototype.\n *\n * @internal\n */\nexport function okRes<T, E>(value: T): Result<T, E> {\n  // Frozen so the `readonly` surface is real at runtime: a variant cannot be\n  // forged by mutating `tag`/payload after construction.\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Ok\" as const,\n      value,\n    }),\n  ) as OkView<T, E>;\n}\n\n/**\n * Construct an `Err` result.\n *\n * @internal\n */\nexport function errRes<T, E>(error: E): Result<T, E> {\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Err\" as const,\n      error,\n    }),\n  ) as ErrView<E, T>;\n}\n\n/**\n * Construct a `Defect` result.\n *\n * @internal\n */\nexport function defectRes<T, E>(cause: unknown): Result<T, E> {\n  return Object.freeze(\n    Object.assign(Object.create(RESULT_PROTO), {\n      tag: \"Defect\" as const,\n      cause,\n    }),\n  ) as DefectView<T, E>;\n}\n\n/**\n * Type guard: is `x` a {@link Result} (any of `Ok` / `Err` / `Defect`)?\n *\n * @remarks\n * Unlike {@link isOk} / {@link isErr} / {@link isDefect}, which narrow a value\n * already known to be a `Result`, this narrows from `unknown` — useful at an\n * untyped boundary. It checks the value carries the `Result` prototype\n * (`instanceof` first, falling back to the `Symbol.for(\"unthrown.Result\")`\n * brand the prototype carries — so a `Result` built by **another copy** of\n * unthrown, e.g. the CJS and ESM builds loaded side by side, is still\n * recognised). A look-alike plain object (`{ tag: \"Ok\" }`) carries neither and\n * is **not** matched. An `AsyncResult` is not a `Result` and returns `false`.\n *\n * @returns `true` when `x` is a `Result` produced by this library.\n *\n * @example\n * ```ts\n * import { isResult, Ok } from \"unthrown\";\n *\n * isResult(Ok(1)); // => true\n * isResult({ tag: \"Ok\" }); // => false (look-alike, wrong prototype)\n * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)\n *\n * const x: unknown = Ok(1);\n * if (isResult(x))\n *   x.match({ ok: () => 1, errCases: (m) => m.with(P._, () => 0), defect: () => -1 });\n * ```\n *\n * @category Guards\n */\nexport function isResult(x: unknown): x is Result<unknown, unknown> {\n  if (x instanceof Res) return true;\n  // Dual-copy / cross-realm fallback: another copy of unthrown has its own\n  // `Res`, so `instanceof` fails — but its prototype carries the shared\n  // `Symbol.for` brand. Reading the brand off the prototype chain keeps the\n  // guarantee that a structural look-alike (no unthrown prototype) still fails.\n  // Fail-closed: this guard exists for untyped boundaries, so a hostile input\n  // (a Proxy `get` trap or a throwing getter at the brand key) is `false`,\n  // never a throw.\n  try {\n    return (\n      (typeof x === \"object\" || typeof x === \"function\") &&\n      x !== null &&\n      Reflect.get(x, RESULT_BRAND) === true\n    );\n  } catch {\n    return false;\n  }\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 * The Defect minted when a callback constrained to return a `Result` returns\n * something else — reachable only from untyped/cast callers (in typed code the\n * constraint is a compile error). The combinator-side sibling of the\n * aggregates' non-`Result`-element guard: surface the out-of-contract value as\n * a `Defect` here rather than letting a poison value throw a raw `TypeError`\n * further down the pipeline.\n *\n * @internal\n */\nfunction nonResultCallbackDefect<T, E>(): Result<T, E> {\n  return defectRes(new TypeError(\"unthrown: a combinator callback returned a non-Result value\"));\n}\n\n/**\n * Drive an error-combinator callback: build `match(error)`, hand it (plus the\n * injected `defect`) to the callback, and `.run()` the returned exhaustive\n * builder to its output. `.run()` executes `.exhaustive()` — type-forced\n * exhaustive, so it always matches for well-typed callers; a value that slips\n * through the types (a widened cast, a JS caller) throws `NonExhaustiveError`,\n * which the caller's `try/catch` turns into a `Defect` — an unmodeled failure.\n *\n * @internal\n */\nfunction runMatch<E>(\n  f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => { run: () => unknown },\n  error: E,\n): unknown {\n  return f(match(error) as ErrMatcher<E>, defect).run();\n}\n\n/**\n * A throw inside a *failure observer* (`tapErrCases` / `tapDefect` / `flatTapErrCases`)\n * must not destroy the failure being observed — that is the exact place (e.g. a\n * failing error-logger) where losing the underlying failure hurts most. The\n * resulting Defect aggregates both: `errors[0]` is the observer's throw,\n * `errors[1]` the original failure.\n *\n * @internal\n */\nfunction observerThrowToDefect<T, E>(thrown: unknown, original: unknown): Result<T, E> {\n  return defectRes(\n    new AggregateError(\n      [thrown, original],\n      \"unthrown: a failure-observer callback threw; errors[0] is the callback's throw, errors[1] the original failure\",\n    ),\n  );\n}\n\n/**\n * Validate that a `bind`/`let` scope is a real (non-null) object before merging a\n * key into it.\n *\n * @remarks\n * Do-notation accumulates an **object** scope: a chain starts at `Do()` (an\n * empty object) and every `bind`/`let` returns an object, so in typed code the\n * scope is always an object. The method lives on the general `Result` surface,\n * though, so a primitive `Ok` (e.g. `Ok(5).bind(...)`, or a chain whose value was\n * `map`-ped away from its scope) could reach it. Rather than let `{ ...5 }`\n * silently collapse to `{}` and drop the prior scope, we throw here — the\n * surrounding `try` turns it into a `Defect`, surfacing the misuse as the\n * bug it is (a defect is a bug, not an absent value). A `this: object` constraint\n * was rejected: TypeScript does not hard-enforce a constraint inferred solely\n * from `this`, and it breaks `AsyncRes implements AsyncResult`.\n *\n * @internal\n */\nfunction scopeOf(value: unknown): object {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(\"bind/let requires an object scope — start a do-chain with Do()\");\n  }\n  return value;\n}\n\n/**\n * The sole runtime implementation of {@link AsyncResult}: wraps a\n * `Promise<Result>` constructed never to reject. Operates on the public `Result`\n * union (via `tag`), never on `Res` internals. Never re-exported from `index.ts`.\n *\n * @internal\n */\nexport class AsyncRes<T, E> implements AsyncResult<T, E> {\n  // A native #private field: invisible to property access and untouchable even\n  // via Object.defineProperty, so the wrapped promise cannot be tampered with.\n  readonly #promise: Promise<Result<T, E>>;\n\n  constructor(promise: Promise<Result<T, E>>) {\n    this.#promise = promise;\n  }\n\n  // oxlint-disable-next-line no-thenable -- AsyncResult is an intentional (success-only) thenable so `await` collapses it to a Result; see the Awaitable type. onrejected is still forwarded so a hypothetical internal rejection settles the await instead of hanging — though the internal promise never rejects.\n  then<R1 = Result<T, E>, R2 = never>(\n    onfulfilled?: ((value: Result<T, E>) => R1 | PromiseLike<R1>) | null,\n    onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null,\n  ): PromiseLike<R1 | R2> {\n    return this.#promise.then(onfulfilled, onrejected);\n  }\n\n  map<U>(f: (value: T) => U & NotThenable<U>): AsyncResult<U, E> {\n    return new AsyncRes<U, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return okRes(f(r.value));\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  flatMap<U, E2>(f: (value: T) => Result<U, E2> | AsyncResult<U, E2>): AsyncResult<U, E | E2> {\n    return new AsyncRes<U, E | E2>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          const inner = await f(r.value);\n          return isResult(inner) ? inner : nonResultCallbackDefect<U, E | E2>();\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tap<R>(f: (value: T) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Ok\") return r;\n        try {\n          f(r.value);\n          return r;\n        } catch (cause) {\n          return defectRes<T, E>(cause);\n        }\n      }),\n    );\n  }\n\n  flatTap<E2>(\n    f: (value: T) => Result<unknown, E2> | AsyncResult<unknown, E2>,\n  ): AsyncResult<T, E | E2> {\n    return new AsyncRes<T, E | E2>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          const inner = await f(r.value);\n          if (!isResult(inner)) return nonResultCallbackDefect();\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 (!isResult(inner)) return nonResultCallbackDefect();\n          if (inner.tag !== \"Ok\") return passThrough(inner);\n          return okRes({ ...scopeOf(r.value), [name]: inner.value }) as unknown as Result<\n            Bound<T, K, U>,\n            E | E2\n          >;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  let<K extends string, U>(\n    name: K,\n    f: (scope: T) => U & NotThenable<U>,\n  ): AsyncResult<Bound<T, K, U>, E> {\n    return new AsyncRes<Bound<T, K, U>, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          return okRes({ ...scopeOf(r.value), [name]: f(r.value) }) as unknown as Result<\n            Bound<T, K, U>,\n            E\n          >;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  as<U>(value: U): AsyncResult<U, E> {\n    return new AsyncRes<U, E>(\n      this.#promise.then((r) => (r.tag === \"Ok\" ? okRes<U, E>(value) : passThrough(r))),\n    );\n  }\n\n  discard(): AsyncResult<void, E> {\n    return new AsyncRes<void, E>(\n      this.#promise.then((r) => (r.tag === \"Ok\" ? okRes<void, E>(undefined) : passThrough(r))),\n    );\n  }\n\n  // Like the matcher methods below, `ensure` is typed loosely here (`never`\n  // channels) because TypeScript cannot relate this single implementation\n  // signature to the public type-guard/boolean overload pair across the\n  // class/`implements` boundary; `AsyncResultMethods` re-imposes the precision.\n  ensure(\n    predicate: (value: T) => boolean,\n    onFail: (value: T) => unknown,\n  ): AsyncResult<never, never> {\n    return new AsyncRes<never, never>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Ok\") return passThrough(r);\n        try {\n          // A passing value flows through as the same Ok (see the sync `ensure`).\n          return (predicate(r.value) ? r : errRes(onFail(r.value))) as Result<never, never>;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  // The precise generic-M matcher signatures live on the public surface\n  // (`AsyncResultMethods`); TypeScript cannot unify them across the\n  // class/`implements` boundary (relating the two generic signatures fails to\n  // equate `MatchErrOut<M>` on each side), so these implementations are typed\n  // loosely — `never` error channels keep the returns bivariantly compatible —\n  // and the interface re-imposes the precision, mirroring how `get`'s `this`\n  // gate is re-imposed in `types.ts`.\n  mapErrCases(\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<unknown>,\n  ): AsyncResult<T, never> {\n    return new AsyncRes<T, never>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const out = runMatch(f, r.error);\n          if (isDefectMarker(out)) return defectRes<T, never>(out.cause);\n          return errRes<T, never>(out as never);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  flatMapErrCases(\n    f: (\n      matcher: ErrMatcher<E>,\n      defect: (cause: unknown) => Defect,\n    ) => ExhaustiveMatch<Result<unknown, unknown> | AsyncResult<unknown, unknown> | Defect>,\n  ): AsyncResult<T, never> {\n    return new AsyncRes<T, never>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const out = runMatch(f, r.error);\n          if (isDefectMarker(out)) return defectRes<T, never>(out.cause);\n          const inner = await (out as Result<unknown, unknown> | AsyncResult<unknown, unknown>);\n          if (!isResult(inner)) return nonResultCallbackDefect<T, never>();\n          return inner as Result<T, never>;\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  recoverErrCases(\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<unknown>,\n  ): AsyncResult<T, never> {\n    return new AsyncRes<T, never>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const out = runMatch(f, r.error);\n          if (isDefectMarker(out)) return defectRes<T, never>(out.cause);\n          return okRes<T, never>(out as T);\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tapErrCases(\n    f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<unknown>,\n  ): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Err\") return r;\n        try {\n          runMatch(f, r.error);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.error);\n        }\n      }),\n    );\n  }\n\n  flatTapErrCases(\n    f: (\n      matcher: ErrMatcher<E>,\n      defect: (cause: unknown) => Defect,\n    ) => ExhaustiveMatch<Result<unknown, unknown> | AsyncResult<unknown, unknown>>,\n  ): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Err\") return passThrough(r);\n        try {\n          const inner = await (runMatch(f, r.error) as\n            | Result<unknown, unknown>\n            | AsyncResult<unknown, unknown>);\n          if (!isResult(inner)) return nonResultCallbackDefect();\n          // Keep the original error on success; an Err/Defect from the effect wins.\n          return inner.tag === \"Ok\" ? passThrough(r) : passThrough(inner);\n        } catch (cause) {\n          return observerThrowToDefect(cause, r.error);\n        }\n      }),\n    );\n  }\n\n  recoverDefect<U, E2>(\n    f: (cause: unknown) => Result<U, E2> | AsyncResult<U, E2>,\n  ): AsyncResult<T | U, E | E2> {\n    return new AsyncRes<T | U, E | E2>(\n      this.#promise.then(async (r) => {\n        if (r.tag !== \"Defect\") return r;\n        try {\n          const inner = await f(r.cause);\n          return isResult(inner) ? inner : nonResultCallbackDefect<T | U, E | E2>();\n        } catch (cause) {\n          return defectRes(cause);\n        }\n      }),\n    );\n  }\n\n  tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then((r) => {\n        if (r.tag !== \"Defect\") return r;\n        try {\n          f(r.cause);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.cause);\n        }\n      }),\n    );\n  }\n\n  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): AsyncResult<T, E> {\n    return new AsyncRes<T, E>(\n      this.#promise.then((r) => {\n        if (r.tag === \"Ok\") return r;\n        try {\n          f(r);\n          return r;\n        } catch (cause) {\n          return observerThrowToDefect<T, E>(cause, r.tag === \"Err\" ? r.error : r.cause);\n        }\n      }),\n    );\n  }\n\n  match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {\n    ok: (value: T) => ROk;\n    errCases: (matcher: ErrMatcher<E>) => M;\n    defect: (cause: unknown) => RDefect;\n  }): Promise<ROk | RDefect | MatchOut<M>> {\n    return this.#promise.then((r) => r.match(cases));\n  }\n\n  get(): Promise<T> {\n    return this.#promise.then((r) => (r as Result<T, never>).get());\n  }\n  getErr(): Promise<E> {\n    return this.#promise.then((r) => (r as Result<never, E>).getErr());\n  }\n  getOr<U>(fallback: U): Promise<T | U> {\n    return this.#promise.then((r) => r.getOr(fallback));\n  }\n  getOrElse<U>(f: (error: E) => U): Promise<T | U> {\n    return this.#promise.then((r) => r.getOrElse(f));\n  }\n  getOrNull(): Promise<T | null> {\n    return this.#promise.then((r) => r.getOrNull());\n  }\n  getOrUndefined(): Promise<T | undefined> {\n    return this.#promise.then((r) => r.getOrUndefined());\n  }\n  getOrThrow(): Promise<T> {\n    // The cast sidesteps `getOrThrow`'s `this` gate (non-empty error channel),\n    // re-imposed on the public `AsyncResultMethods` signature — mirroring `get`.\n    return this.#promise.then((r) => (r as Result<T, unknown>).getOrThrow());\n  }\n}\n\n// Same hardening as `Res.prototype` above: the shared async combinators cannot\n// be swapped out from under every instance. (The wrapped promise is already a\n// native #private field, unreachable from outside.)\nObject.freeze(AsyncRes.prototype);\n","// Result constructors and the standalone narrowing guards.\n\nimport { errRes, okRes } from \"./core.js\";\nimport type { AsyncResult, DefectView, ErrView, OkView, Result } from \"./types.js\";\n\n/**\n * Construct a successful `void` {@link Result} — `Result<void, never>` —\n * sparing you `Ok(undefined)` and typing the success channel `void`, not\n * `undefined`.\n *\n * @example\n * ```ts\n * import { Ok } from \"unthrown\";\n *\n * Ok(); // => a void success: Result<void, never>\n * ```\n *\n * @category Constructors\n */\nexport function Ok(): Result<void, never>;\n/**\n * Construct a successful {@link Result}.\n *\n * @typeParam T - the success value type.\n * @param value - the success value to wrap.\n *\n * @example\n * ```ts\n * import { Ok } from \"unthrown\";\n *\n * Ok(2).map((n) => n + 1); // => Ok(3)\n * Ok(42).get(); // => 42\n * ```\n *\n * @category Constructors\n */\nexport function Ok<T>(value: T): Result<T, never>;\nexport function Ok<T>(value?: T): Result<T, never> {\n  // The only way in with no argument is the no-arg overload, which fixes the\n  // result type to void — exactly what the omitted undefined inhabits.\n  // Invisible to callers.\n  return okRes(value as T);\n}\n\n/**\n * Construct a failed {@link Result} carrying a **modeled** error.\n *\n * @typeParam E - the modeled error type.\n * @param error - the domain error to wrap.\n *\n * @example\n * ```ts\n * import { Err } from \"unthrown\";\n *\n * Err(\"not_found\").map((n) => n + 1); // => Err(\"not_found\") (map skipped)\n * Err(\"not_found\").getErr(); // => \"not_found\"\n * ```\n *\n * @category Constructors\n */\nexport function Err<E>(error: E): Result<never, E> {\n  return errRes(error);\n}\n\n/**\n * Construct a successful `void` {@link AsyncResult} — `AsyncResult<void, never>`\n * — the pre-lifted form of the no-arg {@link Ok}, sparing you\n * `Ok(undefined).toAsync()`.\n *\n * @example\n * ```ts\n * import { OkAsync } from \"unthrown\";\n *\n * OkAsync(); // => a void success: AsyncResult<void, never>\n * ```\n *\n * @category Constructors\n */\nexport function OkAsync(): AsyncResult<void, never>;\n/**\n * Construct a successful {@link AsyncResult} from a pure value — the pre-lifted\n * form of {@link Ok}, sparing you `Ok(value).toAsync()`.\n *\n * @remarks\n * Reach for this on the synchronous/early branch of an `AsyncResult`-returning\n * function, so both branches share one return type without a trailing\n * `.toAsync()`. Named with the `Async` suffix the async free functions carry\n * (`allAsync`, `allFromDictAsync`); the {@link AsyncResult} companion aliases it\n * as `AsyncResult.Ok` (the namespace already says \"async\", so the suffix drops).\n *\n * @typeParam T - the success value type.\n * @param value - the success value to wrap.\n *\n * @example\n * ```ts\n * import { OkAsync, type AsyncResult } from \"unthrown\";\n *\n * function loadItems(ids: string[]): AsyncResult<Item[], never> {\n *   if (ids.length === 0) return OkAsync([]); // no more Ok([]).toAsync()\n *   return itemRepository.load(ids);\n * }\n * ```\n *\n * @category Constructors\n */\nexport function OkAsync<T>(value: T): AsyncResult<T, never>;\nexport function OkAsync<T>(value?: T): AsyncResult<T, never> {\n  // Same deliberate cast as `Ok` above: argument-less means the no-arg\n  // overload already fixed the type to `void`.\n  return Ok(value as T).toAsync();\n}\n\n/**\n * Construct a failed {@link AsyncResult} carrying a **modeled** error — the\n * pre-lifted form of {@link Err}, sparing you `Err(error).toAsync()`.\n *\n * @remarks\n * The error-channel mirror of {@link OkAsync}; see it for the naming and the\n * `AsyncResult.Err` companion alias.\n *\n * @typeParam E - the modeled error type.\n * @param error - the domain error to wrap.\n *\n * @example\n * ```ts\n * import { ErrAsync } from \"unthrown\";\n *\n * ErrAsync(\"not_found\"); // AsyncResult<never, string>\n * ```\n *\n * @category Constructors\n */\nexport function ErrAsync<E>(error: E): AsyncResult<never, E> {\n  return Err(error).toAsync();\n}\n\n/**\n * Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.\n *\n * @returns `true` when `r` is `Ok`.\n *\n * @example\n * ```ts\n * import { isOk, Ok, Err, type Result } from \"unthrown\";\n *\n * isOk(Ok(1)); // => true\n * isOk(Err(\"boom\")); // => false\n *\n * declare const r: Result<number, string>;\n * if (isOk(r)) r.value; // number, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isOk<T, E>(r: Result<T, E>): r is OkView<T, E> {\n  return r.tag === \"Ok\";\n}\n/**\n * Type guard: narrow a {@link Result} to its `Err` variant, exposing `.error`.\n *\n * @returns `true` when `r` is `Err`.\n *\n * @example\n * ```ts\n * import { isErr, Ok, Err, type Result } from \"unthrown\";\n *\n * isErr(Err(\"boom\")); // => true\n * isErr(Ok(1)); // => false\n *\n * declare const r: Result<number, string>;\n * if (isErr(r)) r.error; // string, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isErr<T, E>(r: Result<T, E>): r is ErrView<E, T> {\n  return r.tag === \"Err\";\n}\n/**\n * Type guard: narrow a {@link Result} to its `Defect` variant, exposing `.cause`.\n *\n * @remarks\n * A `Defect` has no public constructor — it only arises at a boundary (e.g. a\n * callback throwing inside a combinator). This guard is how you detect one.\n *\n * @returns `true` when `r` is a `Defect`.\n *\n * @example\n * ```ts\n * import { isDefect, Ok } from \"unthrown\";\n *\n * // A throw inside a combinator is captured as a Defect:\n * const r = Ok(1).map(() => {\n *   throw new Error(\"boom\");\n * });\n * isDefect(r); // => true\n * isDefect(Ok(1)); // => false\n *\n * if (isDefect(r)) r.cause; // unknown, narrowed\n * ```\n *\n * @category Guards\n */\nexport function isDefect<T, E>(r: Result<T, E>): r is DefectView<T, E> {\n  return r.tag === \"Defect\";\n}\n","// Do-notation entry point. The `bind` / `let` steps live on the `Result` /\n// `AsyncResult` method surface (core.ts); `Do()` just seeds an empty object\n// scope to grow.\n\nimport { Ok } from \"./constructors.js\";\nimport type { AsyncResult, Result } from \"./types.js\";\n\n/**\n * Start a do-notation chain with an empty object scope, grown step by step with\n * `bind` (for `Result`-returning steps) and `let` (for pure values).\n *\n * @remarks\n * Capitalised because `do` is a reserved word. Each step receives the scope\n * accumulated so far; the error types union across `bind`s, and a throw in any\n * step becomes a `Defect`. To go asynchronous, lift the chain with `toAsync()`\n * (then a `bind` may return an `AsyncResult`).\n *\n * @example\n * ```ts\n * import { Do, Ok } from \"unthrown\";\n *\n * const result = Do()\n *   .bind(\"user\", () => findUser(id)) // Result<User, NotFound>\n *   .bind(\"org\", ({ user }) => findOrg(user.orgId)) // Result<Org, NotFound>\n *   .let(\"label\", ({ user, org }) => `${user.name} @ ${org.name}`)\n *   .map(({ user, org, label }) => render(user, org, label));\n * // Result<View, NotFound>\n * ```\n *\n * @example\n * ```ts\n * import { Do, Ok, Err } from \"unthrown\";\n *\n * // Ok path — the scope accumulates:\n * Do()\n *   .bind(\"a\", () => Ok(2))\n *   .let(\"b\", ({ a }) => a * 10)\n *   .map(({ a, b }) => a + b); // => Ok(22)\n *\n * // Err path — the first Err short-circuits the rest:\n * Do()\n *   .bind(\"a\", () => Err(\"boom\"))\n *   .let(\"b\", ({ a }) => a); // => Err(\"boom\")\n * ```\n *\n * @category Do-notation\n */\nexport function Do(): Result<{}, never> {\n  return Ok({});\n}\n\n/**\n * Start an **asynchronous** do-notation chain with an empty object scope — the\n * pre-lifted form of {@link Do}, sparing you `Do().toAsync()`.\n *\n * @remarks\n * From here a `bind` may return a `Result` **or** an `AsyncResult`; the scope\n * accumulates exactly as in a sync {@link Do} chain, and a throw in any step\n * becomes a `Defect`. Named with the `Async` suffix the async free functions\n * carry (`OkAsync`, `allAsync`); the {@link AsyncResult} companion aliases it as\n * `AsyncResult.Do` (the namespace already says \"async\", so the suffix drops).\n *\n * @example\n * ```ts\n * import { DoAsync, Ok } from \"unthrown\";\n *\n * const result = await DoAsync()\n *   .bind(\"user\", () => findUser(id)) // AsyncResult<User, NotFound>\n *   .bind(\"plan\", ({ user }) => Ok(user.plan)) // a sync Result is accepted too\n *   .let(\"label\", ({ user, plan }) => `${user.name} on ${plan}`);\n * // Result<{ user: User; plan: Plan; label: string }, NotFound>\n * ```\n *\n * @category Do-notation\n */\nexport function DoAsync(): AsyncResult<{}, never> {\n  return Do().toAsync();\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 { Err, Ok } from \"./constructors.js\";\nimport { AsyncRes, defectRes, errRes, isResult, okRes } from \"./core.js\";\nimport { type Defect, defect, isDefectMarker } from \"./defect.js\";\nimport type {\n  AsyncErrOf,\n  AsyncOkOf,\n  AsyncResult,\n  ErrOf,\n  NotThenable,\n  OkOf,\n  Result,\n} from \"./types.js\";\n\n/**\n * Bridge a nullable value into a {@link Result}: absence becomes a **modeled**\n * `Err`. The sanctioned alternative to an `Option` type.\n *\n * @remarks\n * `null` and `undefined` map to `Err(onAbsent())`; any other value (including\n * falsy ones like `0`, `\"\"`, `false`) maps to `Ok`.\n *\n * @typeParam T - the (nullable) value type.\n * @typeParam E - the error produced when the value is absent.\n * @param value - the possibly-absent value.\n * @param onAbsent - lazily produces the error for the absent case.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromNullable } from \"unthrown\";\n *\n * const map = new Map([[\"a\", 1]]);\n * fromNullable(map.get(\"a\"), () => \"absent\").getOr(0); // => 1\n * fromNullable(map.get(\"z\"), () => \"absent\"); // => Err(\"absent\")\n * fromNullable(0, () => \"absent\").getOr(-1); // => 0 (falsy but present)\n * ```\n */\nexport function fromNullable<T, E>(\n  value: T | null | undefined,\n  onAbsent: () => E,\n): Result<NonNullable<T>, E> {\n  return value === null || value === undefined ? Err(onAbsent()) : Ok(value as NonNullable<T>);\n}\n\n/**\n * Wrap a throwing synchronous function so it returns a {@link Result} instead of\n * throwing.\n *\n * @remarks\n * `qualify` **must** triage every thrown cause into a modeled error `E` or a\n * `Defect` (via the injected `defect` helper, its second argument) — there is no\n * path that leaves `unknown` in `E`. A throw inside `qualify` itself is treated\n * as a `Defect`. `qualify` is **synchronous**: an `async` qualify is rejected at\n * compile time ({@link NotThenable}) — its `Promise` would land in `E` un-triaged\n * — and a thenable slipped past the types at runtime becomes a `Defect` (never\n * an `Err(Promise)`), its orphaned rejection silenced.\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 fromSafeThrowable} when every throw is a Defect.\n *\n * @typeParam A - the wrapped function's argument tuple.\n * @typeParam T - the wrapped function's return type.\n * @typeParam R - `qualify`'s return type; the modeled error `E` is\n * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).\n * @param fn - the throwing function to wrap.\n * @param qualify - triages a thrown `cause` into a modeled `E`, or marks it\n * unmodeled by returning `defect(cause)` (the helper passed as its second arg).\n * @returns a function with the same arguments returning `Result<T, E>`.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromThrowable } from \"unthrown\";\n *\n * // Model the parse failure as an `Err`, everything unexpected as a `Defect`.\n * const parse = fromThrowable(\n *   (text: string) => JSON.parse(text) as unknown,\n *   (cause, defect) =>\n *     cause instanceof SyntaxError ? (\"invalid_json\" as const) : defect(cause),\n * );\n *\n * parse('{\"ok\":true}').getOr(null); // => { ok: true }\n * parse(\"nope\"); // => Err(\"invalid_json\")\n * ```\n */\nexport function fromThrowable<A extends unknown[], T, R>(\n  fn: (...args: A) => T,\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R & NotThenable<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 throwing synchronous function asserted **not** to fail in any modeled\n * way: any throw becomes a `Defect`.\n *\n * @remarks\n * The synchronous counterpart of {@link fromSafePromise}. Use it only when a\n * throw genuinely indicates a bug rather than an anticipated outcome — the\n * error channel is `never`, so there is nothing to triage; there is no\n * `qualify`. When some throws *are* anticipated, reach for\n * {@link fromThrowable} and triage them.\n *\n * @typeParam A - the wrapped function's argument tuple.\n * @typeParam T - the wrapped function's return type.\n * @param fn - the throwing function to wrap.\n * @returns a function with the same arguments returning `Result<T, never>`.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromSafeThrowable } from \"unthrown\";\n *\n * // A decode failure here is a bug (the row came from our own schema), so\n * // every throw is a defect — no throwaway `(cause, defect) => defect(cause)`.\n * const decode = fromSafeThrowable((row: Row) => userSchema.parse(row));\n *\n * decode(row); // => Result<User, never> — a throw becomes a Defect\n * ```\n */\nexport function fromSafeThrowable<A extends unknown[], T>(\n  fn: (...args: A) => T,\n): (...args: A) => Result<T, never> {\n  return (...args: A): Result<T, never> => {\n    try {\n      return Ok(fn(...args));\n    } catch (cause) {\n      return defectRes<T, never>(cause);\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`. `qualify` is\n * **synchronous**: an `async` qualify is rejected at compile time\n * ({@link NotThenable}), and a thenable slipped past the types at runtime\n * becomes a `Defect` (never an `Err(Promise)`), its orphaned rejection silenced.\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 * @param _guard - compile-time only; never pass it. The phantom rest-tuple that\n * enforces \"qualify is synchronous\": an `async` qualify makes this demand an\n * impossible extra argument (whose type spells out the error), while a\n * synchronous one leaves it empty. Encoded here — not on `qualify`'s return\n * type — so `T`'s inference from `promise` is undisturbed.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromPromise } from \"unthrown\";\n *\n * // A rejection with a NotFoundError becomes a modeled `Err`; anything else a Defect.\n * const user = await fromPromise(fetchUser(id), (cause, defect) =>\n *   cause instanceof NotFoundError ? (\"not_found\" as const) : defect(cause),\n * );\n *\n * if (user.isOk()) user.value; // => the fetched user\n * // when fetchUser rejects with NotFoundError: user is Err(\"not_found\")\n * ```\n */\nexport function fromPromise<T, R>(\n  promise: Promise<T> | (() => Promise<T>),\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R,\n  // Phantom rest-tuple guard — the async-qualify ban, encoded OFF the callback's\n  // return type: `R & NotThenable<R>` there made TS defer qualify's inference,\n  // which collapsed `T` to `unknown` for an inline `.then(…)` chain argument.\n  // With the conditional here instead, an async qualify demands an impossible\n  // third argument (compile error carrying the message) while `T`/`R` infer\n  // normally. Nothing is ever passed at runtime.\n  //\n  // `Extract` (not `[R] extends [PromiseLike<…>]`) so the ban also fires when\n  // only SOME arms of a union return are thenable (`E | Promise<X>` — a\n  // sometimes-async qualify is still an unqualified rejection path), and it\n  // vacuously admits the always-throwing qualify (`R = never` extracts to\n  // `never`) with no special case. The runtime thenable→Defect net in\n  // `qualifyToResult` stays as the last resort for untyped callers.\n  ..._guard: [Extract<R, PromiseLike<unknown>>] extends [never]\n    ? []\n    : [\"unthrown: qualify must be synchronous — its Promise would land in E un-triaged\"]\n): AsyncResult<T, Exclude<R, Defect>> {\n  type E = Exclude<R, Defect>;\n  const triage = qualify as (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect;\n  // Promise.resolve() also absorbs a non-thenable passed from untyped code, so\n  // this boundary never throws synchronously — it exists to prevent throws.\n  const p =\n    typeof promise === \"function\" ? Promise.resolve().then(promise) : Promise.resolve(promise);\n  const settled: Promise<Result<T, E>> = p.then(\n    (value) => okRes<T, E>(value),\n    (cause) => qualifyToResult<T, E>(cause, triage),\n  );\n  return new AsyncRes<T, E>(settled);\n}\n\n/**\n * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection\n * becomes a `Defect`.\n *\n * @remarks\n * Use this only when a rejection genuinely indicates a bug rather than an\n * anticipated outcome — the error channel is `never`, so there is nothing to\n * triage. (`await`-ing still yields a `Result`; it never throws.) The\n * synchronous counterpart is {@link fromSafeThrowable}.\n *\n * @typeParam T - the resolved value type.\n * @param promise - the promise, or a thunk returning one.\n *\n * @category Interop\n *\n * @example\n * ```ts\n * import { fromSafePromise } from \"unthrown\";\n *\n * (await fromSafePromise(Promise.resolve(3))).get(); // => 3\n * // a rejection becomes a Defect (never a modeled Err):\n * await fromSafePromise(Promise.reject(new Error(\"boom\"))); // => Defect(Error(\"boom\"))\n * ```\n */\nexport function fromSafePromise<T>(\n  promise: Promise<T> | (() => Promise<T>),\n): AsyncResult<T, never> {\n  // Promise.resolve() also absorbs a non-thenable passed from untyped code, so\n  // this boundary never throws synchronously — it exists to prevent throws.\n  const p =\n    typeof promise === \"function\" ? Promise.resolve().then(promise) : Promise.resolve(promise);\n  const settled: Promise<Result<T, never>> = p.then(\n    (value) => okRes<T, never>(value),\n    (cause) => defectRes<T, never>(cause),\n  );\n  return new AsyncRes<T, never>(settled);\n}\n\nfunction qualifyToResult<T, E>(\n  cause: unknown,\n  qualify: (cause: unknown, defect: (cause: unknown) => Defect) => E | Defect,\n): Result<T, E> {\n  try {\n    const q = qualify(cause, defect);\n    if (isDefectMarker(q)) return defectRes<T, E>(q.cause);\n    if (isThenable(q)) {\n      // An async `qualify` slipped past the compile-time NotThenable ban\n      // (untyped/JS caller). Its Promise must never become the modeled error —\n      // the boundary would be un-triaged — so surface a Defect instead. Also\n      // adopt-and-silence the orphaned thenable: if the async qualify later\n      // rejects, that rejection must not float as an unhandled rejection.\n      void Promise.resolve(q).then(undefined, () => undefined);\n      return defectRes<T, E>(\n        new TypeError(\n          \"unthrown: qualify must be synchronous — it returned a thenable; triage the cause without awaiting\",\n        ),\n      );\n    }\n    return 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 * Runtime thenable probe for the belt-and-braces guard above. Called inside the\n * caller's `try`, so even a hostile `.then` getter lands on the Defect path.\n *\n * @internal\n */\nfunction isThenable(x: unknown): boolean {\n  return (\n    (typeof x === \"object\" || typeof x === \"function\") &&\n    x !== null &&\n    typeof (x as { then?: unknown }).then === \"function\"\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 */\n/** The Defect minted for an out-of-contract non-`Result` element in an aggregate. */\nfunction nonResultDefect(): Result<unknown, unknown> {\n  return defectRes(new TypeError(\"unthrown: aggregate received a non-Result element\"));\n}\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 (!isResult(r)) {\n      // Out-of-contract element (a hole/undefined/non-Result, reachable only via\n      // untyped or cast input). Surface it as a Defect — an unexpected failure —\n      // rather than throwing on `.tag` (sync) or rejecting the internal promise\n      // (async). A Defect dominates, so break.\n      firstDefect ??= nonResultDefect();\n      break;\n    }\n    if (r.tag === \"Defect\") {\n      firstDefect ??= r;\n      break; // any Defect dominates — nothing later can change the outcome\n    } else if (r.tag === \"Err\") firstErr ??= r;\n    else values.push(r.value);\n  }\n  return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/**\n * Fold a record of settled `Result`s with the same rules, else `Ok` of the\n * record of values. Keys are written with `Object.defineProperty` so a\n * caller-supplied `\"__proto__\"` key cannot pollute the prototype.\n *\n * @internal\n */\nfunction foldRecord(results: ResultRecord): Result<unknown, unknown> {\n  let firstErr: Result<unknown, unknown> | undefined;\n  let firstDefect: Result<unknown, unknown> | undefined;\n  const values: Record<string, unknown> = {};\n  for (const [key, r] of Object.entries(results)) {\n    if (!isResult(r)) {\n      firstDefect ??= nonResultDefect(); // out-of-contract element → Defect (see foldArray)\n      break;\n    }\n    if (r.tag === \"Defect\") {\n      firstDefect ??= r;\n      break; // any Defect dominates — nothing later can change the outcome\n    } else if (r.tag === \"Err\") firstErr ??= r;\n    else\n      Object.defineProperty(values, key, {\n        value: r.value,\n        enumerable: true,\n        writable: true,\n        configurable: true,\n      });\n  }\n  return firstDefect ?? firstErr ?? Ok(values);\n}\n\n/**\n * Collect a tuple/array of {@link Result}s into a single `Result` of all their\n * success values.\n *\n * @remarks\n * Short-circuits on the **first** `Err` (later entries are not inspected for\n * their error); any `Defect` present **dominates**, winning even over an earlier\n * `Err`. A **fixed tuple** keeps its positional types — `all([Ok(1), Ok(\"a\")])`\n * is `Result<[number, string], …>` — while a **dynamic array** `Result<T, E>[]`\n * collapses to `Result<T[], E>` with no cast. For a **record** keyed by name,\n * use {@link allFromDict}.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { all, Ok, Err } from \"unthrown\";\n *\n * all([Ok(1), Ok(\"a\"), Ok(true)]).get(); // => [1, \"a\", true] (typed [number, string, boolean])\n * all([Ok(1), Err(\"e\"), Ok(3)]); // => Err(\"e\") (short-circuits on the first Err)\n * ```\n */\nexport function all<Rs extends readonly Result<unknown, unknown>[]>(\n  results: readonly [...Rs],\n): Result<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>> {\n  return foldArray(results) as unknown as Result<\n    AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>,\n    ErrOf<Rs[number]>\n  >;\n}\n\n/**\n * Collect a **record** of {@link Result}s into a single `Result` of a record of\n * their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is\n * `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for\n * parallel work you'd rather not tuple.\n *\n * @remarks\n * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`\n * dominates. This is **not** error accumulation.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allFromDict, Ok, Err } from \"unthrown\";\n *\n * allFromDict({ id: Ok(1), name: Ok(\"ada\") }).get(); // => { id: 1, name: \"ada\" }\n * allFromDict({ id: Ok(1), name: Err(\"missing\") }); // => Err(\"missing\")\n * ```\n */\nexport function allFromDict<R extends ResultRecord>(\n  results: R,\n): Result<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>> {\n  return foldRecord(results) as unknown as Result<\n    { [K in keyof R]: OkOf<R[K]> },\n    ErrOf<R[keyof R]>\n  >;\n}\n\n/**\n * The asynchronous counterpart of {@link all}: combine a tuple/array of\n * {@link AsyncResult}s into one `AsyncResult` of all their success values.\n *\n * @remarks\n * The inputs are resolved **concurrently** (order preserved); the resolved\n * `Result`s are then folded with the same rules as {@link all} — first `Err`\n * short-circuits, any `Defect` dominates. As ever, the returned `AsyncResult`'s\n * internal promise never rejects. For a **record**, use {@link allFromDictAsync}.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allAsync, fromSafePromise } from \"unthrown\";\n *\n * const both = allAsync([fromSafePromise(Promise.resolve(1)), fromSafePromise(Promise.resolve(2))]);\n * (await both).get(); // => [1, 2]\n * ```\n */\nexport function allAsync<Rs extends readonly AsyncResult<unknown, unknown>[]>(\n  results: readonly [...Rs],\n): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>> {\n  // Each library AsyncResult is a never-rejecting thenable, so Promise.all\n  // adopts them; `foldArray` then applies the all() rules. Adopt every input\n  // defensively — a cast/untyped rejecting thenable becomes a `Defect` rather\n  // than rejecting the internal promise (the \"internal promise never rejects\"\n  // invariant holds even for out-of-contract input).\n  const settled = Promise.all(\n    results.map((r) =>\n      Promise.resolve(r).then(\n        (x) => x,\n        (cause) => defectRes(cause),\n      ),\n    ),\n  ).then((resolved) => foldArray(resolved as readonly Result<unknown, unknown>[]));\n  return new AsyncRes(settled) as unknown as AsyncResult<\n    AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>,\n    AsyncErrOf<Rs[number]>\n  >;\n}\n\n/**\n * The asynchronous counterpart of {@link allFromDict}: combine a record of\n * {@link AsyncResult}s into one `AsyncResult` of a record of their values.\n *\n * @remarks\n * Resolved concurrently (order preserved), folded with the {@link all} rules,\n * and the internal promise never rejects.\n *\n * @category Aggregate\n *\n * @example\n * ```ts\n * import { allFromDictAsync, fromSafePromise } from \"unthrown\";\n *\n * const both = allFromDictAsync({\n *   a: fromSafePromise(Promise.resolve(1)),\n *   b: fromSafePromise(Promise.resolve(\"x\")),\n * });\n * (await both).get(); // => { a: 1, b: \"x\" }\n * ```\n */\nexport function allFromDictAsync<R extends AsyncResultRecord>(\n  results: R,\n): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>> {\n  const entries = Object.entries(results);\n  const settled = Promise.all(\n    // Adopt each input defensively (see `allAsync`): a rejecting thenable\n    // becomes a `Defect`, so the internal promise never rejects.\n    entries.map(([, ar]) =>\n      Promise.resolve(ar).then(\n        (x) => x,\n        (cause) => defectRes(cause),\n      ),\n    ),\n  ).then((resolved) => {\n    // Null-proto accumulator: pairing resolved values back to keys can't pollute.\n    const byKey: ResultRecord = Object.create(null) as ResultRecord;\n    entries.forEach(([key], i) => {\n      byKey[key] = resolved[i]!;\n    });\n    return foldRecord(byKey);\n  });\n  return new AsyncRes(settled) as unknown as AsyncResult<\n    { [K in keyof R]: AsyncOkOf<R[K]> },\n    AsyncErrOf<R[keyof R]>\n  >;\n}\n","// Result facade — a discoverable namespace alias for the standalone entry\n// points. The free functions remain the primary, tree-shakeable API; this\n// object is a separate export, so `import { Ok }` never pulls it in. The value\n// `Result` and the type `Result<T, E>` (types.ts) share a name — the\n// companion-object pattern. See CLAUDE.md → \"Internal design\".\n\nimport { Err, ErrAsync, isDefect, isErr, isOk, Ok, OkAsync } from \"./constructors.js\";\nimport { isResult } from \"./core.js\";\nimport { Do, DoAsync } from \"./do.js\";\nimport {\n  all,\n  allAsync,\n  allFromDict,\n  allFromDictAsync,\n  fromNullable,\n  fromPromise,\n  fromSafePromise,\n  fromSafeThrowable,\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.fromSafeThrowable}, {@link Result.all},\n * {@link Result.allFromDict}, {@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 * The **async** entry points live on the sibling {@link AsyncResult} companion\n * (`AsyncResult.fromPromise`, `AsyncResult.all`, …), grouped by what they\n * return — a static lives in exactly one namespace.\n *\n * @category Facade\n *\n * @example\n * ```ts\n * import { Result } from \"unthrown\";\n * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).get(); // => 2\n * ```\n */\nexport const Result = {\n  Ok,\n  Err,\n  Do,\n  fromNullable,\n  fromThrowable,\n  fromSafeThrowable,\n  all,\n  allFromDict,\n  isOk,\n  isErr,\n  isDefect,\n  isResult,\n} as const;\n\n/**\n * `Result<T, E>` — the core discriminated union. Shares its name with the\n * {@link Result | companion object} above (the value and type are one name); this\n * is the type half.\n *\n * @remarks\n * A `Result` is a discriminated union, so TypeDoc can't list its methods on this\n * alias. Its fluent combinators (`map`, `flatMap`, `match`, `get`, …) are\n * documented one per entry on {@link ResultMethods} — the shared method surface\n * every variant carries. For \"which one do I reach for?\", see the\n * [Choosing a combinator](/reference/combinators) guide.\n *\n * @category Facade\n */\n// Re-alias the Result type into this module so a single `export { Result }`\n// (from index.ts) carries BOTH the companion object above and the type — value\n// and type sharing one name, declaration-merged in one place.\nexport type Result<T, E> = ResultType<T, E>;\n\n/**\n * Companion object grouping the **`AsyncResult`-producing** entry points under\n * the matching namespace: {@link AsyncResult.Ok}, {@link AsyncResult.Err},\n * {@link AsyncResult.Do}, {@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 the pre-lifted constructors, `fromPromise`/`fromSafePromise`,\n * and the async aggregates sit here rather than on {@link Result}; the namespace\n * already conveys \"async\", so the members drop the `Async` suffix their free\n * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is\n * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;\n * `AsyncResult.allFromDict` is\n * `allFromDictAsync`). Like {@link Result}, the free functions remain the\n * primary, tree-shakeable API; the value `AsyncResult` and the type\n * {@link AsyncResult} share one name.\n *\n * @category Facade\n *\n * @example\n * ```ts\n * import { AsyncResult } from \"unthrown\";\n * const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(c));\n * user.get(); // => the fetched user (on success)\n * ```\n */\nexport const AsyncResult = {\n  Ok: OkAsync,\n  Err: ErrAsync,\n  Do: DoAsync,\n  fromPromise,\n  fromSafePromise,\n  all: allAsync,\n  allFromDict: allFromDictAsync,\n} as const;\n\n/**\n * `AsyncResult<T, E>` — the async counterpart of {@link Result}. Shares its name\n * with the {@link AsyncResult | companion object} above (value and type are one\n * name); this is the type half.\n *\n * @remarks\n * `AsyncResult` carries the async fluent surface; its combinators (`map`,\n * `flatMap`, `match`, `get`, …) are documented one per entry — with their\n * async signatures — on {@link AsyncResultMethods}. For \"which one do I reach\n * for?\", see the [Choosing a combinator](/reference/combinators) guide.\n *\n * @category Facade\n */\n// Re-alias the AsyncResult type into this module (same companion-object pattern\n// as Result above) so one `export { AsyncResult }` carries value + type.\nexport type AsyncResult<T, E> = AsyncResultType<T, E>;\n","// The TaggedError convention (à la Effect's `Data.TaggedError`) and the\n// `tag(t)` ts-pattern pattern for matching a tagged error union.\n\ntype Props = Record<string, unknown>;\n\n/**\n * The instance shape produced by a {@link TaggedError} class: an `Error` plus a\n * `_tag` discriminant and the (readonly) payload fields.\n *\n * @typeParam Tag - the string literal discriminant.\n * @typeParam A - the payload object type.\n *\n * @category Types\n */\nexport type TaggedErrorInstance<Tag extends string, A extends Props> = Error &\n  Readonly<Omit<A, \"name\" | \"message\" | \"stack\">> & { readonly _tag: Tag };\n\n/**\n * The class constructor returned by {@link TaggedError}. Generic in its payload:\n * apply it with an instantiation expression at the `extends` site.\n *\n * @remarks\n * When the payload is empty, the constructor takes **no** arguments (the\n * `keyof A extends never ? void : A` trick); otherwise it takes the payload. The\n * `name`, `message`, and `stack` keys are all **rejected** (`?: never`) because\n * all three are reserved: `name` is the display label, `message` is the human\n * string owned by `Error`, and `stack` is `Error`'s trace. Set the message the\n * standard way — `override message = \"…\"` (or a constructor override) on the\n * subclass — never as a free-form per-call payload field. The reservations are\n * enforced at the call site, mirroring how {@link TaggedErrorInstance} excludes\n * all three. (`cause` is deliberately **not** reserved: `Error.cause` is\n * `unknown`, so a typed payload `cause` is a legitimate structured field.)\n *\n * @typeParam Tag - the string literal discriminant.\n *\n * @category Types\n */\nexport type TaggedErrorConstructor<Tag extends string> = {\n  new <A extends Props = {}>(\n    args: keyof A extends never\n      ? void\n      : A & { readonly name?: never; readonly message?: never; readonly stack?: never },\n  ): TaggedErrorInstance<Tag, A>;\n};\n\n/**\n * Build a base class for a tagged error — a class extending `Error` with a\n * `_tag` string discriminant, in the style of Effect's `Data.TaggedError`.\n *\n * @remarks\n * Extend the returned class to declare a concrete error. Supply the payload with\n * an instantiation expression; omit it for a payload-less error. The `message`\n * is **not** a payload field — it is the human string owned by `Error`, not\n * structured data, so it is reserved. Define it once per subclass the standard\n * way, `override message = \"…\"` (it may interpolate the payload via `this`,\n * which the base populates before the subclass field initialiser runs); a\n * payload `message` is rejected at compile time, so contextual detail lives in\n * typed fields, never baked into per-call prose. The `_tag` always reflects\n * `tag` and cannot be overridden by the payload. `name` is likewise reserved —\n * it is the display label (set it with `options.name`); a payload `name` is\n * rejected at compile time (and excluded from the instance type), so it can't\n * shadow `Error.name`. `stack` is reserved the same way — it is `Error`'s\n * trace, and even an untyped payload `stack` cannot clobber the real one.\n * `cause` is deliberately **not** reserved: `Error.cause` is typed `unknown`,\n * so a payload `cause` (e.g. a wrapped driver error) is a legitimate,\n * *narrowing* structured field.\n *\n * `_tag` is the discriminant matched by {@link tag} in the error combinators\n * (`result.mapErrCases((matcher) => matcher.with(tag(\"NotFound\"), …))`) and in\n * `match`; `Error.name` is the human-facing label in stack traces and logs. By\n * default they coincide, but\n * they can be **decoupled** with `options.name` — so a tag can be namespaced for\n * collision-safety (`\"@my-lib/RetryableError\"`) without that slash-prefixed\n * string leaking into `Error.name`:\n *\n * ```ts\n * class RetryableError extends TaggedError(\"@my-lib/RetryableError\", {\n *   name: \"RetryableError\",\n * }) {\n *   override message = \"operation failed; safe to retry\";\n * }\n *\n * const e = new RetryableError();\n * e._tag;    // \"@my-lib/RetryableError\" — namespaced discriminant\n * e.name;    // \"RetryableError\"          — clean display name\n * e.message; // \"operation failed; safe to retry\" — the standard Error.message\n * ```\n *\n * @typeParam Tag - the string literal discriminant.\n * @param tag - the discriminant value; also the default error `name`.\n * @param options - optional overrides. `options.name` sets `Error.name`\n * independently of `tag` (defaults to `tag`).\n *\n * @category Tagged errors\n *\n * @example\n * ```ts\n * class NotFound extends TaggedError(\"NotFound\") {}\n * class HttpError extends TaggedError(\"HttpError\")<{ status: number }> {}\n *\n * new NotFound()._tag; // => \"NotFound\"\n * new HttpError({ status: 500 }).status; // => 500\n * ```\n */\nexport function TaggedError<Tag extends string>(\n  tag: Tag,\n  options?: { readonly name?: string },\n): TaggedErrorConstructor<Tag> {\n  const displayName = options?.name ?? tag;\n  class TaggedErrorBase extends Error {\n    readonly _tag!: Tag;\n\n    constructor(props?: Props) {\n      super();\n      if (props) {\n        // `stack` is reserved like `name`/`message`: it is `Error`'s trace, not\n        // payload data. Capture the genuine trace as a string (V8 exposes\n        // `stack` as a lazy accessor whose setter would happily store a payload\n        // value), let the payload land, then re-assert the real trace as a\n        // plain data property — an untyped caller cannot clobber it. (`cause`\n        // is deliberately allowed through: `Error.cause` is `unknown`, so a\n        // typed payload `cause` is a legitimate structured field.)\n        const stack = this.stack;\n        Object.assign(this, props);\n        delete (this as { stack?: unknown }).stack;\n        if (stack !== undefined) {\n          Object.defineProperty(this, \"stack\", {\n            value: stack,\n            writable: true,\n            enumerable: false,\n            configurable: true,\n          });\n        }\n      }\n      // `_tag`, `name`, and `message` are authoritative — an untyped caller\n      // can't set them via the payload. `_tag`/`name` are re-assigned to their\n      // canonical values; `message` is `Error`'s channel (set per subclass via\n      // `override message = …`, whose field initialiser runs after this\n      // constructor returns), so any payload-supplied `message` is dropped here.\n      (this as { _tag: Tag })._tag = tag;\n      this.name = displayName;\n      delete (this as { message?: unknown }).message;\n      Object.setPrototypeOf(this, new.target.prototype);\n    }\n  }\n\n  return TaggedErrorBase as unknown as TaggedErrorConstructor<Tag>;\n}\n\n/**\n * A `ts-pattern` pattern matching any value whose `_tag` equals `value` — a\n * {@link TaggedError}, or any discriminated member. Equivalent to the object\n * pattern `{ _tag: value }`, but reads better inside an error-matching\n * combinator and narrows to the matching variant, payload included.\n *\n * @typeParam Tag - the string literal tag to match.\n * @param value - the `_tag` to match.\n *\n * @category Tagged errors\n *\n * @example\n * ```ts\n * result.mapErrCases((matcher) =>\n *   matcher\n *     .with(tag(\"NotFound\"), () => new NotFoundException())\n *     .with(tag(\"Conflict\"), (e) => new ConflictException(e.key)),\n * );\n * ```\n */\nexport function tag<const Tag extends string>(value: Tag): { _tag: Tag } {\n  return { _tag: value };\n}\n"],"mappings":";;AAEA,MAAM,SAAwB,OAAO,iBAAiB;;;;;;;;;;;;AAgCtD,SAAgB,OAAO,OAAwB;CAG7C,OAAO,OAAO,OAAO;GAAG,SAAS;EAAM;CAAM,CAAC;AAChD;;;;;;;;AASA,SAAgB,eAAe,GAAyB;CACtD,OACE,OAAO,MAAM,YAAY,MAAM,QAAS,EAAmC,YAAY;AAE3F;;;;;;;;;;;;;;;;;;;;;;;;;;ACQA,IAAa,WAAb,cAA2C,MAAM;;;;;CAK/C;CACA,YAAY,OAAU;EACpB,MAAM,sEAAsE,EAAE,OAAO,MAAM,CAAC;EAC5F,KAAK,OAAO;EACZ,KAAK,QAAQ;EACb,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;CAClD;AACF;;;;;;;;AASA,IAAM,MAAN,MAAgB;CACd,IAA2B,GAAmD;EAC5E,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,MAAM,IAAI,EAAE,KAAK,KAAK;GACtB,OAAO,SAAS,CAAC,IAAI,IAAI,wBAAwB;EACnD,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,IAA2B,GAAmD;EAC5E,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;GACtB,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,wBAAwB;GAEjD,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,CAAC,SAAS,CAAC,GAAG,OAAO,wBAAwB;GACjD,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,UAA6C;EAC3C,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAE9C,OAAO,MAAe,KAAA,CAAS;CACjC;CAIA,OAEE,WACA,QACmB;EACnB,IAAI,KAAK,QAAQ,MAAM,OAAO,YAAY,IAAI;EAC9C,IAAI;GAGF,OAAO,UAAU,KAAK,KAAK,IAAI,OAAO,OAAO,OAAO,KAAK,KAAK,CAAC;EACjE,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,YAEE,GAC2B;EAC3B,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,MAAM,MAAM,SAAS,GAAG,KAAK,KAAK;GAClC,IAAI,eAAe,GAAG,GAAG,OAAO,UAAU,IAAI,KAAK;GACnD,OAAO,OAAO,GAAqB;EACrC,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,gBAEE,GACmD;EACnD,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,MAAM,MAAM,SAAS,GAAG,KAAK,KAAK;GAClC,IAAI,eAAe,GAAG,GAAG,OAAO,UAAU,IAAI,KAAK;GACnD,IAAI,CAAC,SAAS,GAAG,GAAG,OAAO,wBAAwB;GACnD,OAAO;EACT,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,gBAEE,GACmC;EACnC,IAAI,KAAK,QAAQ,OAAO,OAAO,YAAY,IAAI;EAC/C,IAAI;GACF,MAAM,MAAM,SAAS,GAAG,KAAK,KAAK;GAClC,IAAI,eAAe,GAAG,GAAG,OAAO,UAAU,IAAI,KAAK;GACnD,OAAO,MAAM,GAAqB;EACpC,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,YAEE,GACc;EACd,IAAI,KAAK,QAAQ,OAAO,OAAO;EAC/B,IAAI;GACF,SAAS,GAAG,KAAK,KAAK;GACtB,OAAO;EACT,SAAS,OAAO;GACd,OAAO,sBAAsB,OAAO,KAAK,KAAK;EAChD;CACF;CAEA,gBAEE,GACmC;EACnC,IAAI,KAAK,QAAQ,OAAO,OAAO;EAC/B,IAAI;GACF,MAAM,IAAI,SAAS,GAAG,KAAK,KAAK;GAChC,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,wBAAwB;GAEjD,OAAO,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;EAC9C,SAAS,OAAO;GACd,OAAO,sBAAsB,OAAO,KAAK,KAAK;EAChD;CACF;CAEA,cAEE,GACuB;EACvB,IAAI,KAAK,QAAQ,UAAU,OAAO;EAClC,IAAI;GACF,MAAM,IAAI,EAAE,KAAK,KAAK;GACtB,OAAO,SAAS,CAAC,IAAI,IAAI,wBAAwB;EACnD,SAAS,OAAO;GACd,OAAO,UAAU,KAAK;EACxB;CACF;CAEA,UAAiC,GAAyD;EACxF,IAAI,KAAK,QAAQ,UAAU,OAAO;EAClC,IAAI;GACF,EAAE,KAAK,KAAK;GACZ,OAAO;EACT,SAAS,OAAO;GACd,OAAO,sBAAsB,OAAO,KAAK,KAAK;EAChD;CACF;CAEA,WAEE,GACc;EACd,IAAI,KAAK,QAAQ,MAAM,OAAO;EAC9B,IAAI;GACF,EAAE,IAAI;GACN,OAAO;EACT,SAAS,OAAO;GACd,OAAO,sBAAsB,OAAO,KAAK,QAAQ,QAAQ,KAAK,QAAQ,KAAK,KAAK;EAClF;CACF;CAEA,MAEE,OAK6B;EAC7B,QAAQ,KAAK,KAAb;GACE,KAAK,MACH,OAAO,MAAM,GAAG,KAAK,KAAK;GAC5B,KAAK,OAMH,OAAO,MAAM,SAASA,QAAM,KAAK,KAAK,CAAkB,CAAC,CAAC,IAAI;GAChE,KAAK,UACH,OAAO,MAAM,OAAO,KAAK,KAAK;EAClC;CACF;CAEA,MAA2B;EACzB,QAAQ,KAAK,KAAb;GACE,KAAK,MACH,OAAO,KAAK;GACd,KAAK,OACH,MAAM,IAAI,SAAS,KAAK,KAAK;GAC/B,KAAK,UACH,MAAM,KAAK;EACf;CACF;CAEA,SAA8B;EAC5B,QAAQ,KAAK,KAAb;GACE,KAAK,OACH,OAAO,KAAK;GACd,KAAK,MACH,MAAM,IAAI,SAAS,KAAK,KAAK;GAC/B,KAAK,UACH,MAAM,KAAK;EACf;CACF;CAEA,MAA6B,UAAoB;EAC/C,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,OAAO;CACT;CAEA,UAAiC,GAA2B;EAC1D,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,aAAkC;EAChC,IAAI,KAAK,QAAQ,MAAM,OAAO,KAAK;EACnC,IAAI,KAAK,QAAQ,UAAU,MAAM,KAAK;EACtC,MAAM,KAAK;CACb;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;;;;;;;;;;AAWA,MAAM,eAAe,OAAO,IAAI,iBAAiB;AAEjD,MAAM,eAAe,IAAI;AACzB,OAAO,eAAe,cAAc,cAAc,EAAE,OAAO,KAAK,CAAC;AAGjE,OAAO,OAAO,YAAY;;;;;;AAO1B,SAAgB,MAAY,OAAwB;CAGlD,OAAO,OAAO,OACZ,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EACzC,KAAK;EACL;CACF,CAAC,CACH;AACF;;;;;;AAOA,SAAgB,OAAa,OAAwB;CACnD,OAAO,OAAO,OACZ,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EACzC,KAAK;EACL;CACF,CAAC,CACH;AACF;;;;;;AAOA,SAAgB,UAAgB,OAA8B;CAC5D,OAAO,OAAO,OACZ,OAAO,OAAO,OAAO,OAAO,YAAY,GAAG;EACzC,KAAK;EACL;CACF,CAAC,CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,SAAS,GAA2C;CAClE,IAAI,aAAa,KAAK,OAAO;CAQ7B,IAAI;EACF,QACG,OAAO,MAAM,YAAY,OAAO,MAAM,eACvC,MAAM,QACN,QAAQ,IAAI,GAAG,YAAY,MAAM;CAErC,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;AAYA,SAAS,YAAkB,MAA8C;CACvE,OAAO;AACT;;;;;;;;;;;AAYA,SAAS,0BAA8C;CACrD,OAAO,0BAAU,IAAI,UAAU,6DAA6D,CAAC;AAC/F;;;;;;;;;;;AAYA,SAAS,SACP,GACA,OACS;CACT,OAAO,EAAEA,QAAM,KAAK,GAAoB,MAAM,CAAC,CAAC,IAAI;AACtD;;;;;;;;;;AAWA,SAAS,sBAA4B,QAAiB,UAAiC;CACrF,OAAO,UACL,IAAI,eACF,CAAC,QAAQ,QAAQ,GACjB,gHACF,CACF;AACF;;;;;;;;;;;;;;;;;;;AAoBA,SAAS,QAAQ,OAAwB;CACvC,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACpE,MAAM,IAAI,UAAU,gEAAgE;CAEtF,OAAO;AACT;;;;;;;;AASA,IAAa,WAAb,MAAa,SAA4C;CAGvD;CAEA,YAAY,SAAgC;EAC1C,KAAKC,WAAW;CAClB;CAGA,KACE,aACA,YACsB;EACtB,OAAO,KAAKA,SAAS,KAAK,aAAa,UAAU;CACnD;CAEA,IAAO,GAAwD;EAC7D,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,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,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,OAAO,SAAS,KAAK,IAAI,QAAQ,wBAAmC;GACtE,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,IAAO,GAAwD;EAC7D,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,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,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,wBAAwB;IAErD,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,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,wBAAwB;IACrD,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,IACE,MACA,GACgC;EAChC,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,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,KAAKA,SAAS,MAAM,MAAO,EAAE,QAAQ,OAAO,MAAY,KAAK,IAAI,YAAY,CAAC,CAAE,CAClF;CACF;CAEA,UAAgC;EAC9B,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAO,EAAE,QAAQ,OAAO,MAAe,KAAA,CAAS,IAAI,YAAY,CAAC,CAAE,CACzF;CACF;CAMA,OACE,WACA,QAC2B;EAC3B,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,MAAM,OAAO,YAAY,CAAC;GACxC,IAAI;IAEF,OAAQ,UAAU,EAAE,KAAK,IAAI,IAAI,OAAO,OAAO,EAAE,KAAK,CAAC;GACzD,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CASA,YACE,GACuB;EACvB,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,MAAM,SAAS,GAAG,EAAE,KAAK;IAC/B,IAAI,eAAe,GAAG,GAAG,OAAO,UAAoB,IAAI,KAAK;IAC7D,OAAO,OAAiB,GAAY;GACtC,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,gBACE,GAIuB;EACvB,OAAO,IAAI,SACT,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,MAAM,SAAS,GAAG,EAAE,KAAK;IAC/B,IAAI,eAAe,GAAG,GAAG,OAAO,UAAoB,IAAI,KAAK;IAC7D,MAAM,QAAQ,MAAO;IACrB,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,wBAAkC;IAC/D,OAAO;GACT,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,gBACE,GACuB;EACvB,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,MAAM,SAAS,GAAG,EAAE,KAAK;IAC/B,IAAI,eAAe,GAAG,GAAG,OAAO,UAAoB,IAAI,KAAK;IAC7D,OAAO,MAAgB,GAAQ;GACjC,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,YACE,GACmB;EACnB,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,OAAO,OAAO;GAC5B,IAAI;IACF,SAAS,GAAG,EAAE,KAAK;IACnB,OAAO;GACT,SAAS,OAAO;IACd,OAAO,sBAA4B,OAAO,EAAE,KAAK;GACnD;EACF,CAAC,CACH;CACF;CAEA,gBACE,GAImB;EACnB,OAAO,IAAI,SACT,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,OAAO,OAAO,YAAY,CAAC;GACzC,IAAI;IACF,MAAM,QAAQ,MAAO,SAAS,GAAG,EAAE,KAAK;IAGxC,IAAI,CAAC,SAAS,KAAK,GAAG,OAAO,wBAAwB;IAErD,OAAO,MAAM,QAAQ,OAAO,YAAY,CAAC,IAAI,YAAY,KAAK;GAChE,SAAS,OAAO;IACd,OAAO,sBAAsB,OAAO,EAAE,KAAK;GAC7C;EACF,CAAC,CACH;CACF;CAEA,cACE,GAC4B;EAC5B,OAAO,IAAI,SACT,KAAKA,SAAS,KAAK,OAAO,MAAM;GAC9B,IAAI,EAAE,QAAQ,UAAU,OAAO;GAC/B,IAAI;IACF,MAAM,QAAQ,MAAM,EAAE,EAAE,KAAK;IAC7B,OAAO,SAAS,KAAK,IAAI,QAAQ,wBAAuC;GAC1E,SAAS,OAAO;IACd,OAAO,UAAU,KAAK;GACxB;EACF,CAAC,CACH;CACF;CAEA,UAAa,GAA8D;EACzE,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,UAAU,OAAO;GAC/B,IAAI;IACF,EAAE,EAAE,KAAK;IACT,OAAO;GACT,SAAS,OAAO;IACd,OAAO,sBAA4B,OAAO,EAAE,KAAK;GACnD;EACF,CAAC,CACH;CACF;CAEA,WAAc,GAA0E;EACtF,OAAO,IAAI,SACT,KAAKA,SAAS,MAAM,MAAM;GACxB,IAAI,EAAE,QAAQ,MAAM,OAAO;GAC3B,IAAI;IACF,EAAE,CAAC;IACH,OAAO;GACT,SAAS,OAAO;IACd,OAAO,sBAA4B,OAAO,EAAE,QAAQ,QAAQ,EAAE,QAAQ,EAAE,KAAK;GAC/E;EACF,CAAC,CACH;CACF;CAEA,MAAwD,OAIf;EACvC,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,MAAM,KAAK,CAAC;CACjD;CAEA,MAAkB;EAChB,OAAO,KAAKA,SAAS,MAAM,MAAO,EAAuB,IAAI,CAAC;CAChE;CACA,SAAqB;EACnB,OAAO,KAAKA,SAAS,MAAM,MAAO,EAAuB,OAAO,CAAC;CACnE;CACA,MAAS,UAA6B;EACpC,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,MAAM,QAAQ,CAAC;CACpD;CACA,UAAa,GAAoC;EAC/C,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,UAAU,CAAC,CAAC;CACjD;CACA,YAA+B;EAC7B,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,UAAU,CAAC;CAChD;CACA,iBAAyC;EACvC,OAAO,KAAKA,SAAS,MAAM,MAAM,EAAE,eAAe,CAAC;CACrD;CACA,aAAyB;EAGvB,OAAO,KAAKA,SAAS,MAAM,MAAO,EAAyB,WAAW,CAAC;CACzE;AACF;AAKA,OAAO,OAAO,SAAS,SAAS;;;ACv3BhC,SAAgB,GAAM,OAA6B;CAIjD,OAAO,MAAM,KAAU;AACzB;;;;;;;;;;;;;;;;;AAkBA,SAAgB,IAAO,OAA4B;CACjD,OAAO,OAAO,KAAK;AACrB;AA4CA,SAAgB,QAAW,OAAkC;CAG3D,OAAO,GAAG,KAAU,CAAC,CAAC,QAAQ;AAChC;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,SAAY,OAAiC;CAC3D,OAAO,IAAI,KAAK,CAAC,CAAC,QAAQ;AAC5B;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,KAAW,GAAoC;CAC7D,OAAO,EAAE,QAAQ;AACnB;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,MAAY,GAAqC;CAC/D,OAAO,EAAE,QAAQ;AACnB;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,SAAe,GAAwC;CACrE,OAAO,EAAE,QAAQ;AACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9JA,SAAgB,KAAwB;CACtC,OAAO,GAAG,CAAC,CAAC;AACd;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,UAAkC;CAChD,OAAO,GAAG,CAAC,CAAC,QAAQ;AACtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnCA,SAAgB,aACd,OACA,UAC2B;CAC3B,OAAO,UAAU,QAAQ,UAAU,KAAA,IAAY,IAAI,SAAS,CAAC,IAAI,GAAG,KAAuB;AAC7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,kBACd,IACkC;CAClC,QAAQ,GAAG,SAA8B;EACvC,IAAI;GACF,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC;EACvB,SAAS,OAAO;GACd,OAAO,UAAoB,KAAK;EAClC;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,YACd,SACA,SAcA,GAAG,QAGiC;CAEpC,MAAM,SAAS;CASf,OAAO,IAAI,UALT,OAAO,YAAY,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAQ,QAAQ,OAAO,EAAA,CAClD,MACtC,UAAU,MAAY,KAAK,IAC3B,UAAU,gBAAsB,OAAO,MAAM,CAEhB,CAAC;AACnC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,gBACd,SACuB;CASvB,OAAO,IAAI,UALT,OAAO,YAAY,aAAa,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,IAAI,QAAQ,QAAQ,OAAO,EAAA,CAC9C,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,IAAI,eAAe,CAAC,GAAG,OAAO,UAAgB,EAAE,KAAK;EACrD,IAAI,WAAW,CAAC,GAAG;GAMjB,QAAa,QAAQ,CAAC,CAAC,CAAC,KAAK,KAAA,SAAiB,KAAA,CAAS;GACvD,OAAO,0BACL,IAAI,UACF,mGACF,CACF;EACF;EACA,OAAO,OAAa,CAAC;CACvB,SAAS,MAAM;EAEb,OAAO,UAAgB,IAAI;CAC7B;AACF;;;;;;;AAQA,SAAS,WAAW,GAAqB;CACvC,QACG,OAAO,MAAM,YAAY,OAAO,MAAM,eACvC,MAAM,QACN,OAAQ,EAAyB,SAAS;AAE9C;;;;;;;;AAoCA,SAAS,kBAA4C;CACnD,OAAO,0BAAU,IAAI,UAAU,mDAAmD,CAAC;AACrF;AAEA,SAAS,UAAU,SAAwE;CACzF,IAAI;CACJ,IAAI;CACJ,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,KAAK,SAAS;EACvB,IAAI,CAAC,SAAS,CAAC,GAAG;GAKhB,gBAAgB,gBAAgB;GAChC;EACF;EACA,IAAI,EAAE,QAAQ,UAAU;GACtB,gBAAgB;GAChB;EACF,OAAO,IAAI,EAAE,QAAQ,OAAO,aAAa;OACpC,OAAO,KAAK,EAAE,KAAK;CAC1B;CACA,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,GAAG;EAC9C,IAAI,CAAC,SAAS,CAAC,GAAG;GAChB,gBAAgB,gBAAgB;GAChC;EACF;EACA,IAAI,EAAE,QAAQ,UAAU;GACtB,gBAAgB;GAChB;EACF,OAAO,IAAI,EAAE,QAAQ,OAAO,aAAa;OAEvC,OAAO,eAAe,QAAQ,KAAK;GACjC,OAAO,EAAE;GACT,YAAY;GACZ,UAAU;GACV,cAAc;EAChB,CAAC;CACL;CACA,OAAO,eAAe,YAAY,GAAG,MAAM;AAC7C;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,IACd,SACwE;CACxE,OAAO,UAAU,OAAO;AAI1B;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,YACd,SAC2D;CAC3D,OAAO,WAAW,OAAO;AAI3B;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,SACd,SACuF;CAcvF,OAAO,IAAI,SARK,QAAQ,IACtB,QAAQ,KAAK,MACX,QAAQ,QAAQ,CAAC,CAAC,CAAC,MAChB,MAAM,IACN,UAAU,UAAU,KAAK,CAC5B,CACF,CACF,CAAC,CAAC,MAAM,aAAa,UAAU,QAA+C,CACpD,CAAC;AAI7B;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,iBACd,SAC0E;CAC1E,MAAM,UAAU,OAAO,QAAQ,OAAO;CAkBtC,OAAO,IAAI,SAjBK,QAAQ,IAGtB,QAAQ,KAAK,GAAG,QACd,QAAQ,QAAQ,EAAE,CAAC,CAAC,MACjB,MAAM,IACN,UAAU,UAAU,KAAK,CAC5B,CACF,CACF,CAAC,CAAC,MAAM,aAAa;EAEnB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClfA,MAAa,SAAS;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAa,cAAc;CACzB,IAAI;CACJ,KAAK;CACL,IAAI;CACJ;CACA;CACA,KAAK;CACL,aAAa;AACf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACdA,SAAgB,YACd,KACA,SAC6B;CAC7B,MAAM,cAAc,SAAS,QAAQ;CACrC,MAAM,wBAAwB,MAAM;EAClC;EAEA,YAAY,OAAe;GACzB,MAAM;GACN,IAAI,OAAO;IAQT,MAAM,QAAQ,KAAK;IACnB,OAAO,OAAO,MAAM,KAAK;IACzB,OAAQ,KAA6B;IACrC,IAAI,UAAU,KAAA,GACZ,OAAO,eAAe,MAAM,SAAS;KACnC,OAAO;KACP,UAAU;KACV,YAAY;KACZ,cAAc;IAChB,CAAC;GAEL;GAMA,KAAwB,OAAO;GAC/B,KAAK,OAAO;GACZ,OAAQ,KAA+B;GACvC,OAAO,eAAe,MAAM,IAAI,OAAO,SAAS;EAClD;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,IAA8B,OAA2B;CACvE,OAAO,EAAE,MAAM,MAAM;AACvB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unthrown",
-  "version": "5.0.0-beta.4",
+  "version": "5.0.0-beta.5",
   "description": "Explicit errors as values, with a separate defect (panic) channel",
   "keywords": [
     "defect",
@@ -45,20 +45,21 @@
     },
     "./package.json": "./package.json"
   },
-  "dependencies": {
-    "ts-pattern": "5.9.0"
-  },
   "devDependencies": {
     "@btravstack/tsconfig": "0.2.0",
     "@btravstack/typedoc": "0.1.0",
     "@types/node": "26.1.1",
     "@vitest/coverage-v8": "4.1.10",
-    "tsdown": "0.22.7",
+    "ts-pattern": "5.9.0",
+    "tsdown": "0.22.12",
     "typedoc": "0.28.20",
     "typedoc-plugin-markdown": "4.12.0",
     "typescript": "6.0.3",
     "vitest": "4.1.10"
   },
+  "peerDependencies": {
+    "ts-pattern": "^5"
+  },
   "engines": {
     "node": ">=20"
   },