npm - unthrown - Versions diffs - 4.2.0 → 4.3.0 - Mend

unthrown 4.2.0 → 4.3.0

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

@@ -177,6 +177,15 @@ var Res = class {
 			return observerThrowToDefect(cause, this.cause);
 		}
 	}
+	tapFailure(f) {
+		if (this.tag === "Ok") return this;
+		try {
+			f(this);
+			return this;
+		} catch (cause) {
+			return observerThrowToDefect(cause, this.tag === "Err" ? this.error : this.cause);
+		}
+	}
 	match(cases) {
 		switch (this.tag) {
 			case "Ok": return cases.ok(this.value);
@@ -533,6 +542,17 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
+	tapFailure(f) {
+		return new AsyncRes(this.promise.then((r) => {
+			if (r.tag === "Ok") return r;
+			try {
+				f(r);
+				return r;
+			} catch (cause) {
+				return observerThrowToDefect(cause, r.tag === "Err" ? r.error : r.cause);
+			}
+		}));
+	}
 	match(cases) {
 		return this.promise.then((r) => r.match(cases));
 	}

package/dist/index.d.cts CHANGED Viewed

@@ -283,6 +283,31 @@ type ResultMethods<T, E> = {
    * @param f - the side effect over the unknown cause.
    */
   tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): Result$1<T, 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
+   * {@link ResultMethods.tapDefect | tapDefect}.
+   *
+   * @remarks
+   * `f` receives the narrowed **failure variant** ({@link FailureView}), not a
+   * payload — the payload union `E | unknown` would collapse to `unknown` and
+   * lose `E`'s typing. Branch on `failure.tag` to reach the typed payload
+   * (`"Err"` → `failure.error: E`, `"Defect"` → `failure.cause: unknown`), or
+   * 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.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,
+   * original failure]` — observing a failure never destroys it. An async
+   * callback is rejected at compile time ({@link NotThenable}).
+   *
+   * @param f - the side effect over the failure variant (its return value is ignored).
+   */
+  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): Result$1<T, E>;
   /**
    * Exhaustively fold all three runtime states into a single value of type `R`.
    *
@@ -484,6 +509,30 @@ type DefectView<T = never, E = never> = ResultMethods<T, E> & {
   readonly tag: "Defect";
   readonly cause: unknown;
 };
+/**
+ * A failure variant of a {@link Result}: an {@link ErrView} **or** a
+ * {@link DefectView}. This is what a `tapFailure` callback receives — the
+ * discriminated variant rather than a payload, because the payload union
+ * `E | unknown` would collapse to `unknown` and lose `E`'s typing. Branch on
+ * `tag` to narrow (`"Err"` → `.error: E`, `"Defect"` → `.cause: unknown`).
+ *
+ * @remarks
+ * Like {@link ErrView}, the error type comes **first** (`FailureView<E, T>`) —
+ * the error is the payload you are usually here for, and a shared observer can
+ * spell just `FailureView<MyError>`.
+ *
+ * @example
+ * ```ts
+ * const logKo = (f: FailureView<ApiError>) =>
+ *   f.tag === "Err" ? logger.warn(f.error) : logger.error(f.cause);
+ * result.tapFailure(logKo);
+ * ```
+ *
+ * @typeParam E - the modeled error type.
+ * @typeParam T - the success value type (phantom here; a failure carries none).
+ * @category Types
+ */
+type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
 /**
  * The core type of the library: a computation that has either succeeded with a
  * value of type `T` or failed with a *modeled* error of type `E`.
@@ -668,6 +717,15 @@ type AsyncResultMethods<T, E> = {
    * callback is rejected at compile time ({@link NotThenable}).
    */
   tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): AsyncResult$1<T, E>;
+  /**
+   * Asynchronous {@link ResultMethods.tapFailure | tapFailure} — the
+   * cross-channel observer. `f` receives the narrowed failure variant
+   * ({@link FailureView}); 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 callback is rejected at compile time
+   * ({@link NotThenable}).
+   */
+  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): AsyncResult$1<T, E>;
   /**
    * Asynchronous {@link ResultMethods.match | match}. Handlers are synchronous;
    * resolves to a `Promise<R>`.
@@ -1659,5 +1717,5 @@ declare function matchTags<T, E extends {
   _tag: string;
 }, R>(result: AsyncResult$1<T, E>, handlers: TagHandlers<T, E, R> & ([Extract<E["_tag"], "Ok" | "Defect">] extends [never] ? unknown : ReservedTagError)): Promise<R>;
 //#endregion
-export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, Err, ErrAsync, type ErrOf, type ErrView, type NotThenable, Ok, OkAsync, type OkOf, type OkView, Result, type ResultMethods, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, matchTags };
+export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, Err, ErrAsync, type ErrOf, type ErrView, type FailureView, type NotThenable, Ok, OkAsync, type OkOf, type OkView, Result, type ResultMethods, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, matchTags };
 //# sourceMappingURL=index.d.cts.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":";;;;;;;KAQY,SAAS,QAAQ,WAAW,IAAI,EAAE;;;;;;;;;KAUlC,MAAM,GAAG,kBAAkB,KAAK,SAAS,KAAK,GAAG,iBAAiB,KAAK,IAAI;;;;;;;;;;;;;;;;;KAkB3E,YAAY,MAAM,YAAY;;;;;;;;;;;;;;;;;KAoB9B,cAAc,GAAG;;;;;;;;;;;;EAY3B,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;;;;;;;;;;;EAYxB,OAAO,IAAI,IAAI,OAAO,MAAM,KAAK,YAAY,MAAM,SAAO,GAAG;;;;;;;;;;;;EAY7D,WAAW,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG;;;;;;;;;;;;EAYjE,OAAO,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG;;;;;;;;;;;;;;;EAe7D,WAAW,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,IAAI;;;;;;;;;;;EAW/D,QAAQ,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,IAAI;;;;;;;;;;;;;;;;;;;EAmB5D,OAAO,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;;;;;EAkB1D,WAAW,IAAI,IAAI,OAAO,MAAM,kBAAgB,MAAM,SAAO,GAAG,IAAI;;;;;;;;;;;;;;EAepE,cAAc,GAAG,IAAI,IAAI,mBAAmB,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG,IAAI;;;;;;;;;;EAU9E,UAAU,GAAG,IAAI,mBAAmB,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;~~EAenE~~,MAAM,GAAG;IAAS,KAAK,OAAO,MAAM;IAAG,MAAM,OAAO,MAAM;IAAG,SAAS,mBAAmB;MAAM;;;;;;;;;;;;;;;;;EAiB/F,IAAI,MAAM,SAAO,YAAY;;;;;;;;;EAS7B,OAAO,MAAM,SAAO,YAAY;;;;;;;;;;;;;;EAchC,OAAO,MAAM,gBAAc,KAAK;;;;;;;;;EAShC,UAAU,MAAM,gBAAc,KAAK;;;;;;;;;EASnC,MAAM,GAAG,UAAU,IAAI,IAAI;;;;;;;;;;;EAW3B,SAAS,GAAG,UAAU,IAAI,IAAI;;;;;;;;EAQ9B,UAAU,GAAG,IAAI,OAAO,MAAM,IAAI,IAAI;;;;;;;;;;;EAWtC,aAAa,GAAG,IAAI,OAAO,MAAM,IAAI,IAAI;;;;;;EAMzC,aAAa;;;;;;EAMb,kBAAkB;;;;;;;;;;;;;;;;;;EAkBlB,cAAc;;EAGd,gBAAgB,OAAO,GAAG;;EAE1B,iBAAiB,QAAQ,GAAG;;EAE5B,oBAAoB,WAAW,GAAG;;EAGlC,WAAW,cAAY,GAAG;;;;;;;;;;;;;;KAehB,OAAO,GAAG,aAAa,cAAc,GAAG;WACzC;WACA,OAAO;;;;;;;;;;;;;;;;;;;;;;KAsBN,QAAQ,GAAG,aAAa,cAAc,GAAG;WAC1C;WACA,OAAO;;;;;;;;;;;;;;KAcN,WAAW,WAAW,aAAa,cAAc,GAAG;WACrD;WACA~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwCC~~,SAAO,GAAG,KAAK,OAAO,GAAG,KAAK,QAAQ,GAAG,KAAK,WAAW,GAAG;;;;;;;;;;;;;;;;;;;KAoB5D,UAAU;EACpB,KAAK,IAAI,GAAG,gBAAgB,OAAO,MAAM,IAAI,YAAY,aAAa,YAAY;;;;;;;;;;;;;;;;;;;;;;KAuBxE,mBAAmB,GAAG;;;;;;EAMhC,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;EAM5D,QAAQ,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,GAAG,IAAI;;;;;;;;;;;EAWxF,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;;EAO5D,QAAQ,IACN,IAAI,OAAO,MAAM,kBAAgB,MAAM,uBAAqB,MAC3D,cAAY,GAAG,IAAI;;;;;;EAMtB,KAAK,kBAAkB,GAAG,IACxB,MAAM,GACN,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAC/C,cAAY,MAAM,GAAG,GAAG,IAAI,IAAI;;;;;;EAMnC,IAAI,kBAAkB,GACpB,MAAM,GACN,IAAI,OAAO,MAAM,IAAI,YAAY,KAChC,cAAY,MAAM,GAAG,GAAG,IAAI;;EAE/B,GAAG,GAAG,OAAO,IAAI,cAAY,GAAG;;EAEhC,WAAW,oBAAkB;;;;;;EAO7B,OAAO,IAAI,IAAI,OAAO,MAAM,KAAK,YAAY,MAAM,cAAY,GAAG;;;;;EAKlE,WAAW,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,IAAI,GAAG;;;;;EAK3F,OAAO,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,IAAI,GAAG;;;;;;EAMvF,WAAW,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,IAAI;;;;;EAKpE,QAAQ,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,IAAI;;;;;;;;;;EAUjE,OAAO,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;;;;EAS/D,WAAW,IACT,IAAI,OAAO,MAAM,kBAAgB,MAAM,uBAAqB,MAC3D,cAAY,GAAG,IAAI;;;;;EAMtB,cAAc,GAAG,IACf,IAAI,mBAAmB,SAAO,GAAG,MAAM,cAAY,GAAG,MACrD,cAAY,IAAI,GAAG,IAAI;;;;;;;EAO1B,UAAU,GAAG,IAAI,mBAAmB,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;~~EAMxE~~,MAAM,GAAG;IACP,KAAK,OAAO,MAAM;IAClB,MAAM,OAAO,MAAM;IACnB,SAAS,mBAAmB;MAC1B,QAAQ;;;;;;EAMZ,IAAI,MAAM,cAAY,YAAY,QAAQ;;;;;EAK1C,OAAO,MAAM,cAAY,YAAY,QAAQ;;;;;;EAM7C,OAAO,MAAM,qBAAmB,KAAK,QAAQ;;;;;EAK7C,UAAU,MAAM,qBAAmB,KAAK,QAAQ;;EAEhD,MAAM,GAAG,UAAU,IAAI,QAAQ,IAAI;;;;;EAKnC,SAAS,GAAG,UAAU,IAAI,QAAQ,IAAI;;EAEtC,UAAU,GAAG,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI;;;;;EAK9C,aAAa,GAAG,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI;;EAEjD,aAAa,QAAQ;;EAErB,kBAAkB,QAAQ;;;;;;EAM1B,cAAc,QAAQ;;;;;;;;;;;;;;;;;;;;;;;KAwBZ,cAAY,GAAG,KAAK,UAAU,SAAO,GAAG,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;KAiBpE,KAAK,KAAK;WAAqB;WAAoB,aAAa;IAAM;;;;;;;;;;;;;;KActE,MAAM,KAAK;WAAqB;WAAqB,aAAa;IAAM;;;;;;;;;;;;;;KAcxE,UAAU,KAAK,UAAU,oBAAkB,cAAc;;;;;;;;;;;;;;KAczD,WAAW,KAAK,UAAU,6BAA2B,KAAK;;;;;;;;;;;;;;;;;~~iBCjzBtD~~,MAAM;;;;;;;;;;;;;;;;;iBAiBN,GAAG,GAAG,OAAO,IAAI,SAAO;;;;;;;;;;;;;;;;;iBAwBxB,IAAI,GAAG,OAAO,IAAI,gBAAc;;;;;;;;;;;;;;;iBAkBhC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BX,QAAQ,GAAG,OAAO,IAAI,cAAY;;;;;;;;;;;;;;;;;;;;;iBA2BlC,SAAS,GAAG,OAAO,IAAI,qBAAmB;;;;;;;;;;;;;;;;;;;iBAsB1C,KAAK,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,OAAO,GAAG;;;;;;;;;;;;;;;;;;;iBAqB5C,MAAM,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4B9C,SAAS,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;~~cC1JvD~~,YAAY,qBAAqB;;;;;WAKnC,OAAO;cACJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~iBA4WL~~,SAAS,aAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~iBCpX3B~~,MAAM;;;cC7ChB;;;;;;;;;;;;;;;KAgBM;YACA;WACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCcK,aAAa,GAAG,GAC9B,OAAO,sBACP,gBAAgB,IACf,SAAO,YAAY,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CV,cAAc,qBAAqB,GAAG,GACpD,QAAQ,MAAM,MAAM,GACpB,UAAU,gBAAgB,SAAS,mBAAmB,WAAW,QAC5D,MAAM,MAAM,SAAO,GAAG,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCxB,kBAAkB,qBAAqB,GACrD,QAAQ,MAAM,MAAM,QACf,MAAM,MAAM,SAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CV,YAAY,GAAG,GAC7B,SAAS,QAAQ,YAAY,QAAQ,KACrC,UAAU,gBAAgB,SAAS,mBAAmB,WAAW,IAChE,cAAY,GAAG,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCb,gBAAgB,GAC9B,SAAS,QAAQ,YAAY,QAAQ,MACpC,cAAY;;;;;;;;;;;;;;;;;;KA0CV,MACH,+BACA,gDACiB,eAAe,eAAe;;KAG5C,eAAe,eAAe;;KAE9B,oBAAoB,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAuExB,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;;;;;;;;;;;;;;;;;;;;;;iBAiC5D,iBAAiB,UAAU,mBACzC,SAAS,IACR,iBAAe,WAAW,IAAI,UAAU,EAAE,QAAO,WAAW,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCnY1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCD,OAAO,GAAG,KAAK,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4B5B;;;;;;;;;;;;;;;;;;;;;KAwBD,YAAY,GAAG,KAAK,cAAgB,GAAG;;;KC/H9C,QAAQ;;;;;;;;;;KAWD,oBAAoB,oBAAoB,UAAU,SAAS,QACrE,SAAS,KAAK;WAAqC,MAAM;;;;;;;;;;;;;;;;;;;;KAoB/C,uBAAuB;OAC5B,UAAU,YACb,YAAY,yBAAyB;aAAe;aAAuB;MAC1E,oBAAoB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDd,YAAY,oBAC1B,KAAK,KACL;WAAqB;IACpB,uBAAuB;;;;;;;;;;;;KAkCd,YAAY,GAAG;EAAY;GAAgB;EACrD,KAAK,OAAO,MAAM;EAClB,SAAS,mBAAmB;OACvB,KAAK,aAAa,OAAO,QAAQ;EAAK,MAAM;OAAS;;;;;;;;KASvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CW,UAAU,GAAG;EAAY;GAAgB,GACvD,QAAQ,SAAO,GAAG,IAClB,UAAU,YAAY,GAAG,GAAG,OACxB,QAAQ,yDAAyD,oBACpE;iBACa,UAAU,GAAG;EAAY;GAAgB,GACvD,QAAQ,cAAY,GAAG,IACvB,UAAU,YAAY,GAAG,GAAG,OACxB,QAAQ,yDAAyD,oBACpE,QAAQ"}
1	+ {"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}

package/dist/index.d.mts CHANGED Viewed

@@ -283,6 +283,31 @@ type ResultMethods<T, E> = {
    * @param f - the side effect over the unknown cause.
    */
   tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): Result$1<T, 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
+   * {@link ResultMethods.tapDefect | tapDefect}.
+   *
+   * @remarks
+   * `f` receives the narrowed **failure variant** ({@link FailureView}), not a
+   * payload — the payload union `E | unknown` would collapse to `unknown` and
+   * lose `E`'s typing. Branch on `failure.tag` to reach the typed payload
+   * (`"Err"` → `failure.error: E`, `"Defect"` → `failure.cause: unknown`), or
+   * 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.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,
+   * original failure]` — observing a failure never destroys it. An async
+   * callback is rejected at compile time ({@link NotThenable}).
+   *
+   * @param f - the side effect over the failure variant (its return value is ignored).
+   */
+  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): Result$1<T, E>;
   /**
    * Exhaustively fold all three runtime states into a single value of type `R`.
    *
@@ -484,6 +509,30 @@ type DefectView<T = never, E = never> = ResultMethods<T, E> & {
   readonly tag: "Defect";
   readonly cause: unknown;
 };
+/**
+ * A failure variant of a {@link Result}: an {@link ErrView} **or** a
+ * {@link DefectView}. This is what a `tapFailure` callback receives — the
+ * discriminated variant rather than a payload, because the payload union
+ * `E | unknown` would collapse to `unknown` and lose `E`'s typing. Branch on
+ * `tag` to narrow (`"Err"` → `.error: E`, `"Defect"` → `.cause: unknown`).
+ *
+ * @remarks
+ * Like {@link ErrView}, the error type comes **first** (`FailureView<E, T>`) —
+ * the error is the payload you are usually here for, and a shared observer can
+ * spell just `FailureView<MyError>`.
+ *
+ * @example
+ * ```ts
+ * const logKo = (f: FailureView<ApiError>) =>
+ *   f.tag === "Err" ? logger.warn(f.error) : logger.error(f.cause);
+ * result.tapFailure(logKo);
+ * ```
+ *
+ * @typeParam E - the modeled error type.
+ * @typeParam T - the success value type (phantom here; a failure carries none).
+ * @category Types
+ */
+type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
 /**
  * The core type of the library: a computation that has either succeeded with a
  * value of type `T` or failed with a *modeled* error of type `E`.
@@ -668,6 +717,15 @@ type AsyncResultMethods<T, E> = {
    * callback is rejected at compile time ({@link NotThenable}).
    */
   tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): AsyncResult$1<T, E>;
