unthrown 5.3.0 → 5.5.0

package/dist/index.cjs

@@ -135,7 +135,7 @@ const universal = pattern(() => true);
 /**
 * The pattern namespace (unthrown's own; the former ts-pattern `P`):
 *
-* - `P._` / `P.any` — the universal catch-all, and an **escape hatch** rather
+* - `P._` — the universal catch-all, and an **escape hatch** rather
 *   than the default: matching the error channel means naming its cases, so
 *   reach for this only where they cannot be named. Matches anything, and
 *   (because its phantom type is `unknown`) makes the builder provably
@@ -153,25 +153,22 @@ const universal = pattern(() => true);
 *   branch's parameter to that variant, payload included. The workhorse of the
 *   error channel: `matcher.with(P.tag("NotFound"), (e) => …)`. It composes like
 *   any other pattern — in a grouped arm
-*   (`.with(P.tag("A"), P.tag("B"), handler)`) and inside `P.union`.
+*   (`.with(P.tag("A"), P.tag("B"), handler)`).
 * - `P.instanceOf(Cls)` — an `instanceof` check, narrowing to the class
 *   instance type (for union members that are not tagged, e.g. a third-party
 *   error class).
-* - `P.when(guard)` — an arbitrary type-guard predicate.
-* - `P.union(…patterns)` — matches when any sub-pattern matches.
-* - `P.string` / `P.number` — primitive-type wildcards.
+* - `P.when(guard)` — an arbitrary type-guard predicate. Also the way to match
+*   a primitive shape (`P.when((v): v is string => typeof v === "string")`),
+*   and grouping patterns under one handler is what a `.with(a, b, handler)`
+*   arm already does.
 *
 * @category Constructors
 */
 const P = Object.freeze({
 	_: universal,
-	any: universal,
 	tag: (value) => ({ _tag: value }),
 	instanceOf: (cls) => pattern((value) => value instanceof cls),
-	when: (guard) => pattern(guard),
-	union: (...patterns) => pattern((value) => patterns.some((sub) => matches(sub, value))),
-	string: pattern((value) => typeof value === "string"),
-	number: pattern((value) => typeof value === "number")
+	when: (guard) => pattern(guard)
 });
 //#endregion
 //#region src/defect.ts
