npm - unthrown - Versions diffs - 3.0.0 → 3.0.1 - Mend

unthrown 3.0.0 → 3.0.1

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 (9) hide show

package/dist/index.cjs CHANGED Viewed

@@ -469,11 +469,7 @@ var AsyncRes = class AsyncRes {
 		return this.promise.then((r) => r.unwrapOr(fallback));
 	}
 	unwrapOrElse(f) {
-		return this.promise.then((r) => {
-			if (r.tag === "Ok") return r.value;
-			if (r.tag === "Defect") throw r.cause;
-			return f(r.error);
-		});
+		return this.promise.then((r) => r.unwrapOrElse(f));
 	}
 	getOrNull() {
 		return this.promise.then((r) => r.getOrNull());
@@ -735,8 +731,10 @@ function foldArray(results) {
 	let firstErr;
 	let firstDefect;
 	const values = [];
-	for (const r of results) if (r.tag === "Defect") firstDefect ??= r;
-	else if (r.tag === "Err") firstErr ??= r;
+	for (const r of results) if (r.tag === "Defect") {
+		firstDefect ??= r;
+		break;
+	} else if (r.tag === "Err") firstErr ??= r;
 	else values.push(r.value);
 	return firstDefect ?? firstErr ?? Ok(values);
 }

package/dist/index.d.cts CHANGED Viewed

@@ -191,7 +191,7 @@ type ResultMethods<T, E> = {
   recoverDefect<U, E2>(f: (cause: unknown) => Result$1<U, E2>): Result$1<T | U, E | E2>;
   /**
    * Run a side effect on a present `Defect`'s cause (e.g. logging) and pass the
-   * `Defect` through unchanged.
+   * `Defect` through unchanged. If `f` throws, the throw becomes a new `Defect`.
    *
    * @param f - the side effect over the unknown cause.
    */

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":"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~~iBAgExB~~,GAAA,qBAAwB,QAAA,sBACtC,OAAA,eAAsB,EAAA,IACrB,QAAA,CAAO,KAAA,CAAM,EAAA,gBAAkB,EAAA,GAAK,IAAA,CAAK,EAAA,CAAG,CAAA,OAAQ,KAAA,CAAM,EAAA;;;;;;;;;;;;;;;;;iBAuB7C,WAAA,WAAsB,YAAA,EACpC,OAAA,EAAS,CAAA,GACR,QAAA,eAAqB,CAAA,GAAI,IAAA,CAAK,CAAA,CAAE,CAAA,MAAO,KAAA,CAAM,CAAA,OAAQ,CAAA;;;;;;;;;;;;;;;;;iBAuBxC,QAAA,qBAA6B,aAAA,sBAC3C,OAAA,eAAsB,EAAA,IACrB,aAAA,CAAY,KAAA,CAAM,EAAA,gBAAkB,EAAA,GAAK,SAAA,CAAU,EAAA,CAAG,CAAA,OAAQ,UAAA,CAAW,EAAA;;;;;;;;;;;;;;;iBA0B5D,gBAAA,WAA2B,iBAAA,EACzC,OAAA,EAAS,CAAA,GACR,aAAA,eAA0B,CAAA,GAAI,SAAA,CAAU,CAAA,CAAE,CAAA,MAAO,UAAA,CAAW,CAAA,OAAQ,CAAA;;;;;;;;;;;;;~~ALnUxB~~;AAU/C;;;;;;;;;;;;cM0Ba,MAAA;EAAA;;;;;;;;;;;;KAiBD,MAAA,SAAe,QAAA,CAAW,CAAA,EAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;cAuB5B,WAAA;EAAA;;;;;KASD,WAAA,SAAoB,aAAA,CAAgB,CAAA,EAAG,CAAA;;;KCxF9C,KAAA,GAAQ,MAAM;;;;;;;;KASP,mBAAA,+BAAkD,KAAA,IAAS,KAAA,GACrE,QAAA,CAAS,CAAA;EAAA,SAAgB,IAAA,EAAM,GAAA;AAAA;;;;APPc;AAU/C;;;;;;KOSY,sBAAA;EAAA,eACK,KAAA,OAAY,IAAA,QAAY,CAAA,wBAAyB,CAAA,GAAI,mBAAA,CAAoB,GAAA,EAAK,CAAA;AAAA;;;;;;;;;;;;;;APVP;AAWxF;;;;;;;;;;;;;;;;;;;;;;;;;;iBO0CgB,WAAA,qBACd,GAAA,EAAK,GAAA,EACL,OAAA;EAAA,SAAqB,IAAA;AAAA,IACpB,sBAAA,CAAuB,GAAA;;;;;;;;;;KA4Bd,WAAA;EAA2B,IAAA;AAAA;EACrC,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA;EAClB,MAAA,GAAS,KAAA,cAAmB,CAAA;AAAA,YAClB,CAAA,YAAa,KAAA,EAAO,OAAA,CAAQ,CAAA;EAAK,IAAA,EAAM,CAAA;AAAA,OAAS,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgC5C,SAAA;EAAyB,IAAA;AAAA,MACvC,MAAA,EAAQ,QAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,EAAU,WAAA,CAAY,CAAA,EAAG,CAAA,EAAG,CAAA,IAC3B,CAAA;AAAA,iBACa,SAAA;EAAyB,IAAA;AAAA,MACvC,MAAA,EAAQ,aAAA,CAAY,CAAA,EAAG,CAAA,GACvB,QAAA,EAAU,WAAA,CAAY,CAAA,EAAG,CAAA,EAAG,CAAA,IAC3B,OAAA,CAAQ,CAAA"}
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

@@ -191,7 +191,7 @@ type ResultMethods<T, E> = {
   recoverDefect<U, E2>(f: (cause: unknown) => Result$1<U, E2>): Result$1<T | U, E | E2>;
   /**
    * Run a side effect on a present `Defect`'s cause (e.g. logging) and pass the
-   * `Defect` through unchanged.
+   * `Defect` through unchanged. If `f` throws, the throw becomes a new `Defect`.
    *
    * @param f - the side effect over the unknown cause.
    */

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":"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~~iBAgExB~~,GAAA,qBAAwB,QAAA,sBACtC,OAAA,eAAsB,EAAA,IACrB,QAAA,CAAO,KAAA,CAAM,EAAA,gBAAkB,EAAA,GAAK,IAAA,CAAK,EAAA,CAAG,CAAA,OAAQ,KAAA,CAAM,EAAA;;;;;;;;;;;;;;;;;iBAuB7C,WAAA,WAAsB,YAAA,EACpC,OAAA,EAAS,CAAA,GACR,QAAA,eAAqB,CAAA,GAAI,IAAA,CAAK,CAAA,CAAE,CAAA,MAAO,KAAA,CAAM,CAAA,OAAQ,CAAA;;;;;;;;;;;;;;;;;iBAuBxC,QAAA,qBAA6B,aAAA,sBAC3C,OAAA,eAAsB,EAAA,IACrB,aAAA,CAAY,KAAA,CAAM,EAAA,gBAAkB,EAAA,GAAK,SAAA,CAAU,EAAA,CAAG,CAAA,OAAQ,UAAA,CAAW,EAAA;;;;;;;;;;;;;;;iBA0B5D,gBAAA,WAA2B,iBAAA,EACzC,OAAA,EAAS,CAAA,GACR,aAAA,eAA0B,CAAA,GAAI,SAAA,CAAU,CAAA,CAAE,CAAA,MAAO,UAAA,CAAW,CAAA,OAAQ,CAAA;;;;;;;;;;;;;~~ALnUxB~~;AAU/C;;;;;;;;;;;;cM0Ba,MAAA;EAAA;;;;;;;;;;;;KAiBD,MAAA,SAAe,QAAA,CAAW,CAAA,EAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;cAuB5B,WAAA;EAAA;;;;;KASD,WAAA,SAAoB,aAAA,CAAgB,CAAA,EAAG,CAAA;;;KCxF9C,KAAA,GAAQ,MAAM;;;;;;;;KASP,mBAAA,+BAAkD,KAAA,IAAS,KAAA,GACrE,QAAA,CAAS,CAAA;EAAA,SAAgB,IAAA,EAAM,GAAA;AAAA;;;;APPc;AAU/C;;;;;;KOSY,sBAAA;EAAA,eACK,KAAA,OAAY,IAAA,QAAY,CAAA,wBAAyB,CAAA,GAAI,mBAAA,CAAoB,GAAA,EAAK,CAAA;AAAA;;;;;;;;;;;;;;APVP;AAWxF;;;;;;;;;;;;;;;;;;;;;;;;;;iBO0CgB,WAAA,qBACd,GAAA,EAAK,GAAA,EACL,OAAA;EAAA,SAAqB,IAAA;AAAA,IACpB,sBAAA,CAAuB,GAAA;;;;;;;;;;KA4Bd,WAAA;EAA2B,IAAA;AAAA;EACrC,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA;EAClB,MAAA,GAAS,KAAA,cAAmB,CAAA;AAAA,YAClB,CAAA,YAAa,KAAA,EAAO,OAAA,CAAQ,CAAA;EAAK,IAAA,EAAM,CAAA;AAAA,OAAS,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgC5C,SAAA;EAAyB,IAAA;AAAA,MACvC,MAAA,EAAQ,QAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,EAAU,WAAA,CAAY,CAAA,EAAG,CAAA,EAAG,CAAA,IAC3B,CAAA;AAAA,iBACa,SAAA;EAAyB,IAAA;AAAA,MACvC,MAAA,EAAQ,aAAA,CAAY,CAAA,EAAG,CAAA,GACvB,QAAA,EAAU,WAAA,CAAY,CAAA,EAAG,CAAA,EAAG,CAAA,IAC3B,OAAA,CAAQ,CAAA"}
1	+ {"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}

package/dist/index.mjs CHANGED Viewed

@@ -468,11 +468,7 @@ var AsyncRes = class AsyncRes {
 		return this.promise.then((r) => r.unwrapOr(fallback));
 	}
 	unwrapOrElse(f) {
-		return this.promise.then((r) => {
-			if (r.tag === "Ok") return r.value;
-			if (r.tag === "Defect") throw r.cause;
-			return f(r.error);
-		});
+		return this.promise.then((r) => r.unwrapOrElse(f));
 	}
 	getOrNull() {
 		return this.promise.then((r) => r.getOrNull());
@@ -734,8 +730,10 @@ function foldArray(results) {
 	let firstErr;
 	let firstDefect;
 	const values = [];
-	for (const r of results) if (r.tag === "Defect") firstDefect ??= r;
-	else if (r.tag === "Err") firstErr ??= r;
+	for (const r of results) if (r.tag === "Defect") {
+		firstDefect ??= r;
+		break;
+	} else if (r.tag === "Err") firstErr ??= r;
 	else values.push(r.value);
 	return firstDefect ?? firstErr ?? Ok(values);
 }

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

package/docs/index.md CHANGED Viewed

@@ -8,7 +8,7 @@
 ### UnwrapError
-Defined in: [packages/core/src/core.ts:35](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/core.ts#L35)
+Defined in: [packages/core/src/core.ts:35](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/core.ts#L35)
 Thrown by a [Result](#result)'s `unwrap` / `unwrapErr` when the assertion is
 wrong on a *modeled* result — `unwrap()` on an `Err`, or `unwrapErr()` on an
@@ -42,7 +42,7 @@ re-thrown (with its original stack) instead.
 new UnwrapError<E>(error): UnwrapError<E>;
 ```
-Defined in: [packages/core/src/core.ts:41](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/core.ts#L41)
+Defined in: [packages/core/src/core.ts:41](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/core.ts#L41)
 ###### Parameters
@@ -65,7 +65,7 @@ Error.constructor
 | Property | Modifier | Type | Description | Inherited from | Defined in |
 | ------ | ------ | ------ | ------ | ------ | ------ |
 | <a id="cause"></a> `cause?` | `public` | `unknown` | - | `Error.cause` | node\_modules/.pnpm/typescript@6.0.3/node\_modules/typescript/lib/lib.es2022.error.d.ts:24 |
-| <a id="error"></a> `error` | `readonly` | `E` | The offending value: the `Err` error for `unwrap()`, or the `Ok` value for `unwrapErr()`. | - | [packages/core/src/core.ts:40](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/core.ts#L40) |
+| <a id="error"></a> `error` | `readonly` | `E` | The offending value: the `Err` error for `unwrap()`, or the `Ok` value for `unwrapErr()`. | - | [packages/core/src/core.ts:40](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/core.ts#L40) |
 | <a id="message"></a> `message` | `public` | `string` | - | `Error.message` | node\_modules/.pnpm/typescript@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1075 |
 | <a id="name"></a> `name` | `public` | `string` | - | `Error.name` | node\_modules/.pnpm/typescript@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1074 |
 | <a id="stack"></a> `stack?` | `public` | `string` | - | `Error.stack` | node\_modules/.pnpm/typescript@6.0.3/node\_modules/typescript/lib/lib.es5.d.ts:1076 |
@@ -179,7 +179,7 @@ Error.prepareStackTrace
 type AsyncErrOf<R> = R extends AsyncResult<unknown, infer E> ? E : never;
 ```
-Defined in: [packages/core/src/types.ts:468](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L468)
+Defined in: [packages/core/src/types.ts:468](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L468)
 Extract the error type `E` from an [AsyncResult](#asyncresult).
@@ -197,7 +197,7 @@ Extract the error type `E` from an [AsyncResult](#asyncresult).
 type AsyncOkOf<R> = R extends AsyncResult<infer T, unknown> ? T : never;
 ```
-Defined in: [packages/core/src/types.ts:462](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L462)
+Defined in: [packages/core/src/types.ts:462](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L462)
 Extract the success type `T` from an [AsyncResult](#asyncresult).
@@ -215,7 +215,7 @@ Extract the success type `T` from an [AsyncResult](#asyncresult).
 type AsyncResult<T, E> = AsyncResultType<T, E>;
 ```
-Defined in: [packages/core/src/facade.ts:85](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L85)
+Defined in: [packages/core/src/facade.ts:85](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L85)
 Companion object grouping the **`AsyncResult`-producing** entry points under
 the matching namespace: [AsyncResult.fromPromise](#property-frompromise),
@@ -254,7 +254,7 @@ const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(
 type Awaitable<T> = object;
 ```
-Defined in: [packages/core/src/types.ts:346](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L346)
+Defined in: [packages/core/src/types.ts:346](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L346)
 A success-only thenable: awaitable, but deliberately **not** a full
 `PromiseLike`.
@@ -281,7 +281,7 @@ being treated as a raw promise (e.g. dropped into `Promise.all`).
 then<R>(onfulfilled?): PromiseLike<R>;
 ```
-Defined in: [packages/core/src/types.ts:347](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L347)
+Defined in: [packages/core/src/types.ts:347](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L347)
 ###### Type Parameters
@@ -307,7 +307,7 @@ Defined in: [packages/core/src/types.ts:347](https://github.com/btravstack/unthr
 type DefectView<T, E> = ResultMethods<T, E> & object;
 ```
-Defined in: [packages/core/src/types.ts:289](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L289)
+Defined in: [packages/core/src/types.ts:289](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L289)
 The `Defect` variant of a [Result](#result): an unmodeled failure carrying a `cause`.
@@ -315,8 +315,8 @@ The `Defect` variant of a [Result](#result): an unmodeled failure carrying a `ca
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| `cause` | `unknown` | [packages/core/src/types.ts:291](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L291) |
-| `tag` | `"Defect"` | [packages/core/src/types.ts:290](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L290) |
+| `cause` | `unknown` | [packages/core/src/types.ts:291](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L291) |
+| `tag` | `"Defect"` | [packages/core/src/types.ts:290](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L290) |
 #### Type Parameters
@@ -333,7 +333,7 @@ The `Defect` variant of a [Result](#result): an unmodeled failure carrying a `ca
 type ErrOf<R> = R extends object ? E : never;
 ```
-Defined in: [packages/core/src/types.ts:456](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L456)
+Defined in: [packages/core/src/types.ts:456](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L456)
 Extract the error type `E` from a `Result`.
@@ -351,7 +351,7 @@ Extract the error type `E` from a `Result`.
 type ErrView<E, T> = ResultMethods<T, E> & object;
 ```
-Defined in: [packages/core/src/types.ts:284](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L284)
+Defined in: [packages/core/src/types.ts:284](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L284)
 The `Err` variant of a [Result](#result): a modeled failure carrying an `error`.
@@ -359,8 +359,8 @@ The `Err` variant of a [Result](#result): a modeled failure carrying an `error`.
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| `error` | `E` | [packages/core/src/types.ts:286](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L286) |
-| `tag` | `"Err"` | [packages/core/src/types.ts:285](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L285) |
+| `error` | `E` | [packages/core/src/types.ts:286](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L286) |
+| `tag` | `"Err"` | [packages/core/src/types.ts:285](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L285) |
 #### Type Parameters
@@ -377,7 +377,7 @@ The `Err` variant of a [Result](#result): a modeled failure carrying an `error`.
 type OkOf<R> = R extends object ? T : never;
 ```
-Defined in: [packages/core/src/types.ts:450](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L450)
+Defined in: [packages/core/src/types.ts:450](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L450)
 Extract the success type `T` from a `Result`.
@@ -395,7 +395,7 @@ Extract the success type `T` from a `Result`.
 type OkView<T, E> = ResultMethods<T, E> & object;
 ```
-Defined in: [packages/core/src/types.ts:279](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L279)
+Defined in: [packages/core/src/types.ts:279](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L279)
 The `Ok` variant of a [Result](#result): a success carrying a `value`.
@@ -403,8 +403,8 @@ The `Ok` variant of a [Result](#result): a success carrying a `value`.
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| `tag` | `"Ok"` | [packages/core/src/types.ts:280](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L280) |
-| `value` | `T` | [packages/core/src/types.ts:281](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/types.ts#L281) |
+| `tag` | `"Ok"` | [packages/core/src/types.ts:280](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L280) |
+| `value` | `T` | [packages/core/src/types.ts:281](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/types.ts#L281) |
 #### Type Parameters
@@ -421,7 +421,7 @@ The `Ok` variant of a [Result](#result): a success carrying a `value`.
 type Result<T, E> = ResultType<T, E>;
 ```
-Defined in: [packages/core/src/facade.ts:45](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L45)
+Defined in: [packages/core/src/facade.ts:45](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L45)
 Companion object grouping the **`Result`-producing** entry points under a
 single, discoverable namespace: [Result.Ok](#property-ok), [Result.Err](#property-err),
@@ -462,7 +462,7 @@ Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).unwrap(); // 2
 type TaggedErrorConstructor<Tag> = <A>(args) => TaggedErrorInstance<Tag, A>;
 ```
-Defined in: [packages/core/src/tagged.ts:28](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L28)
+Defined in: [packages/core/src/tagged.ts:28](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L28)
 The class constructor returned by [TaggedError](#taggederror). Generic in its payload:
 apply it with an instantiation expression at the `extends` site.
@@ -496,7 +496,7 @@ When the payload is empty, the constructor takes **no** arguments (the
 type TaggedErrorInstance<Tag, A> = Error & Readonly<A> & object;
 ```
-Defined in: [packages/core/src/tagged.ts:15](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L15)
+Defined in: [packages/core/src/tagged.ts:15](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L15)
 The instance shape produced by a [TaggedError](#taggederror) class: an `Error` plus a
 `_tag` discriminant and the (readonly) payload fields.
@@ -505,7 +505,7 @@ The instance shape produced by a [TaggedError](#taggederror) class: an `Error` p
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| `_tag` | `Tag` | [packages/core/src/tagged.ts:16](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L16) |
+| `_tag` | `Tag` | [packages/core/src/tagged.ts:16](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L16) |
 #### Type Parameters
@@ -522,7 +522,7 @@ The instance shape produced by a [TaggedError](#taggederror) class: an `Error` p
 type TagHandlers<T, E, R> = object & { [K in E["_tag"]]: (error: Extract<E, { _tag: K }>) => R };
 ```
-Defined in: [packages/core/src/tagged.ts:103](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L103)
+Defined in: [packages/core/src/tagged.ts:103](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L103)
 The handler object [matchTags](#matchtags) requires: a branch per error tag, plus
 `Ok` and `Defect`. Miss a tag and it will not compile — the exhaustiveness is
@@ -532,8 +532,8 @@ enforced by the type, with no `.exhaustive()` to forget.
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| `Defect()` | (`cause`) => `R` | [packages/core/src/tagged.ts:105](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L105) |
-| `Ok()` | (`value`) => `R` | [packages/core/src/tagged.ts:104](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L104) |
+| `Defect()` | (`cause`) => `R` | [packages/core/src/tagged.ts:105](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L105) |
+| `Ok()` | (`value`) => `R` | [packages/core/src/tagged.ts:104](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L104) |
 #### Type Parameters
@@ -551,7 +551,7 @@ enforced by the type, with no `.exhaustive()` to forget.
 const AsyncResult: object;
 ```
-Defined in: [packages/core/src/facade.ts:85](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L85)
+Defined in: [packages/core/src/facade.ts:85](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L85)
 Companion object grouping the **`AsyncResult`-producing** entry points under
 the matching namespace: [AsyncResult.fromPromise](#property-frompromise),
@@ -562,10 +562,10 @@ the matching namespace: [AsyncResult.fromPromise](#property-frompromise),
 | Name | Type | Default value | Defined in |
 | ------ | ------ | ------ | ------ |
-| <a id="property-all"></a> `all()` | &lt;`Rs`&gt;(`results`) => `AsyncResult`&lt;`AllOk`&lt;`Rs`, \{ \[K in string \| number \| symbol\]: AsyncOkOf\<Rs\[K\]\> \}&gt;, [`AsyncErrOf`](#asyncerrof)&lt;`Rs`\[`number`\]&gt;&gt; | `allAsync` | [packages/core/src/facade.ts:88](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L88) |
-| <a id="property-allfromdict"></a> `allFromDict()` | &lt;`R`&gt;(`results`) => `AsyncResult`&lt;\{ \[K in string \| number \| symbol\]: AsyncOkOf\<R\[K\]\> \}, [`AsyncErrOf`](#asyncerrof)&lt;`R`\[keyof `R`\]&gt;&gt; | `allFromDictAsync` | [packages/core/src/facade.ts:89](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L89) |
-| <a id="property-frompromise"></a> `fromPromise()` | &lt;`T`, `R`&gt;(`promise`, `qualify`) => `AsyncResult`&lt;`T`, `Exclude`&lt;`R`, `Defect`&gt;&gt; | - | [packages/core/src/facade.ts:86](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L86) |
-| <a id="property-fromsafepromise"></a> `fromSafePromise()` | &lt;`T`&gt;(`promise`) => `AsyncResult`&lt;`T`, `never`&gt; | - | [packages/core/src/facade.ts:87](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L87) |
+| <a id="property-all"></a> `all()` | &lt;`Rs`&gt;(`results`) => `AsyncResult`&lt;`AllOk`&lt;`Rs`, \{ \[K in string \| number \| symbol\]: AsyncOkOf\<Rs\[K\]\> \}&gt;, [`AsyncErrOf`](#asyncerrof)&lt;`Rs`\[`number`\]&gt;&gt; | `allAsync` | [packages/core/src/facade.ts:88](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L88) |
+| <a id="property-allfromdict"></a> `allFromDict()` | &lt;`R`&gt;(`results`) => `AsyncResult`&lt;\{ \[K in string \| number \| symbol\]: AsyncOkOf\<R\[K\]\> \}, [`AsyncErrOf`](#asyncerrof)&lt;`R`\[keyof `R`\]&gt;&gt; | `allFromDictAsync` | [packages/core/src/facade.ts:89](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L89) |
+| <a id="property-frompromise"></a> `fromPromise()` | &lt;`T`, `R`&gt;(`promise`, `qualify`) => `AsyncResult`&lt;`T`, `Exclude`&lt;`R`, `Defect`&gt;&gt; | - | [packages/core/src/facade.ts:86](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L86) |
+| <a id="property-fromsafepromise"></a> `fromSafePromise()` | &lt;`T`&gt;(`promise`) => `AsyncResult`&lt;`T`, `never`&gt; | - | [packages/core/src/facade.ts:87](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L87) |
 #### Remarks
@@ -592,7 +592,7 @@ const user = await AsyncResult.fromPromise(fetchUser(id), (c, defect) => defect(
 const Result: object;
 ```
-Defined in: [packages/core/src/facade.ts:45](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L45)
+Defined in: [packages/core/src/facade.ts:45](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L45)
 Companion object grouping the **`Result`-producing** entry points under a
 single, discoverable namespace: [Result.Ok](#property-ok), [Result.Err](#property-err),
@@ -604,17 +604,17 @@ single, discoverable namespace: [Result.Ok](#property-ok), [Result.Err](#propert
 | Name | Type | Defined in |
 | ------ | ------ | ------ |
-| <a id="property-all-1"></a> `all()` | &lt;`Rs`&gt;(`results`) => `Result`&lt;`AllOk`&lt;`Rs`, \{ \[K in string \| number \| symbol\]: OkOf\<Rs\[K\]\> \}&gt;, [`ErrOf`](#errof)&lt;`Rs`\[`number`\]&gt;&gt; | [packages/core/src/facade.ts:51](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L51) |
-| <a id="property-allfromdict-1"></a> `allFromDict()` | &lt;`R`&gt;(`results`) => `Result`&lt;\{ \[K in string \| number \| symbol\]: OkOf\<R\[K\]\> \}, [`ErrOf`](#errof)&lt;`R`\[keyof `R`\]&gt;&gt; | [packages/core/src/facade.ts:52](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L52) |
-| <a id="property-do"></a> `Do()` | () => `Result`&lt;\{ \}, `never`&gt; | [packages/core/src/facade.ts:48](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L48) |
-| <a id="property-err"></a> `Err()` | &lt;`E`&gt;(`error`) => `Result`&lt;`never`, `E`&gt; | [packages/core/src/facade.ts:47](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L47) |
-| <a id="property-fromnullable"></a> `fromNullable()` | &lt;`T`, `E`&gt;(`value`, `onAbsent`) => `Result`&lt;`NonNullable`&lt;`T`&gt;, `E`&gt; | [packages/core/src/facade.ts:49](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L49) |
-| <a id="property-fromthrowable"></a> `fromThrowable()` | &lt;`A`, `T`, `R`&gt;(`fn`, `qualify`) => (...`args`) => `Result`&lt;`T`, `Exclude`&lt;`R`, `Defect`&gt;&gt; | [packages/core/src/facade.ts:50](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L50) |
-| <a id="property-isdefect"></a> `isDefect()` | &lt;`T`, `E`&gt;(`r`) => `r is DefectView<T, E>` | [packages/core/src/facade.ts:55](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L55) |
-| <a id="property-iserr"></a> `isErr()` | &lt;`T`, `E`&gt;(`r`) => `r is ErrView<E, T>` | [packages/core/src/facade.ts:54](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L54) |
-| <a id="property-isok"></a> `isOk()` | &lt;`T`, `E`&gt;(`r`) => `r is OkView<T, E>` | [packages/core/src/facade.ts:53](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L53) |
-| <a id="property-isresult"></a> `isResult()` | (`x`) => `x is Result<unknown, unknown>` | [packages/core/src/facade.ts:56](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L56) |
-| <a id="property-ok"></a> `Ok()` | &lt;`T`&gt;(`value`) => `Result`&lt;`T`, `never`&gt; | [packages/core/src/facade.ts:46](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/facade.ts#L46) |
+| <a id="property-all-1"></a> `all()` | &lt;`Rs`&gt;(`results`) => `Result`&lt;`AllOk`&lt;`Rs`, \{ \[K in string \| number \| symbol\]: OkOf\<Rs\[K\]\> \}&gt;, [`ErrOf`](#errof)&lt;`Rs`\[`number`\]&gt;&gt; | [packages/core/src/facade.ts:51](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L51) |
+| <a id="property-allfromdict-1"></a> `allFromDict()` | &lt;`R`&gt;(`results`) => `Result`&lt;\{ \[K in string \| number \| symbol\]: OkOf\<R\[K\]\> \}, [`ErrOf`](#errof)&lt;`R`\[keyof `R`\]&gt;&gt; | [packages/core/src/facade.ts:52](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L52) |
+| <a id="property-do"></a> `Do()` | () => `Result`&lt;\{ \}, `never`&gt; | [packages/core/src/facade.ts:48](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L48) |
+| <a id="property-err"></a> `Err()` | &lt;`E`&gt;(`error`) => `Result`&lt;`never`, `E`&gt; | [packages/core/src/facade.ts:47](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L47) |
+| <a id="property-fromnullable"></a> `fromNullable()` | &lt;`T`, `E`&gt;(`value`, `onAbsent`) => `Result`&lt;`NonNullable`&lt;`T`&gt;, `E`&gt; | [packages/core/src/facade.ts:49](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L49) |
+| <a id="property-fromthrowable"></a> `fromThrowable()` | &lt;`A`, `T`, `R`&gt;(`fn`, `qualify`) => (...`args`) => `Result`&lt;`T`, `Exclude`&lt;`R`, `Defect`&gt;&gt; | [packages/core/src/facade.ts:50](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L50) |
+| <a id="property-isdefect"></a> `isDefect()` | &lt;`T`, `E`&gt;(`r`) => `r is DefectView<T, E>` | [packages/core/src/facade.ts:55](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L55) |
+| <a id="property-iserr"></a> `isErr()` | &lt;`T`, `E`&gt;(`r`) => `r is ErrView<E, T>` | [packages/core/src/facade.ts:54](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L54) |
+| <a id="property-isok"></a> `isOk()` | &lt;`T`, `E`&gt;(`r`) => `r is OkView<T, E>` | [packages/core/src/facade.ts:53](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L53) |
+| <a id="property-isresult"></a> `isResult()` | (`x`) => `x is Result<unknown, unknown>` | [packages/core/src/facade.ts:56](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L56) |
+| <a id="property-ok"></a> `Ok()` | &lt;`T`&gt;(`value`) => `Result`&lt;`T`, `never`&gt; | [packages/core/src/facade.ts:46](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/facade.ts#L46) |
 #### Remarks
@@ -642,7 +642,7 @@ Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).unwrap(); // 2
 function all<Rs>(results): Result<AllOk<Rs, { [K in string | number | symbol]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>>;
 ```
-Defined in: [packages/core/src/interop.ts:252](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/interop.ts#L252)
+Defined in: [packages/core/src/interop.ts:254](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/interop.ts#L254)
 Collect a tuple/array of [Result](#result)s into a single `Result` of all their
 success values.
@@ -688,7 +688,7 @@ all([Ok(1), Ok(2)] as Result<number, never>[]).unwrap(); // number[]
 function allAsync<Rs>(results): AsyncResult<AllOk<Rs, { [K in string | number | symbol]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>>;
 ```
-Defined in: [packages/core/src/interop.ts:302](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/interop.ts#L302)
+Defined in: [packages/core/src/interop.ts:304](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/interop.ts#L304)
 The asynchronous counterpart of [all](#all): combine a tuple/array of
 [AsyncResult](#asyncresult)s into one `AsyncResult` of all their success values.
@@ -731,7 +731,7 @@ await allAsync([fromSafePromise(a()), fromSafePromise(b())]);
 function allFromDict<R>(results): Result<{ [K in string | number | symbol]: OkOf<R[K]> }, ErrOf<R[keyof R]>>;
 ```
-Defined in: [packages/core/src/interop.ts:277](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/interop.ts#L277)
+Defined in: [packages/core/src/interop.ts:279](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/interop.ts#L279)
 Collect a **record** of [Result](#result)s into a single `Result` of a record of
 their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is
@@ -774,7 +774,7 @@ allFromDict({ id: Ok(1), name: Ok("ada") }).unwrap(); // { id: 1, name: "ada" }
 function allFromDictAsync<R>(results): AsyncResult<{ [K in string | number | symbol]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>>;
 ```
-Defined in: [packages/core/src/interop.ts:330](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/interop.ts#L330)
+Defined in: [packages/core/src/interop.ts:332](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/interop.ts#L332)
 The asynchronous counterpart of [allFromDict](#allfromdict): combine a record of
 [AsyncResult](#asyncresult)s into one `AsyncResult` of a record of their values.
@@ -816,7 +816,7 @@ function Do(): Result<{
 }, never>;
 ```
-Defined in: [packages/core/src/do.ts:30](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/do.ts#L30)
+Defined in: [packages/core/src/do.ts:30](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/do.ts#L30)
 Start a do-notation chain with an empty object scope, grown step by step with
 `bind` (for `Result`-returning steps) and `let` (for pure values).
@@ -854,7 +854,7 @@ const result = Do()
 function Err<E>(error): Result<never, E>;
 ```
-Defined in: [packages/core/src/constructors.ts:34](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/constructors.ts#L34)
+Defined in: [packages/core/src/constructors.ts:34](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/constructors.ts#L34)
 Construct a failed [Result](#result) carrying a **modeled** error.
@@ -889,7 +889,7 @@ Err("not_found").unwrapErr(); // "not_found"
 function fromNullable<T, E>(value, onAbsent): Result<NonNullable<T>, E>;
 ```
-Defined in: [packages/core/src/interop.ts:29](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/interop.ts#L29)
+Defined in: [packages/core/src/interop.ts:29](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/interop.ts#L29)
 Bridge a nullable value into a [Result](#result): absence becomes a **modeled**
 `Err`. The sanctioned alternative to an `Option` type.
@@ -932,7 +932,7 @@ fromNullable(map.get(key), () => "missing").unwrap();
 function fromPromise<T, R>(promise, qualify): AsyncResult<T, Exclude<R, Defect>>;
 ```
-Defined in: [packages/core/src/interop.ts:113](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/interop.ts#L113)
+Defined in: [packages/core/src/interop.ts:113](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/interop.ts#L113)
 Wrap a `Promise` (or a thunk producing one) as an [AsyncResult](#asyncresult), forcing
 every rejection to be triaged.
@@ -984,7 +984,7 @@ const user = await fromPromise(fetchUser(id), (cause, defect) =>
 function fromSafePromise<T>(promise): AsyncResult<T, never>;
 ```
-Defined in: [packages/core/src/interop.ts:139](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/interop.ts#L139)
+Defined in: [packages/core/src/interop.ts:139](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/interop.ts#L139)
 Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection
 becomes a `Defect`.
@@ -1019,7 +1019,7 @@ triage. (`await`-ing still yields a `Result`; it never throws.)
 function fromThrowable<A, T, R>(fn, qualify): (...args) => Result<T, Exclude<R, Defect>>;
 ```
-Defined in: [packages/core/src/interop.ts:68](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/interop.ts#L68)
+Defined in: [packages/core/src/interop.ts:68](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/interop.ts#L68)
 Wrap a throwing synchronous function so it returns a [Result](#result) instead of
 throwing.
@@ -1074,7 +1074,7 @@ parse("{}").unwrap();
 function isDefect<T, E>(r): r is DefectView<T, E>;
 ```
-Defined in: [packages/core/src/constructors.ts:66](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/constructors.ts#L66)
+Defined in: [packages/core/src/constructors.ts:66](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/constructors.ts#L66)
 Type guard: narrow a [Result](#result) to its `Defect` variant, exposing `.cause`.
@@ -1105,7 +1105,7 @@ Type guard: narrow a [Result](#result) to its `Defect` variant, exposing `.cause
 function isErr<T, E>(r): r is ErrView<E, T>;
 ```
-Defined in: [packages/core/src/constructors.ts:58](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/constructors.ts#L58)
+Defined in: [packages/core/src/constructors.ts:58](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/constructors.ts#L58)
 Type guard: narrow a [Result](#result) to its `Err` variant, exposing `.error`.
@@ -1136,7 +1136,7 @@ Type guard: narrow a [Result](#result) to its `Err` variant, exposing `.error`.
 function isOk<T, E>(r): r is OkView<T, E>;
 ```
-Defined in: [packages/core/src/constructors.ts:50](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/constructors.ts#L50)
+Defined in: [packages/core/src/constructors.ts:50](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/constructors.ts#L50)
 Type guard: narrow a [Result](#result) to its `Ok` variant, exposing `.value`.
@@ -1175,7 +1175,7 @@ if (isOk(r)) r.value; // number, narrowed
 function isResult(x): x is Result<unknown, unknown>;
 ```
-Defined in: [packages/core/src/core.ts:338](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/core.ts#L338)
+Defined in: [packages/core/src/core.ts:338](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/core.ts#L338)
 Type guard: is `x` a [Result](#result) (any of `Ok` / `Err` / `Defect`)?
@@ -1209,7 +1209,7 @@ is not a `Result` and returns `false`.
 function matchTags<T, E, R>(result, handlers): R;
 ```
-Defined in: [packages/core/src/tagged.ts:138](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L138)
+Defined in: [packages/core/src/tagged.ts:138](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L138)
 Exhaustively fold a [Result](#result) (or [AsyncResult](#asyncresult)) whose error type is
 a tagged union, dispatching each error to the handler matching its `_tag`.
@@ -1261,7 +1261,7 @@ matchTags(r, {
 function matchTags<T, E, R>(result, handlers): Promise<R>;
 ```
-Defined in: [packages/core/src/tagged.ts:142](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L142)
+Defined in: [packages/core/src/tagged.ts:142](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L142)
 Exhaustively fold a [Result](#result) (or [AsyncResult](#asyncresult)) whose error type is
 a tagged union, dispatching each error to the handler matching its `_tag`.
@@ -1315,7 +1315,7 @@ matchTags(r, {
 function Ok<T>(value): Result<T, never>;
 ```
-Defined in: [packages/core/src/constructors.ts:18](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/constructors.ts#L18)
+Defined in: [packages/core/src/constructors.ts:18](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/constructors.ts#L18)
 Construct a successful [Result](#result).
@@ -1350,7 +1350,7 @@ Ok(42).unwrap(); // 42
 function TaggedError<Tag>(tag, options?): TaggedErrorConstructor<Tag>;
 ```
-Defined in: [packages/core/src/tagged.ts:72](https://github.com/btravstack/unthrown/blob/544e3bf9c78133de7b31b82a17110bf70ee814fb/packages/core/src/tagged.ts#L72)
+Defined in: [packages/core/src/tagged.ts:72](https://github.com/btravstack/unthrown/blob/6af2083f66eff6f878bfea8d336602c60827f96e/packages/core/src/tagged.ts#L72)
 Build a base class for a tagged error — a class extending `Error` with a
 `_tag` string discriminant, in the style of Effect's `Data.TaggedError`.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "unthrown",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Explicit errors as values, with a separate defect (panic) channel",
   "keywords": [
     "defect",
@@ -29,6 +29,7 @@
     "docs"
   ],
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
@@ -48,7 +49,7 @@
   "devDependencies": {
     "@types/node": "24.13.2",
     "@vitest/coverage-v8": "4.1.8",
-    "tsdown": "0.22.2",
+    "tsdown": "0.22.3",
     "typedoc": "0.28.19",
     "typedoc-plugin-markdown": "4.12.0",
     "typescript": "6.0.3",