+  /**
+   * Asynchronous {@link ResultMethods.tapFailure | tapFailure} — the
+   * cross-channel observer. `f` receives the narrowed failure variant
+   * ({@link FailureView}); 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 callback is rejected at compile time
+   * ({@link NotThenable}).
+   */
+  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): AsyncResult$1<T, E>;
   /**
    * Asynchronous {@link ResultMethods.match | match}. Handlers are synchronous;
    * resolves to a `Promise<R>`.
@@ -1659,5 +1717,5 @@ declare function matchTags<T, E extends {
   _tag: string;
 }, R>(result: AsyncResult$1<T, E>, handlers: TagHandlers<T, E, R> & ([Extract<E["_tag"], "Ok" | "Defect">] extends [never] ? unknown : ReservedTagError)): Promise<R>;
 //#endregion
-export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, Err, ErrAsync, type ErrOf, type ErrView, type NotThenable, Ok, OkAsync, type OkOf, type OkView, Result, type ResultMethods, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, matchTags };
+export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, Err, ErrAsync, type ErrOf, type ErrView, type FailureView, type NotThenable, Ok, OkAsync, type OkOf, type OkView, Result, type ResultMethods, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, matchTags };
 //# sourceMappingURL=index.d.mts.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":";;;;;;;KAQY,SAAS,QAAQ,WAAW,IAAI,EAAE;;;;;;;;;KAUlC,MAAM,GAAG,kBAAkB,KAAK,SAAS,KAAK,GAAG,iBAAiB,KAAK,IAAI;;;;;;;;;;;;;;;;;KAkB3E,YAAY,MAAM,YAAY;;;;;;;;;;;;;;;;;KAoB9B,cAAc,GAAG;;;;;;;;;;;;EAY3B,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;;;;;;;;;;;EAYxB,OAAO,IAAI,IAAI,OAAO,MAAM,KAAK,YAAY,MAAM,SAAO,GAAG;;;;;;;;;;;;EAY7D,WAAW,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG;;;;;;;;;;;;EAYjE,OAAO,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG;;;;;;;;;;;;;;;EAe7D,WAAW,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,IAAI;;;;;;;;;;;EAW/D,QAAQ,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,IAAI;;;;;;;;;;;;;;;;;;;EAmB5D,OAAO,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;;;;;EAkB1D,WAAW,IAAI,IAAI,OAAO,MAAM,kBAAgB,MAAM,SAAO,GAAG,IAAI;;;;;;;;;;;;;;EAepE,cAAc,GAAG,IAAI,IAAI,mBAAmB,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG,IAAI;;;;;;;;;;EAU9E,UAAU,GAAG,IAAI,mBAAmB,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;~~EAenE~~,MAAM,GAAG;IAAS,KAAK,OAAO,MAAM;IAAG,MAAM,OAAO,MAAM;IAAG,SAAS,mBAAmB;MAAM;;;;;;;;;;;;;;;;;EAiB/F,IAAI,MAAM,SAAO,YAAY;;;;;;;;;EAS7B,OAAO,MAAM,SAAO,YAAY;;;;;;;;;;;;;;EAchC,OAAO,MAAM,gBAAc,KAAK;;;;;;;;;EAShC,UAAU,MAAM,gBAAc,KAAK;;;;;;;;;EASnC,MAAM,GAAG,UAAU,IAAI,IAAI;;;;;;;;;;;EAW3B,SAAS,GAAG,UAAU,IAAI,IAAI;;;;;;;;EAQ9B,UAAU,GAAG,IAAI,OAAO,MAAM,IAAI,IAAI;;;;;;;;;;;EAWtC,aAAa,GAAG,IAAI,OAAO,MAAM,IAAI,IAAI;;;;;;EAMzC,aAAa;;;;;;EAMb,kBAAkB;;;;;;;;;;;;;;;;;;EAkBlB,cAAc;;EAGd,gBAAgB,OAAO,GAAG;;EAE1B,iBAAiB,QAAQ,GAAG;;EAE5B,oBAAoB,WAAW,GAAG;;EAGlC,WAAW,cAAY,GAAG;;;;;;;;;;;;;;KAehB,OAAO,GAAG,aAAa,cAAc,GAAG;WACzC;WACA,OAAO;;;;;;;;;;;;;;;;;;;;;;KAsBN,QAAQ,GAAG,aAAa,cAAc,GAAG;WAC1C;WACA,OAAO;;;;;;;;;;;;;;KAcN,WAAW,WAAW,aAAa,cAAc,GAAG;WACrD;WACA~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwCC~~,SAAO,GAAG,KAAK,OAAO,GAAG,KAAK,QAAQ,GAAG,KAAK,WAAW,GAAG;;;;;;;;;;;;;;;;;;;KAoB5D,UAAU;EACpB,KAAK,IAAI,GAAG,gBAAgB,OAAO,MAAM,IAAI,YAAY,aAAa,YAAY;;;;;;;;;;;;;;;;;;;;;;KAuBxE,mBAAmB,GAAG;;;;;;EAMhC,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;EAM5D,QAAQ,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,GAAG,IAAI;;;;;;;;;;;EAWxF,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;;EAO5D,QAAQ,IACN,IAAI,OAAO,MAAM,kBAAgB,MAAM,uBAAqB,MAC3D,cAAY,GAAG,IAAI;;;;;;EAMtB,KAAK,kBAAkB,GAAG,IACxB,MAAM,GACN,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAC/C,cAAY,MAAM,GAAG,GAAG,IAAI,IAAI;;;;;;EAMnC,IAAI,kBAAkB,GACpB,MAAM,GACN,IAAI,OAAO,MAAM,IAAI,YAAY,KAChC,cAAY,MAAM,GAAG,GAAG,IAAI;;EAE/B,GAAG,GAAG,OAAO,IAAI,cAAY,GAAG;;EAEhC,WAAW,oBAAkB;;;;;;EAO7B,OAAO,IAAI,IAAI,OAAO,MAAM,KAAK,YAAY,MAAM,cAAY,GAAG;;;;;EAKlE,WAAW,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,IAAI,GAAG;;;;;EAK3F,OAAO,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,IAAI,GAAG;;;;;;EAMvF,WAAW,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,IAAI;;;;;EAKpE,QAAQ,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,IAAI;;;;;;;;;;EAUjE,OAAO,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;;;;EAS/D,WAAW,IACT,IAAI,OAAO,MAAM,kBAAgB,MAAM,uBAAqB,MAC3D,cAAY,GAAG,IAAI;;;;;EAMtB,cAAc,GAAG,IACf,IAAI,mBAAmB,SAAO,GAAG,MAAM,cAAY,GAAG,MACrD,cAAY,IAAI,GAAG,IAAI;;;;;;;EAO1B,UAAU,GAAG,IAAI,mBAAmB,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;~~EAMxE~~,MAAM,GAAG;IACP,KAAK,OAAO,MAAM;IAClB,MAAM,OAAO,MAAM;IACnB,SAAS,mBAAmB;MAC1B,QAAQ;;;;;;EAMZ,IAAI,MAAM,cAAY,YAAY,QAAQ;;;;;EAK1C,OAAO,MAAM,cAAY,YAAY,QAAQ;;;;;;EAM7C,OAAO,MAAM,qBAAmB,KAAK,QAAQ;;;;;EAK7C,UAAU,MAAM,qBAAmB,KAAK,QAAQ;;EAEhD,MAAM,GAAG,UAAU,IAAI,QAAQ,IAAI;;;;;EAKnC,SAAS,GAAG,UAAU,IAAI,QAAQ,IAAI;;EAEtC,UAAU,GAAG,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI;;;;;EAK9C,aAAa,GAAG,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI;;EAEjD,aAAa,QAAQ;;EAErB,kBAAkB,QAAQ;;;;;;EAM1B,cAAc,QAAQ;;;;;;;;;;;;;;;;;;;;;;;KAwBZ,cAAY,GAAG,KAAK,UAAU,SAAO,GAAG,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;KAiBpE,KAAK,KAAK;WAAqB;WAAoB,aAAa;IAAM;;;;;;;;;;;;;;KActE,MAAM,KAAK;WAAqB;WAAqB,aAAa;IAAM;;;;;;;;;;;;;;KAcxE,UAAU,KAAK,UAAU,oBAAkB,cAAc;;;;;;;;;;;;;;KAczD,WAAW,KAAK,UAAU,6BAA2B,KAAK;;;;;;;;;;;;;;;;;~~iBCjzBtD~~,MAAM;;;;;;;;;;;;;;;;;iBAiBN,GAAG,GAAG,OAAO,IAAI,SAAO;;;;;;;;;;;;;;;;;iBAwBxB,IAAI,GAAG,OAAO,IAAI,gBAAc;;;;;;;;;;;;;;;iBAkBhC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BX,QAAQ,GAAG,OAAO,IAAI,cAAY;;;;;;;;;;;;;;;;;;;;;iBA2BlC,SAAS,GAAG,OAAO,IAAI,qBAAmB;;;;;;;;;;;;;;;;;;;iBAsB1C,KAAK,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,OAAO,GAAG;;;;;;;;;;;;;;;;;;;iBAqB5C,MAAM,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4B9C,SAAS,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;~~cC1JvD~~,YAAY,qBAAqB;;;;;WAKnC,OAAO;cACJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~iBA4WL~~,SAAS,aAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~iBCpX3B~~,MAAM;;;cC7ChB;;;;;;;;;;;;;;;KAgBM;YACA;WACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCcK,aAAa,GAAG,GAC9B,OAAO,sBACP,gBAAgB,IACf,SAAO,YAAY,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CV,cAAc,qBAAqB,GAAG,GACpD,QAAQ,MAAM,MAAM,GACpB,UAAU,gBAAgB,SAAS,mBAAmB,WAAW,QAC5D,MAAM,MAAM,SAAO,GAAG,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCxB,kBAAkB,qBAAqB,GACrD,QAAQ,MAAM,MAAM,QACf,MAAM,MAAM,SAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CV,YAAY,GAAG,GAC7B,SAAS,QAAQ,YAAY,QAAQ,KACrC,UAAU,gBAAgB,SAAS,mBAAmB,WAAW,IAChE,cAAY,GAAG,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCb,gBAAgB,GAC9B,SAAS,QAAQ,YAAY,QAAQ,MACpC,cAAY;;;;;;;;;;;;;;;;;;KA0CV,MACH,+BACA,gDACiB,eAAe,eAAe;;KAG5C,eAAe,eAAe;;KAE9B,oBAAoB,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAuExB,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;;;;;;;;;;;;;;;;;;;;;;iBAiC5D,iBAAiB,UAAU,mBACzC,SAAS,IACR,iBAAe,WAAW,IAAI,UAAU,EAAE,QAAO,WAAW,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCnY1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCD,OAAO,GAAG,KAAK,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4B5B;;;;;;;;;;;;;;;;;;;;;KAwBD,YAAY,GAAG,KAAK,cAAgB,GAAG;;;KC/H9C,QAAQ;;;;;;;;;;KAWD,oBAAoB,oBAAoB,UAAU,SAAS,QACrE,SAAS,KAAK;WAAqC,MAAM;;;;;;;;;;;;;;;;;;;;KAoB/C,uBAAuB;OAC5B,UAAU,YACb,YAAY,yBAAyB;aAAe;aAAuB;MAC1E,oBAAoB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDd,YAAY,oBAC1B,KAAK,KACL;WAAqB;IACpB,uBAAuB;;;;;;;;;;;;KAkCd,YAAY,GAAG;EAAY;GAAgB;EACrD,KAAK,OAAO,MAAM;EAClB,SAAS,mBAAmB;OACvB,KAAK,aAAa,OAAO,QAAQ;EAAK,MAAM;OAAS;;;;;;;;KASvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CW,UAAU,GAAG;EAAY;GAAgB,GACvD,QAAQ,SAAO,GAAG,IAClB,UAAU,YAAY,GAAG,GAAG,OACxB,QAAQ,yDAAyD,oBACpE;iBACa,UAAU,GAAG;EAAY;GAAgB,GACvD,QAAQ,cAAY,GAAG,IACvB,UAAU,YAAY,GAAG,GAAG,OACxB,QAAQ,yDAAyD,oBACpE,QAAQ"}
1	+ {"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":";;;;;;;KAQY,SAAS,QAAQ,WAAW,IAAI,EAAE;;;;;;;;;KAUlC,MAAM,GAAG,kBAAkB,KAAK,SAAS,KAAK,GAAG,iBAAiB,KAAK,IAAI;;;;;;;;;;;;;;;;;KAkB3E,YAAY,MAAM,YAAY;;;;;;;;;;;;;;;;;KAoB9B,cAAc,GAAG;;;;;;;;;;;;EAY3B,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;;;;;;;;;;;EAYxB,OAAO,IAAI,IAAI,OAAO,MAAM,KAAK,YAAY,MAAM,SAAO,GAAG;;;;;;;;;;;;EAY7D,WAAW,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG;;;;;;;;;;;;EAYjE,OAAO,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG;;;;;;;;;;;;;;;EAe7D,WAAW,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,IAAI;;;;;;;;;;;EAW/D,QAAQ,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,IAAI;;;;;;;;;;;;;;;;;;;EAmB5D,OAAO,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;;;;;EAkB1D,WAAW,IAAI,IAAI,OAAO,MAAM,kBAAgB,MAAM,SAAO,GAAG,IAAI;;;;;;;;;;;;;;EAepE,cAAc,GAAG,IAAI,IAAI,mBAAmB,SAAO,GAAG,MAAM,SAAO,IAAI,GAAG,IAAI;;;;;;;;;;EAU9E,UAAU,GAAG,IAAI,mBAAmB,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;EA0BnE,WAAW,GAAG,IAAI,SAAS,YAAY,GAAG,OAAO,IAAI,YAAY,KAAK,SAAO,GAAG;;;;;;;;;;;;;;EAehF,MAAM,GAAG;IAAS,KAAK,OAAO,MAAM;IAAG,MAAM,OAAO,MAAM;IAAG,SAAS,mBAAmB;MAAM;;;;;;;;;;;;;;;;;EAiB/F,IAAI,MAAM,SAAO,YAAY;;;;;;;;;EAS7B,OAAO,MAAM,SAAO,YAAY;;;;;;;;;;;;;;EAchC,OAAO,MAAM,gBAAc,KAAK;;;;;;;;;EAShC,UAAU,MAAM,gBAAc,KAAK;;;;;;;;;EASnC,MAAM,GAAG,UAAU,IAAI,IAAI;;;;;;;;;;;EAW3B,SAAS,GAAG,UAAU,IAAI,IAAI;;;;;;;;EAQ9B,UAAU,GAAG,IAAI,OAAO,MAAM,IAAI,IAAI;;;;;;;;;;;EAWtC,aAAa,GAAG,IAAI,OAAO,MAAM,IAAI,IAAI;;;;;;EAMzC,aAAa;;;;;;EAMb,kBAAkB;;;;;;;;;;;;;;;;;;EAkBlB,cAAc;;EAGd,gBAAgB,OAAO,GAAG;;EAE1B,iBAAiB,QAAQ,GAAG;;EAE5B,oBAAoB,WAAW,GAAG;;EAGlC,WAAW,cAAY,GAAG;;;;;;;;;;;;;;KAehB,OAAO,GAAG,aAAa,cAAc,GAAG;WACzC;WACA,OAAO;;;;;;;;;;;;;;;;;;;;;;KAsBN,QAAQ,GAAG,aAAa,cAAc,GAAG;WAC1C;WACA,OAAO;;;;;;;;;;;;;;KAcN,WAAW,WAAW,aAAa,cAAc,GAAG;WACrD;WACA;;;;;;;;;;;;;;;;;;;;;;;;;KA0BC,YAAY,GAAG,aAAa,QAAQ,GAAG,KAAK,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuC1D,SAAO,GAAG,KAAK,OAAO,GAAG,KAAK,QAAQ,GAAG,KAAK,WAAW,GAAG;;;;;;;;;;;;;;;;;;;KAoB5D,UAAU;EACpB,KAAK,IAAI,GAAG,gBAAgB,OAAO,MAAM,IAAI,YAAY,aAAa,YAAY;;;;;;;;;;;;;;;;;;;;;;KAuBxE,mBAAmB,GAAG;;;;;;EAMhC,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;EAM5D,QAAQ,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,GAAG,IAAI;;;;;;;;;;;EAWxF,IAAI,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;;EAO5D,QAAQ,IACN,IAAI,OAAO,MAAM,kBAAgB,MAAM,uBAAqB,MAC3D,cAAY,GAAG,IAAI;;;;;;EAMtB,KAAK,kBAAkB,GAAG,IACxB,MAAM,GACN,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAC/C,cAAY,MAAM,GAAG,GAAG,IAAI,IAAI;;;;;;EAMnC,IAAI,kBAAkB,GACpB,MAAM,GACN,IAAI,OAAO,MAAM,IAAI,YAAY,KAChC,cAAY,MAAM,GAAG,GAAG,IAAI;;EAE/B,GAAG,GAAG,OAAO,IAAI,cAAY,GAAG;;EAEhC,WAAW,oBAAkB;;;;;;EAO7B,OAAO,IAAI,IAAI,OAAO,MAAM,KAAK,YAAY,MAAM,cAAY,GAAG;;;;;EAKlE,WAAW,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,IAAI,GAAG;;;;;EAK3F,OAAO,GAAG,IAAI,IAAI,OAAO,MAAM,SAAO,GAAG,MAAM,cAAY,GAAG,MAAM,cAAY,IAAI,GAAG;;;;;;EAMvF,WAAW,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,IAAI;;;;;EAKpE,QAAQ,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,IAAI;;;;;;;;;;EAUjE,OAAO,GAAG,IAAI,OAAO,MAAM,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;;;;EAS/D,WAAW,IACT,IAAI,OAAO,MAAM,kBAAgB,MAAM,uBAAqB,MAC3D,cAAY,GAAG,IAAI;;;;;EAMtB,cAAc,GAAG,IACf,IAAI,mBAAmB,SAAO,GAAG,MAAM,cAAY,GAAG,MACrD,cAAY,IAAI,GAAG,IAAI;;;;;;;EAO1B,UAAU,GAAG,IAAI,mBAAmB,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;;;;;EAUxE,WAAW,GAAG,IAAI,SAAS,YAAY,GAAG,OAAO,IAAI,YAAY,KAAK,cAAY,GAAG;;;;;EAMrF,MAAM,GAAG;IACP,KAAK,OAAO,MAAM;IAClB,MAAM,OAAO,MAAM;IACnB,SAAS,mBAAmB;MAC1B,QAAQ;;;;;;EAMZ,IAAI,MAAM,cAAY,YAAY,QAAQ;;;;;EAK1C,OAAO,MAAM,cAAY,YAAY,QAAQ;;;;;;EAM7C,OAAO,MAAM,qBAAmB,KAAK,QAAQ;;;;;EAK7C,UAAU,MAAM,qBAAmB,KAAK,QAAQ;;EAEhD,MAAM,GAAG,UAAU,IAAI,QAAQ,IAAI;;;;;EAKnC,SAAS,GAAG,UAAU,IAAI,QAAQ,IAAI;;EAEtC,UAAU,GAAG,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI;;;;;EAK9C,aAAa,GAAG,IAAI,OAAO,MAAM,IAAI,QAAQ,IAAI;;EAEjD,aAAa,QAAQ;;EAErB,kBAAkB,QAAQ;;;;;;EAM1B,cAAc,QAAQ;;;;;;;;;;;;;;;;;;;;;;;KAwBZ,cAAY,GAAG,KAAK,UAAU,SAAO,GAAG,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;KAiBpE,KAAK,KAAK;WAAqB;WAAoB,aAAa;IAAM;;;;;;;;;;;;;;KActE,MAAM,KAAK;WAAqB;WAAqB,aAAa;IAAM;;;;;;;;;;;;;;KAcxE,UAAU,KAAK,UAAU,oBAAkB,cAAc;;;;;;;;;;;;;;KAczD,WAAW,KAAK,UAAU,6BAA2B,KAAK;;;;;;;;;;;;;;;;;iBC92BtD,MAAM;;;;;;;;;;;;;;;;;iBAiBN,GAAG,GAAG,OAAO,IAAI,SAAO;;;;;;;;;;;;;;;;;iBAwBxB,IAAI,GAAG,OAAO,IAAI,gBAAc;;;;;;;;;;;;;;;iBAkBhC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BX,QAAQ,GAAG,OAAO,IAAI,cAAY;;;;;;;;;;;;;;;;;;;;;iBA2BlC,SAAS,GAAG,OAAO,IAAI,qBAAmB;;;;;;;;;;;;;;;;;;;iBAsB1C,KAAK,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,OAAO,GAAG;;;;;;;;;;;;;;;;;;;iBAqB5C,MAAM,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4B9C,SAAS,GAAG,GAAG,GAAG,SAAO,GAAG,KAAK,KAAK,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;cCzJvD,YAAY,qBAAqB;;;;;WAKnC,OAAO;cACJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyXL,SAAS,aAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBClY3B,MAAM;;;cC7ChB;;;;;;;;;;;;;;;KAgBM;YACA;WACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCcK,aAAa,GAAG,GAC9B,OAAO,sBACP,gBAAgB,IACf,SAAO,YAAY,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CV,cAAc,qBAAqB,GAAG,GACpD,QAAQ,MAAM,MAAM,GACpB,UAAU,gBAAgB,SAAS,mBAAmB,WAAW,QAC5D,MAAM,MAAM,SAAO,GAAG,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCxB,kBAAkB,qBAAqB,GACrD,QAAQ,MAAM,MAAM,QACf,MAAM,MAAM,SAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CV,YAAY,GAAG,GAC7B,SAAS,QAAQ,YAAY,QAAQ,KACrC,UAAU,gBAAgB,SAAS,mBAAmB,WAAW,IAChE,cAAY,GAAG,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;iBAsCb,gBAAgB,GAC9B,SAAS,QAAQ,YAAY,QAAQ,MACpC,cAAY;;;;;;;;;;;;;;;;;;KA0CV,MACH,+BACA,gDACiB,eAAe,eAAe;;KAG5C,eAAe,eAAe;;KAE9B,oBAAoB,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAuExB,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;;;;;;;;;;;;;;;;;;;;;;iBAiC5D,iBAAiB,UAAU,mBACzC,SAAS,IACR,iBAAe,WAAW,IAAI,UAAU,EAAE,QAAO,WAAW,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCnY1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCD,OAAO,GAAG,KAAK,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4B5B;;;;;;;;;;;;;;;;;;;;;KAwBD,YAAY,GAAG,KAAK,cAAgB,GAAG;;;KC/H9C,QAAQ;;;;;;;;;;KAWD,oBAAoB,oBAAoB,UAAU,SAAS,QACrE,SAAS,KAAK;WAAqC,MAAM;;;;;;;;;;;;;;;;;;;;KAoB/C,uBAAuB;OAC5B,UAAU,YACb,YAAY,yBAAyB;aAAe;aAAuB;MAC1E,oBAAoB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDd,YAAY,oBAC1B,KAAK,KACL;WAAqB;IACpB,uBAAuB;;;;;;;;;;;;KAkCd,YAAY,GAAG;EAAY;GAAgB;EACrD,KAAK,OAAO,MAAM;EAClB,SAAS,mBAAmB;OACvB,KAAK,aAAa,OAAO,QAAQ;EAAK,MAAM;OAAS;;;;;;;;KASvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CW,UAAU,GAAG;EAAY;GAAgB,GACvD,QAAQ,SAAO,GAAG,IAClB,UAAU,YAAY,GAAG,GAAG,OACxB,QAAQ,yDAAyD,oBACpE;iBACa,UAAU,GAAG;EAAY;GAAgB,GACvD,QAAQ,cAAY,GAAG,IACvB,UAAU,YAAY,GAAG,GAAG,OACxB,QAAQ,yDAAyD,oBACpE,QAAQ"}

package/dist/index.mjs CHANGED Viewed

@@ -176,6 +176,15 @@ var Res = class {
 			return observerThrowToDefect(cause, this.cause);
 		}
 	}
+	tapFailure(f) {
+		if (this.tag === "Ok") return this;
+		try {
+			f(this);
+			return this;
+		} catch (cause) {
+			return observerThrowToDefect(cause, this.tag === "Err" ? this.error : this.cause);
+		}
+	}
 	match(cases) {
 		switch (this.tag) {
 			case "Ok": return cases.ok(this.value);
@@ -532,6 +541,17 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
+	tapFailure(f) {
+		return new AsyncRes(this.promise.then((r) => {
+			if (r.tag === "Ok") return r;
+			try {
+				f(r);
+				return r;
+			} catch (cause) {
+				return observerThrowToDefect(cause, r.tag === "Err" ? r.error : r.cause);
+			}
+		}));
+	}
 	match(cases) {
 		return this.promise.then((r) => r.match(cases));
 	}

package/dist/index.mjs.map CHANGED Viewed

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

package/package.json CHANGED Viewed

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