@@ -569,6 +566,30 @@ function passThrough(self) {
 	return self;
 }
 /**
+* Runtime thenable probe, shared by the combinator-side net below and the
+* boundary nets in `interop.ts`.
+*
+* @remarks
+* Reading `.then` can itself **throw** — a hostile getter, or a Proxy `get`
+* trap — so this is deliberately not a total function, and every caller must
+* account for that. Two shapes are sanctioned, and there is no third:
+*
+* - inside a `try` that routes the throw to a `Defect` (the boundaries in
+*   `interop.ts`, where a hostile value arriving at a triage point *is* an
+*   unmodeled failure and should surface as one); or
+* - through {@link silenceIfThenable}, for a value being **discarded**, where
+*   there is no Defect channel to route to and the only correct answer is to
+*   drop it without throwing.
+*
+* Calling it bare, outside both, is a bug: the throw escapes into whatever
+* context invoked it.
+*
+* @internal
+*/
+function isThenable(x) {
+	return (typeof x === "object" || typeof x === "function") && x !== null && typeof x.then === "function";
+}
+/**
 * Adopt-and-silence a thenable a combinator is about to **discard**.
 *
 * @remarks
@@ -589,7 +610,7 @@ function passThrough(self) {
 */
 function silenceIfThenable(value) {
 	try {
-		if ((typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function") Promise.resolve(value).then(void 0, () => void 0);
+		if (isThenable(value)) Promise.resolve(value).then(void 0, () => void 0);
 	} catch {}
 }
 /**
@@ -670,18 +691,29 @@ var AsyncRes = class AsyncRes {
 	constructor(promise) {
 		this.#promise = promise;
 	}
+	/**
+	* Lift a **synchronous** `Result` combinator over the wrapped promise.
+	*
+	* @remarks
+	* Every method below that does no `await` of its own is exactly its `Res`
+	* twin applied to the settled `Result` — same tag check, same try/catch, same
+	* throw→defect net. Delegating instead of restating it keeps the two surfaces
+	* from drifting: a fix to the sync combinator is the fix to the async one.
+	* The methods that DO await a callback's result (`flatMap`, `flatTap`,
+	* `bind`, `flatMapErrCases`, `flatTapErrCases`, `recoverDefect` — the ones
+	* whose callback may hand back an `AsyncResult`) genuinely differ and are
+	* still written out in full.
+	*
+	* @internal
+	*/
+	#lift(f) {
+		return new AsyncRes(this.#promise.then(f));
+	}
 	then(onfulfilled, onrejected) {
 		return this.#promise.then(onfulfilled, onrejected);
 	}
 	map(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Ok") return passThrough(r);
-			try {
-				return okRes(f(r.value));
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.map(f));
 	}
 	flatMap(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
@@ -695,15 +727,7 @@ var AsyncRes = class AsyncRes {
 		}));
 	}
 	tap(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Ok") return r;
-			try {
-				silenceIfThenable(f(r.value));
-				return r;
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.tap(f));
 	}
 	flatTap(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
@@ -734,45 +758,19 @@ var AsyncRes = class AsyncRes {
 		}));
 	}
 	let(name, f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Ok") return passThrough(r);
-			try {
-				return okRes({
-					...scopeOf(r.value),
-					[name]: f(r.value)
-				});
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.let(name, f));
 	}
 	as(value) {
-		return new AsyncRes(this.#promise.then((r) => r.tag === "Ok" ? okRes(value) : passThrough(r)));
+		return this.#lift((r) => r.as(value));
 	}
 	discard() {
-		return new AsyncRes(this.#promise.then((r) => r.tag === "Ok" ? okRes(void 0) : passThrough(r)));
+		return this.#lift((r) => r.discard());
 	}
 	ensure(predicate, onFail) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Ok") return passThrough(r);
-			try {
-				return predicate(r.value) ? r : errRes(onFail(r.value));
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.ensure(predicate, onFail));
 	}
 	mapErrCases(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Err") return passThrough(r);
-			try {
-				const out = runMatch(f, r.error);
-				if (isDefectMarker(out)) return defectRes(out.cause);
-				return errRes(out);
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.mapErrCases(f));
 	}
 	flatMapErrCases(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
@@ -789,29 +787,10 @@ var AsyncRes = class AsyncRes {
 		}));
 	}
 	recoverErrCases(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Err") return passThrough(r);
-			try {
-				const out = runMatch(f, r.error);
-				if (isDefectMarker(out)) return defectRes(out.cause);
-				return okRes(out);
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.recoverErrCases(f));
 	}
 	tapErrCases(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Err") return r;
-			try {
-				const out = runMatch(f, r.error);
-				if (isDefectMarker(out)) return observerThrowToDefect(out.cause, r.error);
-				silenceIfThenable(out);
-				return r;
-			} catch (cause) {
-				return observerThrowToDefect(cause, r.error);
-			}
-		}));
+		return this.#lift((r) => r.tapErrCases(f));
 	}
 	flatTapErrCases(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
@@ -839,26 +818,10 @@ var AsyncRes = class AsyncRes {
 		}));
 	}
 	tapDefect(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Defect") return r;
-			try {
-				silenceIfThenable(f(r.cause));
-				return r;
-			} catch (cause) {
-				return observerThrowToDefect(cause, r.cause);
-			}
-		}));
+		return this.#lift((r) => r.tapDefect(f));
 	}
 	tapFailure(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag === "Ok") return r;
