npm - unthrown - Versions diffs - 5.0.0-beta.3 → 5.0.0-beta.4 - Mend

unthrown 5.0.0-beta.3 → 5.0.0-beta.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/index.cjs CHANGED Viewed

@@ -152,7 +152,7 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
-	mapErr(f) {
+	mapErrCases(f) {
 		if (this.tag !== "Err") return passThrough(this);
 		try {
 			const out = runMatch(f, this.error);
@@ -162,7 +162,7 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
-	flatMapErr(f) {
+	flatMapErrCases(f) {
 		if (this.tag !== "Err") return passThrough(this);
 		try {
 			const out = runMatch(f, this.error);
@@ -173,7 +173,7 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
-	recoverErr(f) {
+	recoverErrCases(f) {
 		if (this.tag !== "Err") return passThrough(this);
 		try {
 			const out = runMatch(f, this.error);
@@ -183,7 +183,7 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
-	tapErr(f) {
+	tapErrCases(f) {
 		if (this.tag !== "Err") return this;
 		try {
 			runMatch(f, this.error);
@@ -192,7 +192,7 @@ var Res = class {
 			return observerThrowToDefect(cause, this.error);
 		}
 	}
-	flatTapErr(f) {
+	flatTapErrCases(f) {
 		if (this.tag !== "Err") return this;
 		try {
 			const r = runMatch(f, this.error);
@@ -410,7 +410,7 @@ function runMatch(f, error) {
 	return f((0, ts_pattern.match)(error), defect).run();
 }
 /**
-* A throw inside a *failure observer* (`tapErr` / `tapDefect` / `flatTapErr`)
+* A throw inside a *failure observer* (`tapErrCases` / `tapDefect` / `flatTapErrCases`)
 * must not destroy the failure being observed — that is the exact place (e.g. a
 * failing error-logger) where losing the underlying failure hurts most. The
 * resulting Defect aggregates both: `errors[0]` is the observer's throw,
@@ -547,7 +547,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	mapErr(f) {
+	mapErrCases(f) {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
@@ -559,7 +559,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	flatMapErr(f) {
+	flatMapErrCases(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
@@ -573,7 +573,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	recoverErr(f) {
+	recoverErrCases(f) {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
@@ -585,7 +585,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	tapErr(f) {
+	tapErrCases(f) {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Err") return r;
 			try {
@@ -596,7 +596,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	flatTapErr(f) {
+	flatTapErrCases(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
@@ -1342,7 +1342,7 @@ const AsyncResult = {
 * *narrowing* structured field.
 *
 * `_tag` is the discriminant matched by {@link tag} in the error combinators
-* (`result.mapErr((matcher) => matcher.with(tag("NotFound"), …))`) and in
+* (`result.mapErrCases((matcher) => matcher.with(tag("NotFound"), …))`) and in
 * `match`; `Error.name` is the human-facing label in stack traces and logs. By
 * default they coincide, but
 * they can be **decoupled** with `options.name` — so a tag can be namespaced for
@@ -1416,7 +1416,7 @@ function TaggedError(tag, options) {
 *
 * @example
 * ```ts
-* result.mapErr((matcher) =>
+* result.mapErrCases((matcher) =>
 *   matcher
 *     .with(tag("NotFound"), () => new NotFoundException())
 *     .with(tag("Conflict"), (e) => new ConflictException(e.key)),

package/dist/index.d.cts CHANGED Viewed

@@ -99,7 +99,7 @@ type MatchOut<M> = M extends ExhaustiveMatch<infer O> ? O : never;
 type MatchErrOut<M> = Exclude<MatchOut<M>, Defect>;
 /**
  * The fluent method surface every {@link Result} variant carries — the
- * combinators (`map`, `flatMap`, `mapErr`, `match`, `get`, …), documented one
+ * combinators (`map`, `flatMap`, `mapErrCases`, `match`, `get`, …), documented one
  * per entry below. Factored out so the three variants ({@link OkView},
  * {@link ErrView}, {@link DefectView}) can each intersect it; {@link AsyncResult}
  * mirrors this surface with async signatures.
@@ -272,7 +272,7 @@ type ResultMethods<out T, out E> = {
    * @remarks
    * The callback receives `match(error)` (an {@link ErrMatcher}) and the
    * injected `defect` helper. Chain `.with(pattern, handler)` and **return the
-   * un-terminated builder** — `mapErr` calls `.exhaustive()` itself, so a
+   * un-terminated builder** — `mapErrCases` calls `.exhaustive()` itself, so a
    * missing case is a compile error at the call site (there is no `.exhaustive()`
    * to forget, and no way to slip in `.otherwise()`). The outgoing error type is
    * the union of the branch returns with the `Defect` arm subtracted
@@ -287,7 +287,7 @@ type ResultMethods<out T, out E> = {
    * @typeParam M - the exhaustive builder the callback returns.
    * @param f - builds the match over the error (returns the un-terminated builder).
    */
-  mapErr<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T, MatchErrOut<M>>;
+  mapErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T, MatchErrOut<M>>;
   /**
    * Sequence from an `Err` by producing another `Result` — the error-channel
    * mirror of {@link ResultMethods.flatMap | flatMap}, **matching the error
@@ -300,7 +300,7 @@ type ResultMethods<out T, out E> = {
    * @typeParam M - the exhaustive builder the callback returns.
    * @param f - builds the match; each branch produces a fallback `Result`.
    */
-  flatMapErr<M extends ExhaustiveMatch<Result$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>>;
+  flatMapErrCases<M extends ExhaustiveMatch<Result$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>>;
   /**
    * Recover from an `Err` by producing a success value, emptying the error
    * channel — **matching the error exhaustively** ({@link ErrMatcher}). Pairs
@@ -315,7 +315,7 @@ type ResultMethods<out T, out E> = {
    * @typeParam M - the exhaustive builder the callback returns.
    * @param f - builds the match; each branch produces a success value.
    */
-  recoverErr<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | MatchErrOut<M>, never>;
+  recoverErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | MatchErrOut<M>, never>;
   /**
    * Run a side effect on the error — **matched exhaustively** ({@link ErrMatcher})
    * — and pass the `Result` through unchanged.
@@ -330,11 +330,11 @@ type ResultMethods<out T, out E> = {
    * because the branch results are discarded, a returned `Promise` would float
    * unobserved and its rejection would vanish. A failable
    * `Result`-returning effect belongs in
-   * {@link ResultMethods.flatTapErr | flatTapErr}.
+   * {@link ResultMethods.flatTapErrCases | flatTapErrCases}.
    *
    * @param f - builds the match; branch returns are ignored.
    */
-  tapErr<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): Result$1<T, E>;
+  tapErrCases<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): Result$1<T, E>;
   /**
    * Run a **failable** side effect on the error, keeping the original error but
    * threading the effect's own error — **matched exhaustively**
@@ -353,7 +353,7 @@ type ResultMethods<out T, out E> = {
    * @typeParam M - the exhaustive builder the callback returns.
    * @param f - builds the match; each branch is a failable effect (its `Ok` is ignored).
    */
-  flatTapErr<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2>>): Result$1<T, E | E2>;
+  flatTapErrCases<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2>>): Result$1<T, E | E2>;
   /**
    * Recover from a `Defect` — the **only** combinator that can touch one.
    *
@@ -382,7 +382,7 @@ type ResultMethods<out T, out E> = {
    * Run a side effect on **any failure** — `Err` or `Defect` — and pass the
    * `Result` through unchanged. The one cross-channel observer, for the shared
    * "it went KO" concern (logging, metrics, rollback) that would otherwise be
-   * duplicated across {@link ResultMethods.tapErr | tapErr} and
+   * duplicated across {@link ResultMethods.tapErrCases | tapErrCases} and
    * {@link ResultMethods.tapDefect | tapDefect}.
    *
    * @remarks
@@ -393,7 +393,7 @@ type ResultMethods<out T, out E> = {
    * treat it opaquely for a shared logger. Runs on `Err` and `Defect`; `Ok`
    * passes through. It **observes without consuming**: the failure flows on
    * unchanged — to also recover, use
-   * {@link ResultMethods.recoverErr | recoverErr} /
+   * {@link ResultMethods.recoverErrCases | recoverErrCases} /
    * {@link ResultMethods.recoverDefect | recoverDefect} (deliberately separate
    * acts) or {@link ResultMethods.match | match} at the edge. If `f` throws, the
    * result is a `Defect` whose cause is an `AggregateError` of `[thrown,
@@ -437,7 +437,7 @@ type ResultMethods<out T, out E> = {
    *
    * @remarks
    * Compiles only when the error channel is empty (`E = never`) — eliminate
-   * modeled errors first (`match` / `recoverErr` / `flatMapErr`), or reach for the
+   * modeled errors first (`match` / `recoverErrCases` / `flatMapErrCases`), or reach for the
    * `getOr` / `getOrElse` / `getOrNull` / `getOrUndefined` family (which
    * recover an `Err`). If you get a `'this' context` type error here, that is
    * the gate: the receiver still has a non-`never` error channel.
@@ -501,8 +501,8 @@ type ResultMethods<out T, out E> = {
    * `throw` behind a method, so a `no-throw` lint rule can ban raw throws while
    * this one sanctioned extraction remains — _not_ to replace principled
    * handling. When you can keep the error a value, prefer
-   * {@link ResultMethods.match | match} / {@link ResultMethods.recoverErr | recoverErr} /
-   * {@link ResultMethods.flatMapErr | flatMapErr}.
+   * {@link ResultMethods.match | match} / {@link ResultMethods.recoverErrCases | recoverErrCases} /
+   * {@link ResultMethods.flatMapErrCases | flatMapErrCases}.
    *
    * Type-gated as the **complement** of {@link ResultMethods.get | get}: it
    * compiles only when the error channel is **non-empty** (`E` is not `never`) —
@@ -666,7 +666,7 @@ type Awaitable<out T> = {
 };
 /**
  * The async method surface every {@link AsyncResult} carries — the combinators
- * (`map`, `flatMap`, `mapErr`, `match`, `get`, …) with their asynchronous
+ * (`map`, `flatMap`, `mapErrCases`, `match`, `get`, …) with their asynchronous
  * signatures, documented one per entry below. The async mirror of
  * {@link ResultMethods}: each entry links its synchronous counterpart and states
  * only the async delta.
@@ -756,24 +756,24 @@ type AsyncResultMethods<out T, out E> = {
   /** Boolean form of the asynchronous {@link ResultMethods.ensure | ensure} — validates without refining, keeping `T`. */
   ensure<E2>(predicate: (value: T) => boolean, onFail: (value: T) => E2 & NotThenable<E2>): AsyncResult$1<T, E | E2>;
   /**
-   * Asynchronous {@link ResultMethods.mapErr | mapErr} — the same exhaustive
+   * Asynchronous {@link ResultMethods.mapErrCases | mapErrCases} — the same exhaustive
    * {@link ErrMatcher} form; the combinator calls `.exhaustive()`.
    */
-  mapErr<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T, MatchErrOut<M>>;
+  mapErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T, MatchErrOut<M>>;
   /**
-   * Asynchronous {@link ResultMethods.flatMapErr | flatMapErr} — the same
+   * Asynchronous {@link ResultMethods.flatMapErrCases | flatMapErrCases} — the same
    * exhaustive {@link ErrMatcher} form. Unlike the sync form, a branch may
    * return a `Result` **or** an `AsyncResult`.
    */
-  flatMapErr<M extends ExhaustiveMatch<Result$1<unknown, unknown> | AsyncResult$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | OkOf<MatchOut<M>> | AsyncOkOf<MatchOut<M>>, ErrOf<MatchOut<M>> | AsyncErrOf<MatchOut<M>>>;
+  flatMapErrCases<M extends ExhaustiveMatch<Result$1<unknown, unknown> | AsyncResult$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | OkOf<MatchOut<M>> | AsyncOkOf<MatchOut<M>>, ErrOf<MatchOut<M>> | AsyncErrOf<MatchOut<M>>>;
   /**
-   * Asynchronous {@link ResultMethods.recoverErr | recoverErr} — the same
+   * Asynchronous {@link ResultMethods.recoverErrCases | recoverErrCases} — the same
    * exhaustive {@link ErrMatcher} form. Branches are synchronous; a throw
    * becomes a `Defect`.
    */
-  recoverErr<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | MatchErrOut<M>, never>;
+  recoverErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | MatchErrOut<M>, never>;
   /**
-   * Asynchronous {@link ResultMethods.tapErr | tapErr}. `f` is synchronous; if it
+   * Asynchronous {@link ResultMethods.tapErrCases | tapErrCases}. `f` is synchronous; if it
    * throws, the result is a `Defect` whose cause is an `AggregateError` of
    * `[thrown, original failure]` — observing a failure never destroys it. An
    * async branch is rejected at compile time ({@link NotThenable} on the
@@ -781,18 +781,18 @@ type AsyncResultMethods<out T, out E> = {
    * would float unobserved. The
    * {@link AsyncResultMethods.tap | tap} fire-and-forget caveat applies here
    * too — a failable effect belongs in
-   * {@link AsyncResultMethods.flatTapErr | flatTapErr}.
+   * {@link AsyncResultMethods.flatTapErrCases | flatTapErrCases}.
    */
-  tapErr<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): AsyncResult$1<T, E>;
+  tapErrCases<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): AsyncResult$1<T, E>;
   /**
-   * Asynchronous {@link ResultMethods.flatTapErr | flatTapErr} — the
+   * Asynchronous {@link ResultMethods.flatTapErrCases | flatTapErrCases} — the
    * error-channel mirror of `flatTap`. `f` may return a `Result` **or** an
    * `AsyncResult`; its `Ok` value is discarded, an `Err`/`Defect` from `f`
    * threads through, and if `f` throws, the result is a `Defect` whose cause is
    * an `AggregateError` of `[thrown, original failure]` — observing a failure
    * never destroys it.
    */
-  flatTapErr<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2> | AsyncResult$1<unknown, E2>>): AsyncResult$1<T, E | E2>;
+  flatTapErrCases<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2> | AsyncResult$1<unknown, E2>>): AsyncResult$1<T, E | E2>;
   /**
    * Asynchronous {@link ResultMethods.recoverDefect | recoverDefect}. `f` may
    * return a `Result` or an `AsyncResult`.
@@ -864,7 +864,7 @@ type AsyncResultMethods<out T, out E> = {
  * {@link fromPromise} forces. To do further async work, re-enter through a
  * qualified boundary and compose it: `ar.flatMap((v) => fromPromise(work(v),
  * qualify))`. The eliminators (`get`, …) return promises; the binds
- * (`flatMap`, `flatTap`, `flatMapErr`, `recoverDefect`) additionally accept an
+ * (`flatMap`, `flatTap`, `flatMapErrCases`, `recoverDefect`) additionally accept an
  * `AsyncResult`. Its combinators are documented one per entry on
  * {@link AsyncResultMethods}.
  *
@@ -1396,7 +1396,7 @@ declare function fromSafeThrowable<A extends unknown[], T>(fn: (...args: A) => T
  * // when fetchUser rejects with NotFoundError: user is Err("not_found")
  * ```
  */
-declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R, ..._guard: [R] extends [never] ? [] : [R] extends [PromiseLike<unknown>] ? ["unthrown: qualify must be synchronous — its Promise would land in E un-triaged"] : []): AsyncResult$1<T, Exclude<R, Defect>>;
+declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R, ..._guard: [Extract<R, PromiseLike<unknown>>] extends [never] ? [] : ["unthrown: qualify must be synchronous — its Promise would land in E un-triaged"]): AsyncResult$1<T, Exclude<R, Defect>>;
 /**
  * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection
  * becomes a `Defect`.
@@ -1583,7 +1583,7 @@ declare const Result: {
  * alias. Its fluent combinators (`map`, `flatMap`, `match`, `get`, …) are
  * documented one per entry on {@link ResultMethods} — the shared method surface
  * every variant carries. For "which one do I reach for?", see the
- * [Choosing a combinator](/guide/choosing-a-combinator) guide.
+ * [Choosing a combinator](/reference/combinators) guide.
  *
  * @category Facade
  */
@@ -1634,7 +1634,7 @@ declare const AsyncResult: {
  * `AsyncResult` carries the async fluent surface; its combinators (`map`,
  * `flatMap`, `match`, `get`, …) are documented one per entry — with their
  * async signatures — on {@link AsyncResultMethods}. For "which one do I reach
- * for?", see the [Choosing a combinator](/guide/choosing-a-combinator) guide.
+ * for?", see the [Choosing a combinator](/reference/combinators) guide.
  *
  * @category Facade
  */
@@ -1704,7 +1704,7 @@ type TaggedErrorConstructor<Tag extends string> = {
  * *narrowing* structured field.
  *
  * `_tag` is the discriminant matched by {@link tag} in the error combinators
- * (`result.mapErr((matcher) => matcher.with(tag("NotFound"), …))`) and in
+ * (`result.mapErrCases((matcher) => matcher.with(tag("NotFound"), …))`) and in
  * `match`; `Error.name` is the human-facing label in stack traces and logs. By
  * default they coincide, but
  * they can be **decoupled** with `options.name` — so a tag can be namespaced for
@@ -1756,7 +1756,7 @@ declare function TaggedError<Tag extends string>(tag: Tag, options?: {
  *
  * @example
  * ```ts
- * result.mapErr((matcher) =>
+ * result.mapErrCases((matcher) =>
  *   matcher
  *     .with(tag("NotFound"), () => new NotFoundException())
  *     .with(tag("Conflict"), (e) => new ConflictException(e.key)),

package/dist/index.d.cts.map CHANGED Viewed

	@@ -1 +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":";;cAEM;;;;;;;;;;;;;;;KAgBM;YACA;WACD;;;;;;;;;;KCRC,SAAS,QAAQ,WAAW,IAAI,EAAE;;;;;;;;;KAUlC,MAAM,GAAG,kBAAkB,KAAK,SAAS,KAAK,GAAG,iBAAiB,KAAK,IAAI;;;;;;;;;;;;;;;;;KAkB3E,YAAY,MAAM,YAAY;;;;;;;;;;;;;;KAiB9B,WAAW,KAAK,kBAAkB,QAAM;;;;;;;;;;;KAYxC,gBAAgB;EAC1B,gBAAgB;EAChB,WAAW;;;;;;;KAQD,SAAS,KAAK,UAAU,sBAAsB,KAAK;;;;;;;;;KAUnD,YAAY,KAAK,QAAQ,SAAS,IAAI;;;;;;;;;;;;;;;;;KAkBtC,kBAAkB,OAAO;;;;;;;;;;;;EAYnC,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;EAWvD,QAAQ,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,SAAO,GAAG,IAAI;;;;;;;;;;;;;;;;;;;EAmB9D,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;;;;EAiBvD,QAAQ,IAAI,IAAI,OAAO,MAAM,kBAAgB,MAAM,SAAO,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;EAoBjE,KAAK,kBAAkB,GAAG,IACxB,MAAM,GACN,IAAI,OAAO,MAAM,SAAO,GAAG,MAC1B,SAAO,MAAM,GAAG,GAAG,IAAI,IAAI;;;;;;;;;;;;;;;;EAgB9B,IAAI,kBAAkB,GAAG,MAAM,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,MAAM,GAAG,GAAG,IAAI;;;;;;;;EAQ/F,GAAG,GAAG,OAAO,IAAI,SAAO,GAAG;;;;;;;;;EAS3B,WAAW,eAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCxB,OAAO,UAAU,GAAG,IAClB,YAAY,OAAO,MAAM,SAAS,GAClC,SAAS,OAAO,MAAM,KAAK,YAAY,MACtC,SAAO,GAAG,IAAI;;;;;EAKjB,OAAO,IACL,YAAY,OAAO,eACnB,SAAS,OAAO,MAAM,KAAK,YAAY,MACtC,SAAO,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;EAuBjB,~~OAAO~~,UAAU,~~0BACf~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,SAAO,GAAG,YAAY;;;;;;;;;;;;;EAczB,~~WAAW~~,UAAU,gBAAgB,6BAA2B,~~SAC9D~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,SAAO,IAAI,KAAK,SAAS,KAAK,MAAM,SAAS;;;;;;;;;;;;;;;EAgBhD,~~WAAW~~,UAAU,~~0BACnB~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,SAAO,IAAI,YAAY;;;;;;;;;;;;;;;;;;;EAoB1B,~~OAAO~~,~~GACL~~,IACE,SAAS,WAAW,IACpB,SAAS,mBAAmB,WACzB,gBAAgB,IAAI,YAAY,MACpC,SAAO,GAAG;;;;;;;;;;;;;;;;;;;EAoBb,~~WAAW~~,~~IACT~~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~~OAAO~~,UAAU,~~0BACf~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,cAAY,GAAG,YAAY;;;;;;EAO9B,~~WACE~~,UAAU,gBAAgB,6BAA2B,kCAAgC,SAErF,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,cACD,IAAI,KAAK,SAAS,MAAM,UAAU,SAAS,KAC3C,MAAM,SAAS,MAAM,WAAW,SAAS;;;;;;EAQ3C,~~WAAW~~,UAAU,~~0BACnB~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,cAAY,IAAI,YAAY;;;;;;;;;;;;EAa/B,~~OAAO~~,~~GACL~~,IACE,SAAS,WAAW,IACpB,SAAS,mBAAmB,WACzB,gBAAgB,IAAI,YAAY,MACpC,cAAY,GAAG;;;;;;;;;EAUlB,~~WAAW~~,~~IACT~~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~~MAO9D~~,SAAS,~~2BAEP~~,~~YAAY~~,~~kHAGhB~~,cAAY,GAAG,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCb,gBAAgB,GAC9B,SAAS,QAAQ,YAAY,QAAQ,MACpC,cAAY;;;;;;;;;;;;;;;;;;KAsEV,MACH,+BACA,gDACiB,eAAe,eAAe;;KAG5C,eAAe,eAAe;;KAE9B,oBAAoB,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAwFxB,IAAI,oBAAoB,8BACtC,sBAAsB,MACrB,SAAO,MAAM,OAAO,WAAW,KAAK,KAAK,GAAG,SAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;iBA2B7C,YAAY,UAAU,cACpC,SAAS,IACR,YAAU,WAAW,IAAI,KAAK,EAAE,QAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;iBA2BxC,SAAS,oBAAoB,mCAC3C,sBAAsB,MACrB,cAAY,MAAM,OAAO,WAAW,KAAK,UAAU,GAAG,SAAQ,WAAW;;;;;;;;;;;;;;;;;;;;;;iBAyC5D,iBAAiB,UAAU,mBACzC,SAAS,IACR,iBAAe,WAAW,IAAI,UAAU,EAAE,QAAO,WAAW,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~cCtd1D~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCD,OAAO,GAAG,KAAK,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8B5B;;;;;;;;;;;;;;;;;;;;;;KAyBD,YAAY,GAAG,KAAK,cAAgB,GAAG;;;KCpI9C,QAAQ;;;;;;;;;;KAWD,oBAAoB,oBAAoB,UAAU,SAAS,QACrE,SAAS,KAAK;WAA+C,MAAM;;;;;;;;;;;;;;;;;;;;;;KAsBzD,uBAAuB;OAC5B,UAAU,YACb,YAAY,yBAER;aAAe;aAAuB;aAA0B;MACnE,oBAAoB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Dd,YAAY,oBAC1B,KAAK,KACL;WAAqB;IACpB,uBAAuB;;;;;;;;;;;;;;;;;;;;;iBA8DV,UAAU,oBAAoB,OAAO;EAAQ,MAAM"}
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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"}

package/dist/index.d.mts CHANGED Viewed

@@ -99,7 +99,7 @@ type MatchOut<M> = M extends ExhaustiveMatch<infer O> ? O : never;
 type MatchErrOut<M> = Exclude<MatchOut<M>, Defect>;
 /**
  * The fluent method surface every {@link Result} variant carries — the
- * combinators (`map`, `flatMap`, `mapErr`, `match`, `get`, …), documented one
+ * combinators (`map`, `flatMap`, `mapErrCases`, `match`, `get`, …), documented one
  * per entry below. Factored out so the three variants ({@link OkView},
  * {@link ErrView}, {@link DefectView}) can each intersect it; {@link AsyncResult}
  * mirrors this surface with async signatures.
@@ -272,7 +272,7 @@ type ResultMethods<out T, out E> = {
    * @remarks
    * The callback receives `match(error)` (an {@link ErrMatcher}) and the
    * injected `defect` helper. Chain `.with(pattern, handler)` and **return the
-   * un-terminated builder** — `mapErr` calls `.exhaustive()` itself, so a
+   * un-terminated builder** — `mapErrCases` calls `.exhaustive()` itself, so a
    * missing case is a compile error at the call site (there is no `.exhaustive()`
    * to forget, and no way to slip in `.otherwise()`). The outgoing error type is
    * the union of the branch returns with the `Defect` arm subtracted
@@ -287,7 +287,7 @@ type ResultMethods<out T, out E> = {
    * @typeParam M - the exhaustive builder the callback returns.
    * @param f - builds the match over the error (returns the un-terminated builder).
    */
-  mapErr<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T, MatchErrOut<M>>;
+  mapErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T, MatchErrOut<M>>;
   /**
    * Sequence from an `Err` by producing another `Result` — the error-channel
    * mirror of {@link ResultMethods.flatMap | flatMap}, **matching the error
@@ -300,7 +300,7 @@ type ResultMethods<out T, out E> = {
    * @typeParam M - the exhaustive builder the callback returns.
    * @param f - builds the match; each branch produces a fallback `Result`.
    */
-  flatMapErr<M extends ExhaustiveMatch<Result$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>>;
+  flatMapErrCases<M extends ExhaustiveMatch<Result$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>>;
   /**
    * Recover from an `Err` by producing a success value, emptying the error
    * channel — **matching the error exhaustively** ({@link ErrMatcher}). Pairs
@@ -315,7 +315,7 @@ type ResultMethods<out T, out E> = {
    * @typeParam M - the exhaustive builder the callback returns.
    * @param f - builds the match; each branch produces a success value.
    */
-  recoverErr<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | MatchErrOut<M>, never>;
+  recoverErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | MatchErrOut<M>, never>;
   /**
    * Run a side effect on the error — **matched exhaustively** ({@link ErrMatcher})
    * — and pass the `Result` through unchanged.
@@ -330,11 +330,11 @@ type ResultMethods<out T, out E> = {
    * because the branch results are discarded, a returned `Promise` would float
    * unobserved and its rejection would vanish. A failable
    * `Result`-returning effect belongs in
-   * {@link ResultMethods.flatTapErr | flatTapErr}.
+   * {@link ResultMethods.flatTapErrCases | flatTapErrCases}.
    *
    * @param f - builds the match; branch returns are ignored.
    */
-  tapErr<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): Result$1<T, E>;
+  tapErrCases<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): Result$1<T, E>;
   /**
    * Run a **failable** side effect on the error, keeping the original error but
    * threading the effect's own error — **matched exhaustively**
@@ -353,7 +353,7 @@ type ResultMethods<out T, out E> = {
    * @typeParam M - the exhaustive builder the callback returns.
    * @param f - builds the match; each branch is a failable effect (its `Ok` is ignored).
    */
-  flatTapErr<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2>>): Result$1<T, E | E2>;
+  flatTapErrCases<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2>>): Result$1<T, E | E2>;
   /**
    * Recover from a `Defect` — the **only** combinator that can touch one.
    *
@@ -382,7 +382,7 @@ type ResultMethods<out T, out E> = {
    * Run a side effect on **any failure** — `Err` or `Defect` — and pass the
    * `Result` through unchanged. The one cross-channel observer, for the shared
    * "it went KO" concern (logging, metrics, rollback) that would otherwise be
-   * duplicated across {@link ResultMethods.tapErr | tapErr} and
+   * duplicated across {@link ResultMethods.tapErrCases | tapErrCases} and
    * {@link ResultMethods.tapDefect | tapDefect}.
    *
    * @remarks
@@ -393,7 +393,7 @@ type ResultMethods<out T, out E> = {
    * treat it opaquely for a shared logger. Runs on `Err` and `Defect`; `Ok`
    * passes through. It **observes without consuming**: the failure flows on
    * unchanged — to also recover, use
-   * {@link ResultMethods.recoverErr | recoverErr} /
+   * {@link ResultMethods.recoverErrCases | recoverErrCases} /
    * {@link ResultMethods.recoverDefect | recoverDefect} (deliberately separate
    * acts) or {@link ResultMethods.match | match} at the edge. If `f` throws, the
    * result is a `Defect` whose cause is an `AggregateError` of `[thrown,
@@ -437,7 +437,7 @@ type ResultMethods<out T, out E> = {
    *
    * @remarks
    * Compiles only when the error channel is empty (`E = never`) — eliminate
-   * modeled errors first (`match` / `recoverErr` / `flatMapErr`), or reach for the
+   * modeled errors first (`match` / `recoverErrCases` / `flatMapErrCases`), or reach for the
    * `getOr` / `getOrElse` / `getOrNull` / `getOrUndefined` family (which
    * recover an `Err`). If you get a `'this' context` type error here, that is
    * the gate: the receiver still has a non-`never` error channel.
@@ -501,8 +501,8 @@ type ResultMethods<out T, out E> = {
    * `throw` behind a method, so a `no-throw` lint rule can ban raw throws while
    * this one sanctioned extraction remains — _not_ to replace principled
    * handling. When you can keep the error a value, prefer
-   * {@link ResultMethods.match | match} / {@link ResultMethods.recoverErr | recoverErr} /
-   * {@link ResultMethods.flatMapErr | flatMapErr}.
+   * {@link ResultMethods.match | match} / {@link ResultMethods.recoverErrCases | recoverErrCases} /
+   * {@link ResultMethods.flatMapErrCases | flatMapErrCases}.
    *
    * Type-gated as the **complement** of {@link ResultMethods.get | get}: it
    * compiles only when the error channel is **non-empty** (`E` is not `never`) —
@@ -666,7 +666,7 @@ type Awaitable<out T> = {
 };
 /**
  * The async method surface every {@link AsyncResult} carries — the combinators
- * (`map`, `flatMap`, `mapErr`, `match`, `get`, …) with their asynchronous
+ * (`map`, `flatMap`, `mapErrCases`, `match`, `get`, …) with their asynchronous
  * signatures, documented one per entry below. The async mirror of
  * {@link ResultMethods}: each entry links its synchronous counterpart and states
  * only the async delta.
@@ -756,24 +756,24 @@ type AsyncResultMethods<out T, out E> = {
   /** Boolean form of the asynchronous {@link ResultMethods.ensure | ensure} — validates without refining, keeping `T`. */
   ensure<E2>(predicate: (value: T) => boolean, onFail: (value: T) => E2 & NotThenable<E2>): AsyncResult$1<T, E | E2>;
   /**
-   * Asynchronous {@link ResultMethods.mapErr | mapErr} — the same exhaustive
+   * Asynchronous {@link ResultMethods.mapErrCases | mapErrCases} — the same exhaustive
    * {@link ErrMatcher} form; the combinator calls `.exhaustive()`.
    */
-  mapErr<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T, MatchErrOut<M>>;
+  mapErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T, MatchErrOut<M>>;
   /**
-   * Asynchronous {@link ResultMethods.flatMapErr | flatMapErr} — the same
+   * Asynchronous {@link ResultMethods.flatMapErrCases | flatMapErrCases} — the same
    * exhaustive {@link ErrMatcher} form. Unlike the sync form, a branch may
    * return a `Result` **or** an `AsyncResult`.
    */
-  flatMapErr<M extends ExhaustiveMatch<Result$1<unknown, unknown> | AsyncResult$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | OkOf<MatchOut<M>> | AsyncOkOf<MatchOut<M>>, ErrOf<MatchOut<M>> | AsyncErrOf<MatchOut<M>>>;
+  flatMapErrCases<M extends ExhaustiveMatch<Result$1<unknown, unknown> | AsyncResult$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | OkOf<MatchOut<M>> | AsyncOkOf<MatchOut<M>>, ErrOf<MatchOut<M>> | AsyncErrOf<MatchOut<M>>>;
   /**
-   * Asynchronous {@link ResultMethods.recoverErr | recoverErr} — the same
+   * Asynchronous {@link ResultMethods.recoverErrCases | recoverErrCases} — the same
    * exhaustive {@link ErrMatcher} form. Branches are synchronous; a throw
    * becomes a `Defect`.
    */
-  recoverErr<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | MatchErrOut<M>, never>;
+  recoverErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | MatchErrOut<M>, never>;
   /**
-   * Asynchronous {@link ResultMethods.tapErr | tapErr}. `f` is synchronous; if it
+   * Asynchronous {@link ResultMethods.tapErrCases | tapErrCases}. `f` is synchronous; if it
    * throws, the result is a `Defect` whose cause is an `AggregateError` of
    * `[thrown, original failure]` — observing a failure never destroys it. An
    * async branch is rejected at compile time ({@link NotThenable} on the
@@ -781,18 +781,18 @@ type AsyncResultMethods<out T, out E> = {
    * would float unobserved. The
    * {@link AsyncResultMethods.tap | tap} fire-and-forget caveat applies here
    * too — a failable effect belongs in
-   * {@link AsyncResultMethods.flatTapErr | flatTapErr}.
+   * {@link AsyncResultMethods.flatTapErrCases | flatTapErrCases}.
    */
-  tapErr<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): AsyncResult$1<T, E>;
+  tapErrCases<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): AsyncResult$1<T, E>;
   /**
-   * Asynchronous {@link ResultMethods.flatTapErr | flatTapErr} — the
+   * Asynchronous {@link ResultMethods.flatTapErrCases | flatTapErrCases} — the
    * error-channel mirror of `flatTap`. `f` may return a `Result` **or** an
    * `AsyncResult`; its `Ok` value is discarded, an `Err`/`Defect` from `f`
    * threads through, and if `f` throws, the result is a `Defect` whose cause is
    * an `AggregateError` of `[thrown, original failure]` — observing a failure
    * never destroys it.
    */
-  flatTapErr<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2> | AsyncResult$1<unknown, E2>>): AsyncResult$1<T, E | E2>;
+  flatTapErrCases<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2> | AsyncResult$1<unknown, E2>>): AsyncResult$1<T, E | E2>;
   /**
    * Asynchronous {@link ResultMethods.recoverDefect | recoverDefect}. `f` may
    * return a `Result` or an `AsyncResult`.
@@ -864,7 +864,7 @@ type AsyncResultMethods<out T, out E> = {
  * {@link fromPromise} forces. To do further async work, re-enter through a
  * qualified boundary and compose it: `ar.flatMap((v) => fromPromise(work(v),
  * qualify))`. The eliminators (`get`, …) return promises; the binds
- * (`flatMap`, `flatTap`, `flatMapErr`, `recoverDefect`) additionally accept an
+ * (`flatMap`, `flatTap`, `flatMapErrCases`, `recoverDefect`) additionally accept an
  * `AsyncResult`. Its combinators are documented one per entry on
  * {@link AsyncResultMethods}.
  *
@@ -1396,7 +1396,7 @@ declare function fromSafeThrowable<A extends unknown[], T>(fn: (...args: A) => T
  * // when fetchUser rejects with NotFoundError: user is Err("not_found")
  * ```
  */
-declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R, ..._guard: [R] extends [never] ? [] : [R] extends [PromiseLike<unknown>] ? ["unthrown: qualify must be synchronous — its Promise would land in E un-triaged"] : []): AsyncResult$1<T, Exclude<R, Defect>>;
+declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R, ..._guard: [Extract<R, PromiseLike<unknown>>] extends [never] ? [] : ["unthrown: qualify must be synchronous — its Promise would land in E un-triaged"]): AsyncResult$1<T, Exclude<R, Defect>>;
 /**
  * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection
  * becomes a `Defect`.
@@ -1583,7 +1583,7 @@ declare const Result: {
  * alias. Its fluent combinators (`map`, `flatMap`, `match`, `get`, …) are
  * documented one per entry on {@link ResultMethods} — the shared method surface
  * every variant carries. For "which one do I reach for?", see the
- * [Choosing a combinator](/guide/choosing-a-combinator) guide.
+ * [Choosing a combinator](/reference/combinators) guide.
  *
  * @category Facade
  */
@@ -1634,7 +1634,7 @@ declare const AsyncResult: {
  * `AsyncResult` carries the async fluent surface; its combinators (`map`,
  * `flatMap`, `match`, `get`, …) are documented one per entry — with their
  * async signatures — on {@link AsyncResultMethods}. For "which one do I reach
- * for?", see the [Choosing a combinator](/guide/choosing-a-combinator) guide.
+ * for?", see the [Choosing a combinator](/reference/combinators) guide.
  *
  * @category Facade
  */
@@ -1704,7 +1704,7 @@ type TaggedErrorConstructor<Tag extends string> = {
  * *narrowing* structured field.
  *
  * `_tag` is the discriminant matched by {@link tag} in the error combinators
- * (`result.mapErr((matcher) => matcher.with(tag("NotFound"), …))`) and in
+ * (`result.mapErrCases((matcher) => matcher.with(tag("NotFound"), …))`) and in
  * `match`; `Error.name` is the human-facing label in stack traces and logs. By
  * default they coincide, but
  * they can be **decoupled** with `options.name` — so a tag can be namespaced for
@@ -1756,7 +1756,7 @@ declare function TaggedError<Tag extends string>(tag: Tag, options?: {
  *
  * @example
  * ```ts
- * result.mapErr((matcher) =>
+ * result.mapErrCases((matcher) =>
  *   matcher
  *     .with(tag("NotFound"), () => new NotFoundException())
  *     .with(tag("Conflict"), (e) => new ConflictException(e.key)),

package/dist/index.d.mts.map CHANGED Viewed

	@@ -1 +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":";;cAEM;;;;;;;;;;;;;;;KAgBM;YACA;WACD;;;;;;;;;;KCRC,SAAS,QAAQ,WAAW,IAAI,EAAE;;;;;;;;;KAUlC,MAAM,GAAG,kBAAkB,KAAK,SAAS,KAAK,GAAG,iBAAiB,KAAK,IAAI;;;;;;;;;;;;;;;;;KAkB3E,YAAY,MAAM,YAAY;;;;;;;;;;;;;;KAiB9B,WAAW,KAAK,kBAAkB,QAAM;;;;;;;;;;;KAYxC,gBAAgB;EAC1B,gBAAgB;EAChB,WAAW;;;;;;;KAQD,SAAS,KAAK,UAAU,sBAAsB,KAAK;;;;;;;;;KAUnD,YAAY,KAAK,QAAQ,SAAS,IAAI;;;;;;;;;;;;;;;;;KAkBtC,kBAAkB,OAAO;;;;;;;;;;;;EAYnC,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;EAWvD,QAAQ,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,SAAO,GAAG,IAAI;;;;;;;;;;;;;;;;;;;EAmB9D,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;;;;EAiBvD,QAAQ,IAAI,IAAI,OAAO,MAAM,kBAAgB,MAAM,SAAO,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;EAoBjE,KAAK,kBAAkB,GAAG,IACxB,MAAM,GACN,IAAI,OAAO,MAAM,SAAO,GAAG,MAC1B,SAAO,MAAM,GAAG,GAAG,IAAI,IAAI;;;;;;;;;;;;;;;;EAgB9B,IAAI,kBAAkB,GAAG,MAAM,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,MAAM,GAAG,GAAG,IAAI;;;;;;;;EAQ/F,GAAG,GAAG,OAAO,IAAI,SAAO,GAAG;;;;;;;;;EAS3B,WAAW,eAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCxB,OAAO,UAAU,GAAG,IAClB,YAAY,OAAO,MAAM,SAAS,GAClC,SAAS,OAAO,MAAM,KAAK,YAAY,MACtC,SAAO,GAAG,IAAI;;;;;EAKjB,OAAO,IACL,YAAY,OAAO,eACnB,SAAS,OAAO,MAAM,KAAK,YAAY,MACtC,SAAO,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;EAuBjB,~~OAAO~~,UAAU,~~0BACf~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,SAAO,GAAG,YAAY;;;;;;;;;;;;;EAczB,~~WAAW~~,UAAU,gBAAgB,6BAA2B,~~SAC9D~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,SAAO,IAAI,KAAK,SAAS,KAAK,MAAM,SAAS;;;;;;;;;;;;;;;EAgBhD,~~WAAW~~,UAAU,~~0BACnB~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,SAAO,IAAI,YAAY;;;;;;;;;;;;;;;;;;;EAoB1B,~~OAAO~~,~~GACL~~,IACE,SAAS,WAAW,IACpB,SAAS,mBAAmB,WACzB,gBAAgB,IAAI,YAAY,MACpC,SAAO,GAAG;;;;;;;;;;;;;;;;;;;EAoBb,~~WAAW~~,~~IACT~~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~~OAAO~~,UAAU,~~0BACf~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,cAAY,GAAG,YAAY;;;;;;EAO9B,~~WACE~~,UAAU,gBAAgB,6BAA2B,kCAAgC,SAErF,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,cACD,IAAI,KAAK,SAAS,MAAM,UAAU,SAAS,KAC3C,MAAM,SAAS,MAAM,WAAW,SAAS;;;;;;EAQ3C,~~WAAW~~,UAAU,~~0BACnB~~,IAAI,SAAS,WAAW,IAAI,SAAS,mBAAmB,WAAW,IAClE,cAAY,IAAI,YAAY;;;;;;;;;;;;EAa/B,~~OAAO~~,~~GACL~~,IACE,SAAS,WAAW,IACpB,SAAS,mBAAmB,WACzB,gBAAgB,IAAI,YAAY,MACpC,cAAY,GAAG;;;;;;;;;EAUlB,~~WAAW~~,~~IACT~~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~~MAO9D~~,SAAS,~~2BAEP~~,~~YAAY~~,~~kHAGhB~~,cAAY,GAAG,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCb,gBAAgB,GAC9B,SAAS,QAAQ,YAAY,QAAQ,MACpC,cAAY;;;;;;;;;;;;;;;;;;KAsEV,MACH,+BACA,gDACiB,eAAe,eAAe;;KAG5C,eAAe,eAAe;;KAE9B,oBAAoB,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAwFxB,IAAI,oBAAoB,8BACtC,sBAAsB,MACrB,SAAO,MAAM,OAAO,WAAW,KAAK,KAAK,GAAG,SAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;iBA2B7C,YAAY,UAAU,cACpC,SAAS,IACR,YAAU,WAAW,IAAI,KAAK,EAAE,QAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;iBA2BxC,SAAS,oBAAoB,mCAC3C,sBAAsB,MACrB,cAAY,MAAM,OAAO,WAAW,KAAK,UAAU,GAAG,SAAQ,WAAW;;;;;;;;;;;;;;;;;;;;;;iBAyC5D,iBAAiB,UAAU,mBACzC,SAAS,IACR,iBAAe,WAAW,IAAI,UAAU,EAAE,QAAO,WAAW,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~cCtd1D~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCD,OAAO,GAAG,KAAK,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8B5B;;;;;;;;;;;;;;;;;;;;;;KAyBD,YAAY,GAAG,KAAK,cAAgB,GAAG;;;KCpI9C,QAAQ;;;;;;;;;;KAWD,oBAAoB,oBAAoB,UAAU,SAAS,QACrE,SAAS,KAAK;WAA+C,MAAM;;;;;;;;;;;;;;;;;;;;;;KAsBzD,uBAAuB;OAC5B,UAAU,YACb,YAAY,yBAER;aAAe;aAAuB;aAA0B;MACnE,oBAAoB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Dd,YAAY,oBAC1B,KAAK,KACL;WAAqB;IACpB,uBAAuB;;;;;;;;;;;;;;;;;;;;;iBA8DV,UAAU,oBAAoB,OAAO;EAAQ,MAAM"}
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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"}

package/dist/index.mjs CHANGED Viewed

@@ -151,7 +151,7 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
-	mapErr(f) {
+	mapErrCases(f) {
 		if (this.tag !== "Err") return passThrough(this);
 		try {
 			const out = runMatch(f, this.error);
@@ -161,7 +161,7 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
-	flatMapErr(f) {
+	flatMapErrCases(f) {
 		if (this.tag !== "Err") return passThrough(this);
 		try {
 			const out = runMatch(f, this.error);
@@ -172,7 +172,7 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
-	recoverErr(f) {
+	recoverErrCases(f) {
 		if (this.tag !== "Err") return passThrough(this);
 		try {
 			const out = runMatch(f, this.error);
@@ -182,7 +182,7 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
-	tapErr(f) {
+	tapErrCases(f) {
 		if (this.tag !== "Err") return this;
 		try {
 			runMatch(f, this.error);
@@ -191,7 +191,7 @@ var Res = class {
 			return observerThrowToDefect(cause, this.error);
 		}
 	}
-	flatTapErr(f) {
+	flatTapErrCases(f) {
 		if (this.tag !== "Err") return this;
 		try {
 			const r = runMatch(f, this.error);
@@ -409,7 +409,7 @@ function runMatch(f, error) {
 	return f(match$1(error), defect).run();
 }
 /**
-* A throw inside a *failure observer* (`tapErr` / `tapDefect` / `flatTapErr`)
+* A throw inside a *failure observer* (`tapErrCases` / `tapDefect` / `flatTapErrCases`)
 * must not destroy the failure being observed — that is the exact place (e.g. a
 * failing error-logger) where losing the underlying failure hurts most. The
 * resulting Defect aggregates both: `errors[0]` is the observer's throw,
@@ -546,7 +546,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	mapErr(f) {
+	mapErrCases(f) {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
@@ -558,7 +558,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	flatMapErr(f) {
+	flatMapErrCases(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
@@ -572,7 +572,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	recoverErr(f) {
+	recoverErrCases(f) {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
@@ -584,7 +584,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	tapErr(f) {
+	tapErrCases(f) {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Err") return r;
 			try {
@@ -595,7 +595,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	flatTapErr(f) {
+	flatTapErrCases(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
@@ -1341,7 +1341,7 @@ const AsyncResult = {
 * *narrowing* structured field.
 *
 * `_tag` is the discriminant matched by {@link tag} in the error combinators
-* (`result.mapErr((matcher) => matcher.with(tag("NotFound"), …))`) and in
+* (`result.mapErrCases((matcher) => matcher.with(tag("NotFound"), …))`) and in
 * `match`; `Error.name` is the human-facing label in stack traces and logs. By
 * default they coincide, but
 * they can be **decoupled** with `options.name` — so a tag can be namespaced for
@@ -1415,7 +1415,7 @@ function TaggedError(tag, options) {
 *
 * @example
 * ```ts
-* result.mapErr((matcher) =>
+* result.mapErrCases((matcher) =>
 *   matcher
 *     .with(tag("NotFound"), () => new NotFoundException())
 *     .with(tag("Conflict"), (e) => new ConflictException(e.key)),

package/dist/index.mjs.map CHANGED Viewed

	@@ -1 +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 mapErr<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 flatMapErr<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 recoverErr<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 tapErr(\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 flatTapErr<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 (`tapErr` / `tapDefect` / `flatTapErr`)\n * must not destroy the failure being observed — that is the exact place (e.g. a\n * failing error-logger) where losing the underlying failure hurts most. The\n * resulting Defect aggregates both: `errors[0]` is the observer's throw,\n * `errors[1]` the original failure.\n \n @internal\n /\nfunction observerThrowToDefect<T, E>(thrown: unknown, original: unknown): Result<T, E> {\n return defectRes(\n new AggregateError(\n [thrown, original],\n \"unthrown: a failure-observer callback threw; errors[0] is the callback's throw, errors[1] the original failure\",\n ),\n );\n}\n\n/\n Validate that a `bind`/`let` scope is a real (non-null) object before merging a\n * key into it.\n \n @remarks\n * Do-notation accumulates an object scope: a chain starts at `Do()` (an\n * empty object) and every `bind`/`let` returns an object, so in typed code the\n * scope is always an object. The method lives on the general `Result` surface,\n * though, so a primitive `Ok` (e.g. `Ok(5).bind(...)`, or a chain whose value was\n * `map`-ped away from its scope) could reach it. Rather than let `{ ...5 }`\n * silently collapse to `{}` and drop the prior scope, we throw here — the\n * surrounding `try` turns it into a `Defect`, surfacing the misuse as the\n * bug it is (a defect is a bug, not an absent value). A `this: object` constraint\n * was rejected: TypeScript does not hard-enforce a constraint inferred solely\n * from `this`, and it breaks `AsyncRes implements AsyncResult`.\n \n @internal\n /\nfunction scopeOf(value: unknown): object {\n if (typeof value !== \"object\" \|\| value === null \|\| Array.isArray(value)) {\n throw new TypeError(\"bind/let requires an object scope — start a do-chain with Do()\");\n }\n return value;\n}\n\n/\n The sole runtime implementation of {@link AsyncResult}: wraps a\n * `Promise<Result>` constructed never to reject. Operates on the public `Result`\n * union (via `tag`), never on `Res` internals. Never re-exported from `index.ts`.\n \n @internal\n /\nexport class AsyncRes<T, E> implements AsyncResult<T, E> {\n // 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 mapErr(\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 flatMapErr(\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 recoverErr(\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 tapErr(\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 flatTapErr(\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 ..._guard: [R] extends [never]\n ? [] // a qualify that always throws returns `never` — legal (the throw is a Defect)\n : [R] extends [PromiseLike<unknown>]\n ? [\"unthrown: qualify must be synchronous — its Promise would land in E un-triaged\"]\n : []\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](/guide/choosing-a-combinator) guide.\n \n @category Facade\n /\n// Re-alias the Result type into this module so a single `export { Result }`\n// (from index.ts) carries BOTH the companion object above and the type — value\n// and type sharing one name, declaration-merged in one place.\nexport type Result<T, E> = ResultType<T, E>;\n\n/\n Companion object grouping the `AsyncResult`-producing entry points under\n * the matching namespace: {@link AsyncResult.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](/guide/choosing-a-combinator) guide.\n \n @category Facade\n /\n// Re-alias the AsyncResult type into this module (same companion-object pattern\n// as Result above) so one `export { AsyncResult }` carries value + type.\nexport type AsyncResult<T, E> = AsyncResultType<T, E>;\n","// The TaggedError convention (à la Effect's `Data.TaggedError`) and 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.mapErr((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.mapErr((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":"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"}
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":"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"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "unthrown",
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.4",
   "description": "Explicit errors as values, with a separate defect (panic) channel",
   "keywords": [
     "defect",