-			try {
-				silenceIfThenable(f(r));
-				return r;
-			} catch (cause) {
-				return observerThrowToDefect(cause, r.tag === "Err" ? r.error : r.cause);
-			}
-		}));
+		return this.#lift((r) => r.tapFailure(f));
 	}
 	match(cases) {
 		return this.#promise.then((r) => r.match(cases));
@@ -1340,7 +1303,7 @@ function fromExecutor(executor) {
 			return;
 		}
 		if (!isResult(result)) {
-			if (isThenable(result)) Promise.resolve(result).then(void 0, () => void 0);
+			silenceIfThenable(result);
 			resolve(defectRes(/* @__PURE__ */ new TypeError("unthrown: fromExecutor's settle received a non-Result value")));
 			return;
 		}
@@ -1394,15 +1357,6 @@ function thenableReturnDefect(value) {
 	return defectRes(/* @__PURE__ */ new TypeError("unthrown: fromThrowable/fromSafeThrowable wrap a SYNCHRONOUS function, but `fn` returned a thenable — its rejection would escape qualification. Use fromPromise/fromSafePromise instead."));
 }
 /**
-* Runtime thenable probe for the belt-and-braces guards above. Called inside the
-* caller's `try`, so even a hostile `.then` getter lands on the Defect path.
-*
-* @internal
-*/
-function isThenable(x) {
-	return (typeof x === "object" || typeof x === "function") && x !== null && typeof x.then === "function";
-}
-/**
 * Fold an array of settled `Result`s: first `Err` wins, any `Defect` dominates,
 * else `Ok` of the values array.
 *
@@ -1431,32 +1385,23 @@ function foldArray(results) {
 }
 /**
 * Fold a record of settled `Result`s with the same rules, else `Ok` of the
-* record of values. Keys are written with `Object.defineProperty` so a
-* caller-supplied `"__proto__"` key cannot pollute the prototype.
+* record of values.
+*
+* @remarks
+* The positional fold already implements every rule (first `Err` wins, any
+* `Defect` dominates, a non-`Result` element becomes a `Defect`), so this pairs
+* the keys back onto its success value rather than restating them.
+*
+* `Object.fromEntries` is what makes a caller-supplied `"__proto__"` key safe:
+* it builds each key with CreateDataProperty, which defines an own property
+* instead of invoking the `__proto__` setter — the same guarantee the previous
+* explicit `Object.defineProperty` loop bought by hand.
 *
 * @internal
 */
 function foldRecord(results) {
-	let firstErr;
-	let firstDefect;
-	const values = {};
-	for (const [key, r] of Object.entries(results)) {
-		if (!isResult(r)) {
-			firstDefect ??= nonResultDefect();
-			break;
-		}
-		if (r.tag === "Defect") {
-			firstDefect ??= r;
-			break;
-		} else if (r.tag === "Err") firstErr ??= r;
-		else Object.defineProperty(values, key, {
-			value: r.value,
-			enumerable: true,
-			writable: true,
-			configurable: true
-		});
-	}
-	return firstDefect ?? firstErr ?? Ok(values);
+	const keys = Object.keys(results);
+	return foldArray(Object.values(results)).map((values) => Object.fromEntries(keys.map((key, i) => [key, values[i]])));
 }
 /**
 * Collect a tuple/array of {@link Result}s into a single `Result` of all their
@@ -1554,14 +1499,8 @@ function allAsync(results) {
 * ```
 */
 function allFromDictAsync(results) {
-	const entries = Object.entries(results);
-	return new AsyncRes(Promise.all(entries.map(([, ar]) => Promise.resolve(ar).then((x) => x, (cause) => defectRes(cause)))).then((resolved) => {
-		const byKey = Object.create(null);
-		entries.forEach(([key], i) => {
-			byKey[key] = resolved[i];
-		});
-		return foldRecord(byKey);
-	}));
+	const keys = Object.keys(results);
+	return new AsyncRes(Promise.all(Object.values(results).map((ar) => Promise.resolve(ar).then((x) => x, (cause) => defectRes(cause)))).then((resolved) => foldArray(resolved).map((values) => Object.fromEntries(keys.map((key, i) => [key, values[i]])))));
 }
 //#endregion
 //#region src/facade.ts

package/dist/index.d.cts

@@ -44,7 +44,7 @@ type PatternMatcher<M> = {
   readonly [MATCHES]?: M;
 };
 /**
- * The statically-known universal pattern — the type of `P._` / `P.any` only.
+ * The statically-known universal pattern — the type of `P._` only.
  * The phantom `UNIVERSAL` marker is *required*, so no other
  * `PatternMatcher<unknown>` (e.g. a `P.when` guard that happens to be
  * universal) is assignable: the catch-all `.with` overload must only fire for
@@ -127,7 +127,7 @@ type PinTooLate = {
  */
 type Matcher<E, Remaining, O, Declared = Unset> = {
   /**
-   * The catch-all arm: `.with(P._, handler)` / `.with(P.any, handler)` — the
+   * The catch-all arm: `.with(P._, handler)` — the
    * wildcard **escape hatch**, not the way to handle a concrete error union
    * (name those cases; `@unthrown/oxlint`'s `no-catch-all-pattern`, in its
    * `recommended` preset, flags the wildcard).
@@ -225,7 +225,7 @@ declare function match<const E>(value: E): Matcher<E, E, never>;
 /**
  * The pattern namespace (unthrown's own; the former ts-pattern `P`):
  *
- * - `P._` / `P.any` — the universal catch-all, and an **escape hatch** rather
+ * - `P._` — the universal catch-all, and an **escape hatch** rather
  *   than the default: matching the error channel means naming its cases, so
  *   reach for this only where they cannot be named. Matches anything, and
  *   (because its phantom type is `unknown`) makes the builder provably
@@ -243,27 +243,24 @@ declare function match<const E>(value: E): Matcher<E, E, never>;
  *   branch's parameter to that variant, payload included. The workhorse of the
  *   error channel: `matcher.with(P.tag("NotFound"), (e) => …)`. It composes like
  *   any other pattern — in a grouped arm
- *   (`.with(P.tag("A"), P.tag("B"), handler)`) and inside `P.union`.
+ *   (`.with(P.tag("A"), P.tag("B"), handler)`).
  * - `P.instanceOf(Cls)` — an `instanceof` check, narrowing to the class
  *   instance type (for union members that are not tagged, e.g. a third-party
  *   error class).
- * - `P.when(guard)` — an arbitrary type-guard predicate.
- * - `P.union(…patterns)` — matches when any sub-pattern matches.
- * - `P.string` / `P.number` — primitive-type wildcards.
+ * - `P.when(guard)` — an arbitrary type-guard predicate. Also the way to match
+ *   a primitive shape (`P.when((v): v is string => typeof v === "string")`),
+ *   and grouping patterns under one handler is what a `.with(a, b, handler)`
+ *   arm already does.
  *
  * @category Constructors
  */
 declare const P: Readonly<{
   _: UniversalPattern;
-  any: UniversalPattern;
   tag: <const Tag extends string>(value: Tag) => {
     _tag: Tag;
   };
   instanceOf: <C extends abstract new (...args: never[]) => unknown>(cls: C) => PatternMatcher<InstanceType<C>>;
   when: <G>(guard: (value: unknown) => value is G) => PatternMatcher<G>;
-  union: <const Pts extends readonly [unknown, ...unknown[]]>(...patterns: Pts) => PatternMatcher<MatchedOf<Pts[number]>>;
-  string: PatternMatcher<string>;
-  number: PatternMatcher<number>;
 }>;
 //#endregion
 //#region src/types.d.ts

package/dist/index.d.mts

@@ -44,7 +44,7 @@ type PatternMatcher<M> = {
   readonly [MATCHES]?: M;
 };
 /**
- * The statically-known universal pattern — the type of `P._` / `P.any` only.
+ * The statically-known universal pattern — the type of `P._` only.
  * The phantom `UNIVERSAL` marker is *required*, so no other
  * `PatternMatcher<unknown>` (e.g. a `P.when` guard that happens to be
  * universal) is assignable: the catch-all `.with` overload must only fire for
@@ -127,7 +127,7 @@ type PinTooLate = {
  */
 type Matcher<E, Remaining, O, Declared = Unset> = {
   /**
-   * The catch-all arm: `.with(P._, handler)` / `.with(P.any, handler)` — the
+   * The catch-all arm: `.with(P._, handler)` — the
    * wildcard **escape hatch**, not the way to handle a concrete error union
    * (name those cases; `@unthrown/oxlint`'s `no-catch-all-pattern`, in its
    * `recommended` preset, flags the wildcard).
@@ -225,7 +225,7 @@ declare function match<const E>(value: E): Matcher<E, E, never>;
 /**
  * The pattern namespace (unthrown's own; the former ts-pattern `P`):
  *
- * - `P._` / `P.any` — the universal catch-all, and an **escape hatch** rather
+ * - `P._` — the universal catch-all, and an **escape hatch** rather
  *   than the default: matching the error channel means naming its cases, so
  *   reach for this only where they cannot be named. Matches anything, and
  *   (because its phantom type is `unknown`) makes the builder provably
@@ -243,27 +243,24 @@ declare function match<const E>(value: E): Matcher<E, E, never>;
  *   branch's parameter to that variant, payload included. The workhorse of the
  *   error channel: `matcher.with(P.tag("NotFound"), (e) => …)`. It composes like
  *   any other pattern — in a grouped arm
- *   (`.with(P.tag("A"), P.tag("B"), handler)`) and inside `P.union`.
+ *   (`.with(P.tag("A"), P.tag("B"), handler)`).
  * - `P.instanceOf(Cls)` — an `instanceof` check, narrowing to the class
  *   instance type (for union members that are not tagged, e.g. a third-party
  *   error class).
- * - `P.when(guard)` — an arbitrary type-guard predicate.
- * - `P.union(…patterns)` — matches when any sub-pattern matches.
- * - `P.string` / `P.number` — primitive-type wildcards.
+ * - `P.when(guard)` — an arbitrary type-guard predicate. Also the way to match
+ *   a primitive shape (`P.when((v): v is string => typeof v === "string")`),
+ *   and grouping patterns under one handler is what a `.with(a, b, handler)`
+ *   arm already does.
  *
  * @category Constructors
  */
 declare const P: Readonly<{
   _: UniversalPattern;
-  any: UniversalPattern;
   tag: <const Tag extends string>(value: Tag) => {
     _tag: Tag;
   };
   instanceOf: <C extends abstract new (...args: never[]) => unknown>(cls: C) => PatternMatcher<InstanceType<C>>;
   when: <G>(guard: (value: unknown) => value is G) => PatternMatcher<G>;
-  union: <const Pts extends readonly [unknown, ...unknown[]]>(...patterns: Pts) => PatternMatcher<MatchedOf<Pts[number]>>;
-  string: PatternMatcher<string>;
-  number: PatternMatcher<number>;
 }>;
 //#endregion
 //#region src/types.d.ts

package/dist/index.mjs

@@ -134,7 +134,7 @@ const universal = pattern(() => true);
 /**
 * The pattern namespace (unthrown's own; the former ts-pattern `P`):
 *
-* - `P._` / `P.any` — the universal catch-all, and an **escape hatch** rather
+* - `P._` — the universal catch-all, and an **escape hatch** rather
 *   than the default: matching the error channel means naming its cases, so
 *   reach for this only where they cannot be named. Matches anything, and
 *   (because its phantom type is `unknown`) makes the builder provably
@@ -152,25 +152,22 @@ const universal = pattern(() => true);
 *   branch's parameter to that variant, payload included. The workhorse of the
 *   error channel: `matcher.with(P.tag("NotFound"), (e) => …)`. It composes like
 *   any other pattern — in a grouped arm
-*   (`.with(P.tag("A"), P.tag("B"), handler)`) and inside `P.union`.
+*   (`.with(P.tag("A"), P.tag("B"), handler)`).
 * - `P.instanceOf(Cls)` — an `instanceof` check, narrowing to the class
 *   instance type (for union members that are not tagged, e.g. a third-party
 *   error class).
-* - `P.when(guard)` — an arbitrary type-guard predicate.
-* - `P.union(…patterns)` — matches when any sub-pattern matches.
-* - `P.string` / `P.number` — primitive-type wildcards.
+* - `P.when(guard)` — an arbitrary type-guard predicate. Also the way to match
+*   a primitive shape (`P.when((v): v is string => typeof v === "string")`),
+*   and grouping patterns under one handler is what a `.with(a, b, handler)`
+*   arm already does.
 *
 * @category Constructors
 */
 const P = Object.freeze({
 	_: universal,
-	any: universal,
 	tag: (value) => ({ _tag: value }),
 	instanceOf: (cls) => pattern((value) => value instanceof cls),
-	when: (guard) => pattern(guard),
-	union: (...patterns) => pattern((value) => patterns.some((sub) => matches(sub, value))),
-	string: pattern((value) => typeof value === "string"),
-	number: pattern((value) => typeof value === "number")
+	when: (guard) => pattern(guard)
 });
 //#endregion
 //#region src/defect.ts
@@ -568,6 +565,30 @@ function passThrough(self) {
 	return self;
 }
 /**
+* Runtime thenable probe, shared by the combinator-side net below and the
+* boundary nets in `interop.ts`.
+*
+* @remarks
+* Reading `.then` can itself **throw** — a hostile getter, or a Proxy `get`
+* trap — so this is deliberately not a total function, and every caller must
+* account for that. Two shapes are sanctioned, and there is no third:
+*
+* - inside a `try` that routes the throw to a `Defect` (the boundaries in
+*   `interop.ts`, where a hostile value arriving at a triage point *is* an
+*   unmodeled failure and should surface as one); or
+* - through {@link silenceIfThenable}, for a value being **discarded**, where
+*   there is no Defect channel to route to and the only correct answer is to
+*   drop it without throwing.
+*
+* Calling it bare, outside both, is a bug: the throw escapes into whatever
+* context invoked it.
+*
+* @internal
+*/
+function isThenable(x) {
+	return (typeof x === "object" || typeof x === "function") && x !== null && typeof x.then === "function";
+}
+/**
 * Adopt-and-silence a thenable a combinator is about to **discard**.
 *
 * @remarks
@@ -588,7 +609,7 @@ function passThrough(self) {
 */
 function silenceIfThenable(value) {
 	try {
-		if ((typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function") Promise.resolve(value).then(void 0, () => void 0);
+		if (isThenable(value)) Promise.resolve(value).then(void 0, () => void 0);
 	} catch {}
 }
 /**
@@ -669,18 +690,29 @@ var AsyncRes = class AsyncRes {
 	constructor(promise) {
 		this.#promise = promise;
 	}
+	/**
+	* Lift a **synchronous** `Result` combinator over the wrapped promise.
+	*
+	* @remarks
+	* Every method below that does no `await` of its own is exactly its `Res`
+	* twin applied to the settled `Result` — same tag check, same try/catch, same
+	* throw→defect net. Delegating instead of restating it keeps the two surfaces
+	* from drifting: a fix to the sync combinator is the fix to the async one.
+	* The methods that DO await a callback's result (`flatMap`, `flatTap`,
+	* `bind`, `flatMapErrCases`, `flatTapErrCases`, `recoverDefect` — the ones
+	* whose callback may hand back an `AsyncResult`) genuinely differ and are
+	* still written out in full.
+	*
+	* @internal
+	*/
+	#lift(f) {
+		return new AsyncRes(this.#promise.then(f));
+	}
 	then(onfulfilled, onrejected) {
 		return this.#promise.then(onfulfilled, onrejected);
 	}
 	map(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Ok") return passThrough(r);
-			try {
-				return okRes(f(r.value));
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.map(f));
 	}
 	flatMap(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
@@ -694,15 +726,7 @@ var AsyncRes = class AsyncRes {
 		}));
 	}
 	tap(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Ok") return r;
-			try {
-				silenceIfThenable(f(r.value));
-				return r;
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.tap(f));
 	}
 	flatTap(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
@@ -733,45 +757,19 @@ var AsyncRes = class AsyncRes {
 		}));
 	}
 	let(name, f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Ok") return passThrough(r);
-			try {
-				return okRes({
-					...scopeOf(r.value),
-					[name]: f(r.value)
-				});
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.let(name, f));
 	}
 	as(value) {
-		return new AsyncRes(this.#promise.then((r) => r.tag === "Ok" ? okRes(value) : passThrough(r)));
+		return this.#lift((r) => r.as(value));
 	}
 	discard() {
-		return new AsyncRes(this.#promise.then((r) => r.tag === "Ok" ? okRes(void 0) : passThrough(r)));
+		return this.#lift((r) => r.discard());
 	}
 	ensure(predicate, onFail) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Ok") return passThrough(r);
-			try {
-				return predicate(r.value) ? r : errRes(onFail(r.value));
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.ensure(predicate, onFail));
 	}
 	mapErrCases(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Err") return passThrough(r);
-			try {
-				const out = runMatch(f, r.error);
-				if (isDefectMarker(out)) return defectRes(out.cause);
-				return errRes(out);
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.mapErrCases(f));
 	}
 	flatMapErrCases(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
@@ -788,29 +786,10 @@ var AsyncRes = class AsyncRes {
 		}));
 	}
 	recoverErrCases(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Err") return passThrough(r);
-			try {
-				const out = runMatch(f, r.error);
-				if (isDefectMarker(out)) return defectRes(out.cause);
-				return okRes(out);
-			} catch (cause) {
-				return defectRes(cause);
-			}
-		}));
+		return this.#lift((r) => r.recoverErrCases(f));
 	}
 	tapErrCases(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Err") return r;
-			try {
-				const out = runMatch(f, r.error);
-				if (isDefectMarker(out)) return observerThrowToDefect(out.cause, r.error);
-				silenceIfThenable(out);
-				return r;
-			} catch (cause) {
-				return observerThrowToDefect(cause, r.error);
-			}
-		}));
+		return this.#lift((r) => r.tapErrCases(f));
 	}
 	flatTapErrCases(f) {
 		return new AsyncRes(this.#promise.then(async (r) => {
@@ -838,26 +817,10 @@ var AsyncRes = class AsyncRes {
 		}));
 	}
 	tapDefect(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag !== "Defect") return r;
-			try {
-				silenceIfThenable(f(r.cause));
-				return r;
-			} catch (cause) {
-				return observerThrowToDefect(cause, r.cause);
-			}
-		}));
+		return this.#lift((r) => r.tapDefect(f));
 	}
 	tapFailure(f) {
-		return new AsyncRes(this.#promise.then((r) => {
-			if (r.tag === "Ok") return r;
-			try {
-				silenceIfThenable(f(r));
-				return r;
-			} catch (cause) {
-				return observerThrowToDefect(cause, r.tag === "Err" ? r.error : r.cause);
-			}
-		}));
+		return this.#lift((r) => r.tapFailure(f));
 	}
 	match(cases) {
 		return this.#promise.then((r) => r.match(cases));
@@ -1339,7 +1302,7 @@ function fromExecutor(executor) {
 			return;
 		}
 		if (!isResult(result)) {
-			if (isThenable(result)) Promise.resolve(result).then(void 0, () => void 0);
+			silenceIfThenable(result);
 			resolve(defectRes(/* @__PURE__ */ new TypeError("unthrown: fromExecutor's settle received a non-Result value")));
 			return;
 		}
@@ -1393,15 +1356,6 @@ function thenableReturnDefect(value) {
 	return defectRes(/* @__PURE__ */ new TypeError("unthrown: fromThrowable/fromSafeThrowable wrap a SYNCHRONOUS function, but `fn` returned a thenable — its rejection would escape qualification. Use fromPromise/fromSafePromise instead."));
 }
 /**
-* Runtime thenable probe for the belt-and-braces guards above. Called inside the
-* caller's `try`, so even a hostile `.then` getter lands on the Defect path.
-*
-* @internal
-*/
-function isThenable(x) {
-	return (typeof x === "object" || typeof x === "function") && x !== null && typeof x.then === "function";
-}
-/**
 * Fold an array of settled `Result`s: first `Err` wins, any `Defect` dominates,
 * else `Ok` of the values array.
 *
@@ -1430,32 +1384,23 @@ function foldArray(results) {
 }
 /**
 * Fold a record of settled `Result`s with the same rules, else `Ok` of the
-* record of values. Keys are written with `Object.defineProperty` so a
-* caller-supplied `"__proto__"` key cannot pollute the prototype.
+* record of values.
+*
+* @remarks
+* The positional fold already implements every rule (first `Err` wins, any
+* `Defect` dominates, a non-`Result` element becomes a `Defect`), so this pairs
+* the keys back onto its success value rather than restating them.
+*
+* `Object.fromEntries` is what makes a caller-supplied `"__proto__"` key safe:
+* it builds each key with CreateDataProperty, which defines an own property
+* instead of invoking the `__proto__` setter — the same guarantee the previous
+* explicit `Object.defineProperty` loop bought by hand.
 *
 * @internal
 */
 function foldRecord(results) {
-	let firstErr;
-	let firstDefect;
-	const values = {};
-	for (const [key, r] of Object.entries(results)) {
-		if (!isResult(r)) {
-			firstDefect ??= nonResultDefect();
-			break;
-		}
-		if (r.tag === "Defect") {
-			firstDefect ??= r;
-			break;
-		} else if (r.tag === "Err") firstErr ??= r;
-		else Object.defineProperty(values, key, {
-			value: r.value,
-			enumerable: true,
-			writable: true,
-			configurable: true
-		});
-	}
-	return firstDefect ?? firstErr ?? Ok(values);
+	const keys = Object.keys(results);
+	return foldArray(Object.values(results)).map((values) => Object.fromEntries(keys.map((key, i) => [key, values[i]])));
 }
 /**
 * Collect a tuple/array of {@link Result}s into a single `Result` of all their
@@ -1553,14 +1498,8 @@ function allAsync(results) {
 * ```
 */
 function allFromDictAsync(results) {
-	const entries = Object.entries(results);
-	return new AsyncRes(Promise.all(entries.map(([, ar]) => Promise.resolve(ar).then((x) => x, (cause) => defectRes(cause)))).then((resolved) => {
-		const byKey = Object.create(null);
-		entries.forEach(([key], i) => {
-			byKey[key] = resolved[i];
-		});
-		return foldRecord(byKey);
-	}));
+	const keys = Object.keys(results);
+	return new AsyncRes(Promise.all(Object.values(results).map((ar) => Promise.resolve(ar).then((x) => x, (cause) => defectRes(cause)))).then((resolved) => foldArray(resolved).map((values) => Object.fromEntries(keys.map((key, i) => [key, values[i]])))));
 }
 //#endregion
 //#region src/facade.ts

package/package.json

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