unthrown 5.2.0 → 5.4.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));
@@ -1288,6 +1251,72 @@ function fromPromise(promise, qualify, ..._guard) {
 function fromSafePromise(promise) {
 	return new AsyncRes((typeof promise === "function" ? Promise.resolve().then(promise) : Promise.resolve(promise)).then((value) => okRes(value), (cause) => defectRes(cause)));
 }
+/**
+* Build an {@link AsyncResult} from a callback-style API — this library's
+* answer to `new Promise((resolve, reject) => …)`.
+*
+* @remarks
+* The settler takes a **`Result`**, not a value-or-reason pair: the caller names
+* the variant, so no `unknown` can enter `E` and there is no `qualify` to pass.
+* For a failure that is *not* modeled, settle the injected `defect` helper's
+* marker — the same injection `qualify` receives, and the only way to reach the
+* defect channel from inside an asynchronous callback (a `throw` there runs in
+* its own turn, long after the executor body returned).
+*
+* `T` and `E` cannot be inferred from the body, since `settle` is a parameter.
+* Supply them explicitly, or let them flow from an annotated target. Absent
+* either, both default to `never` (Thesis #3: no path may produce `unknown` in
+* `E`) — so an unannotated call is a compile error at the `settle(...)` call
+* site, not a silently-`unknown` channel.
+*
+* An executor that never settles yields an `AsyncResult` that never resolves —
+* the one hazard {@link fromPromise} does not have, and identical to
+* `new Promise`.
+*
+* @typeParam T - the success type.
+* @typeParam E - the modeled error type.
+* @param executor - runs immediately; receives the settler and the `defect` helper.
+*
+* @category Interop
+*
+* @example
+* ```ts
+* import { fromExecutor, Err, Ok } from "unthrown";
+*
+* const listen = (port: number) =>
+*   fromExecutor<Server, PortInUse>((settle, defect) => {
+*     server.once("error", (cause) =>
+*       isAddrInUse(cause) ? settle(Err(new PortInUse(port))) : settle(defect(cause)),
+*     );
+*     server.listen(port, () => settle(Ok(server)));
+*   });
+* ```
+*/
+function fromExecutor(executor) {
+	let resolve;
+	const promise = new Promise((r) => {
+		resolve = r;
+	});
+	const settle = (result) => {
+		if (isDefectMarker(result)) {
+			resolve(defectRes(result.cause));
+			return;
+		}
+		if (!isResult(result)) {
+			silenceIfThenable(result);
+			resolve(defectRes(/* @__PURE__ */ new TypeError("unthrown: fromExecutor's settle received a non-Result value")));
+			return;
+		}
+		resolve(result);
+	};
+	try {
+		const returned = executor(settle, defect);
+		if (isThenable(returned)) Promise.resolve(returned).then(void 0, (cause) => settle(defect(cause)));
+	} catch (cause) {
+		settle(defect(cause));
+	}
+	return new AsyncRes(promise);
+}
 function qualifyToResult(cause, qualify) {
 	try {
 		const q = qualify(cause, defect);
@@ -1328,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.
 *
@@ -1365,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
@@ -1488,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
@@ -1542,14 +1547,15 @@ const Result = {
 /**
 * Companion object grouping the **`AsyncResult`-producing** entry points under
 * the matching namespace: {@link AsyncResult.Ok}, {@link AsyncResult.Err},
-* {@link AsyncResult.Do}, {@link AsyncResult.fromPromise},
-* {@link AsyncResult.fromSafePromise}, {@link AsyncResult.all},
-* {@link AsyncResult.allFromDict}.
+* {@link AsyncResult.Do}, {@link AsyncResult.fromExecutor},
+* {@link AsyncResult.fromPromise}, {@link AsyncResult.fromSafePromise},
+* {@link AsyncResult.all}, {@link AsyncResult.allFromDict}.
 *
 * @remarks
 * The async sibling of {@link Result}. Statics are grouped by what they
-* **return**, so the pre-lifted constructors, `fromPromise`/`fromSafePromise`,
-* and the async aggregates sit here rather than on {@link Result}; the namespace
+* **return**, so the pre-lifted constructors, `fromExecutor`,
+* `fromPromise`/`fromSafePromise`, and the async aggregates sit here rather
+* than on {@link Result}; the namespace
 * already conveys "async", so the members drop the `Async` suffix their free
 * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is
 * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;
@@ -1574,6 +1580,7 @@ const AsyncResult = {
 	Ok: OkAsync,
 	Err: ErrAsync,
 	Do: DoAsync,
+	fromExecutor,
 	fromPromise,
 	fromSafePromise,
 	all: allAsync,
@@ -1686,6 +1693,7 @@ exports.all = all;
 exports.allAsync = allAsync;
 exports.allFromDict = allFromDict;
 exports.allFromDictAsync = allFromDictAsync;
+exports.fromExecutor = fromExecutor;
 exports.fromNullable = fromNullable;
 exports.fromPromise = fromPromise;
 exports.fromSafePromise = fromSafePromise;

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
@@ -1720,6 +1717,59 @@ declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qua
  * ```
  */
 declare function fromSafePromise<T>(promise: Promise<T> | (() => Promise<T>)): AsyncResult$1<T, never>;
+/**
+ * The settler a {@link fromExecutor} executor receives. Settles the pending
+ * `AsyncResult` **once** — later calls are no-ops, exactly as `resolve` is on a
+ * `Promise`.
+ *
+ * @typeParam T - the success type.
+ * @typeParam E - the modeled error type.
+ *
+ * @category Types
+ */
+type Settle<T, E> = (result: Result$1<T, E> | Defect) => void;
+/**
+ * Build an {@link AsyncResult} from a callback-style API — this library's
+ * answer to `new Promise((resolve, reject) => …)`.
+ *
+ * @remarks
+ * The settler takes a **`Result`**, not a value-or-reason pair: the caller names
+ * the variant, so no `unknown` can enter `E` and there is no `qualify` to pass.
+ * For a failure that is *not* modeled, settle the injected `defect` helper's
+ * marker — the same injection `qualify` receives, and the only way to reach the
+ * defect channel from inside an asynchronous callback (a `throw` there runs in
+ * its own turn, long after the executor body returned).
+ *
+ * `T` and `E` cannot be inferred from the body, since `settle` is a parameter.
+ * Supply them explicitly, or let them flow from an annotated target. Absent
+ * either, both default to `never` (Thesis #3: no path may produce `unknown` in
+ * `E`) — so an unannotated call is a compile error at the `settle(...)` call
+ * site, not a silently-`unknown` channel.
+ *
+ * An executor that never settles yields an `AsyncResult` that never resolves —
+ * the one hazard {@link fromPromise} does not have, and identical to
+ * `new Promise`.
+ *
+ * @typeParam T - the success type.
+ * @typeParam E - the modeled error type.
+ * @param executor - runs immediately; receives the settler and the `defect` helper.
+ *
+ * @category Interop
+ *
+ * @example
+ * ```ts
+ * import { fromExecutor, Err, Ok } from "unthrown";
+ *
+ * const listen = (port: number) =>
+ *   fromExecutor<Server, PortInUse>((settle, defect) => {
+ *     server.once("error", (cause) =>
+ *       isAddrInUse(cause) ? settle(Err(new PortInUse(port))) : settle(defect(cause)),
+ *     );
+ *     server.listen(port, () => settle(Ok(server)));
+ *   });
+ * ```
+ */
+declare function fromExecutor<T = never, E = never>(executor: (settle: Settle<T, E>, defect: (cause: unknown) => Defect) => void): AsyncResult$1<T, E>;
 /**
  * The success channel of {@link all} / {@link allAsync}: a **positional tuple**
  * for a fixed-length input (including the empty tuple), or a homogeneous
@@ -1892,14 +1942,15 @@ type Result<T, E> = Result$1<T, E>;
 /**
  * Companion object grouping the **`AsyncResult`-producing** entry points under
  * the matching namespace: {@link AsyncResult.Ok}, {@link AsyncResult.Err},
- * {@link AsyncResult.Do}, {@link AsyncResult.fromPromise},
- * {@link AsyncResult.fromSafePromise}, {@link AsyncResult.all},
- * {@link AsyncResult.allFromDict}.
+ * {@link AsyncResult.Do}, {@link AsyncResult.fromExecutor},
+ * {@link AsyncResult.fromPromise}, {@link AsyncResult.fromSafePromise},
+ * {@link AsyncResult.all}, {@link AsyncResult.allFromDict}.
  *
  * @remarks
  * The async sibling of {@link Result}. Statics are grouped by what they
- * **return**, so the pre-lifted constructors, `fromPromise`/`fromSafePromise`,
- * and the async aggregates sit here rather than on {@link Result}; the namespace
+ * **return**, so the pre-lifted constructors, `fromExecutor`,
+ * `fromPromise`/`fromSafePromise`, and the async aggregates sit here rather
+ * than on {@link Result}; the namespace
  * already conveys "async", so the members drop the `Async` suffix their free
  * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is
  * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;
@@ -1924,6 +1975,7 @@ declare const AsyncResult: {
   readonly Ok: typeof OkAsync;
   readonly Err: typeof ErrAsync;
   readonly Do: typeof DoAsync;
+  readonly fromExecutor: typeof fromExecutor;
   readonly fromPromise: typeof fromPromise;
   readonly fromSafePromise: typeof fromSafePromise;
   readonly all: typeof allAsync;
@@ -2052,4 +2104,4 @@ declare function TaggedError<Tag extends string>(tag: Tag, options?: {
   readonly name?: string;
 }): TaggedErrorConstructor<Tag>;
 //#endregion
-export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, DoAsync, Err, ErrAsync, type ErrMatcher, type ErrOf, type ErrView, type FailureView, GetError, type Matcher, NonExhaustiveError, type NotThenable, Ok, OkAsync, type OkOf, type OkView, P, type PatternMatcher, Result, type ResultMethods, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match };
+export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, DoAsync, Err, ErrAsync, type ErrMatcher, type ErrOf, type ErrView, type FailureView, GetError, type Matcher, NonExhaustiveError, type NotThenable, Ok, OkAsync, type OkOf, type OkView, P, type PatternMatcher, Result, type ResultMethods, type Settle, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromExecutor, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match };

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
@@ -1720,6 +1717,59 @@ declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qua
  * ```
  */
 declare function fromSafePromise<T>(promise: Promise<T> | (() => Promise<T>)): AsyncResult$1<T, never>;
+/**
+ * The settler a {@link fromExecutor} executor receives. Settles the pending
+ * `AsyncResult` **once** — later calls are no-ops, exactly as `resolve` is on a
+ * `Promise`.
+ *
+ * @typeParam T - the success type.
+ * @typeParam E - the modeled error type.
+ *
+ * @category Types
+ */
+type Settle<T, E> = (result: Result$1<T, E> | Defect) => void;
+/**
+ * Build an {@link AsyncResult} from a callback-style API — this library's
+ * answer to `new Promise((resolve, reject) => …)`.
+ *
+ * @remarks
+ * The settler takes a **`Result`**, not a value-or-reason pair: the caller names
+ * the variant, so no `unknown` can enter `E` and there is no `qualify` to pass.
+ * For a failure that is *not* modeled, settle the injected `defect` helper's
+ * marker — the same injection `qualify` receives, and the only way to reach the
+ * defect channel from inside an asynchronous callback (a `throw` there runs in
+ * its own turn, long after the executor body returned).
+ *
+ * `T` and `E` cannot be inferred from the body, since `settle` is a parameter.
+ * Supply them explicitly, or let them flow from an annotated target. Absent
+ * either, both default to `never` (Thesis #3: no path may produce `unknown` in
+ * `E`) — so an unannotated call is a compile error at the `settle(...)` call
+ * site, not a silently-`unknown` channel.
+ *
+ * An executor that never settles yields an `AsyncResult` that never resolves —
+ * the one hazard {@link fromPromise} does not have, and identical to
+ * `new Promise`.
+ *
+ * @typeParam T - the success type.
+ * @typeParam E - the modeled error type.
+ * @param executor - runs immediately; receives the settler and the `defect` helper.
+ *
+ * @category Interop
+ *
+ * @example
+ * ```ts
+ * import { fromExecutor, Err, Ok } from "unthrown";
+ *
+ * const listen = (port: number) =>
+ *   fromExecutor<Server, PortInUse>((settle, defect) => {
+ *     server.once("error", (cause) =>
+ *       isAddrInUse(cause) ? settle(Err(new PortInUse(port))) : settle(defect(cause)),
+ *     );
+ *     server.listen(port, () => settle(Ok(server)));
+ *   });
+ * ```
+ */
+declare function fromExecutor<T = never, E = never>(executor: (settle: Settle<T, E>, defect: (cause: unknown) => Defect) => void): AsyncResult$1<T, E>;
 /**
  * The success channel of {@link all} / {@link allAsync}: a **positional tuple**
  * for a fixed-length input (including the empty tuple), or a homogeneous
@@ -1892,14 +1942,15 @@ type Result<T, E> = Result$1<T, E>;
 /**
  * Companion object grouping the **`AsyncResult`-producing** entry points under
  * the matching namespace: {@link AsyncResult.Ok}, {@link AsyncResult.Err},
- * {@link AsyncResult.Do}, {@link AsyncResult.fromPromise},
- * {@link AsyncResult.fromSafePromise}, {@link AsyncResult.all},
- * {@link AsyncResult.allFromDict}.
+ * {@link AsyncResult.Do}, {@link AsyncResult.fromExecutor},
+ * {@link AsyncResult.fromPromise}, {@link AsyncResult.fromSafePromise},
+ * {@link AsyncResult.all}, {@link AsyncResult.allFromDict}.
  *
  * @remarks
  * The async sibling of {@link Result}. Statics are grouped by what they
- * **return**, so the pre-lifted constructors, `fromPromise`/`fromSafePromise`,
- * and the async aggregates sit here rather than on {@link Result}; the namespace
+ * **return**, so the pre-lifted constructors, `fromExecutor`,
+ * `fromPromise`/`fromSafePromise`, and the async aggregates sit here rather
+ * than on {@link Result}; the namespace
  * already conveys "async", so the members drop the `Async` suffix their free
  * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is
  * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;
@@ -1924,6 +1975,7 @@ declare const AsyncResult: {
   readonly Ok: typeof OkAsync;
   readonly Err: typeof ErrAsync;
   readonly Do: typeof DoAsync;
+  readonly fromExecutor: typeof fromExecutor;
   readonly fromPromise: typeof fromPromise;
   readonly fromSafePromise: typeof fromSafePromise;
   readonly all: typeof allAsync;
@@ -2052,4 +2104,4 @@ declare function TaggedError<Tag extends string>(tag: Tag, options?: {
   readonly name?: string;
 }): TaggedErrorConstructor<Tag>;
 //#endregion
-export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, DoAsync, Err, ErrAsync, type ErrMatcher, type ErrOf, type ErrView, type FailureView, GetError, type Matcher, NonExhaustiveError, type NotThenable, Ok, OkAsync, type OkOf, type OkView, P, type PatternMatcher, Result, type ResultMethods, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match };
+export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, DoAsync, Err, ErrAsync, type ErrMatcher, type ErrOf, type ErrView, type FailureView, GetError, type Matcher, NonExhaustiveError, type NotThenable, Ok, OkAsync, type OkOf, type OkView, P, type PatternMatcher, Result, type ResultMethods, type Settle, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromExecutor, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match };

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));
@@ -1287,6 +1250,72 @@ function fromPromise(promise, qualify, ..._guard) {
 function fromSafePromise(promise) {
 	return new AsyncRes((typeof promise === "function" ? Promise.resolve().then(promise) : Promise.resolve(promise)).then((value) => okRes(value), (cause) => defectRes(cause)));
 }
+/**
+* Build an {@link AsyncResult} from a callback-style API — this library's
+* answer to `new Promise((resolve, reject) => …)`.
+*
+* @remarks
+* The settler takes a **`Result`**, not a value-or-reason pair: the caller names
+* the variant, so no `unknown` can enter `E` and there is no `qualify` to pass.
+* For a failure that is *not* modeled, settle the injected `defect` helper's
+* marker — the same injection `qualify` receives, and the only way to reach the
+* defect channel from inside an asynchronous callback (a `throw` there runs in
+* its own turn, long after the executor body returned).
+*
+* `T` and `E` cannot be inferred from the body, since `settle` is a parameter.
+* Supply them explicitly, or let them flow from an annotated target. Absent
+* either, both default to `never` (Thesis #3: no path may produce `unknown` in
+* `E`) — so an unannotated call is a compile error at the `settle(...)` call
+* site, not a silently-`unknown` channel.
+*
+* An executor that never settles yields an `AsyncResult` that never resolves —
+* the one hazard {@link fromPromise} does not have, and identical to
+* `new Promise`.
+*
+* @typeParam T - the success type.
+* @typeParam E - the modeled error type.
+* @param executor - runs immediately; receives the settler and the `defect` helper.
+*
+* @category Interop
+*
+* @example
+* ```ts
+* import { fromExecutor, Err, Ok } from "unthrown";
+*
+* const listen = (port: number) =>
+*   fromExecutor<Server, PortInUse>((settle, defect) => {
+*     server.once("error", (cause) =>
+*       isAddrInUse(cause) ? settle(Err(new PortInUse(port))) : settle(defect(cause)),
+*     );
+*     server.listen(port, () => settle(Ok(server)));
+*   });
+* ```
+*/
+function fromExecutor(executor) {
+	let resolve;
+	const promise = new Promise((r) => {
+		resolve = r;
+	});
+	const settle = (result) => {
+		if (isDefectMarker(result)) {
+			resolve(defectRes(result.cause));
+			return;
+		}
+		if (!isResult(result)) {
+			silenceIfThenable(result);
+			resolve(defectRes(/* @__PURE__ */ new TypeError("unthrown: fromExecutor's settle received a non-Result value")));
+			return;
+		}
+		resolve(result);
+	};
+	try {
+		const returned = executor(settle, defect);
+		if (isThenable(returned)) Promise.resolve(returned).then(void 0, (cause) => settle(defect(cause)));
+	} catch (cause) {
+		settle(defect(cause));
+	}
+	return new AsyncRes(promise);
+}
 function qualifyToResult(cause, qualify) {
 	try {
 		const q = qualify(cause, defect);
@@ -1327,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.
 *
@@ -1364,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
@@ -1487,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
@@ -1541,14 +1546,15 @@ const Result = {
 /**
 * Companion object grouping the **`AsyncResult`-producing** entry points under
 * the matching namespace: {@link AsyncResult.Ok}, {@link AsyncResult.Err},
-* {@link AsyncResult.Do}, {@link AsyncResult.fromPromise},
-* {@link AsyncResult.fromSafePromise}, {@link AsyncResult.all},
-* {@link AsyncResult.allFromDict}.
+* {@link AsyncResult.Do}, {@link AsyncResult.fromExecutor},
+* {@link AsyncResult.fromPromise}, {@link AsyncResult.fromSafePromise},
+* {@link AsyncResult.all}, {@link AsyncResult.allFromDict}.
 *
 * @remarks
 * The async sibling of {@link Result}. Statics are grouped by what they
-* **return**, so the pre-lifted constructors, `fromPromise`/`fromSafePromise`,
-* and the async aggregates sit here rather than on {@link Result}; the namespace
+* **return**, so the pre-lifted constructors, `fromExecutor`,
+* `fromPromise`/`fromSafePromise`, and the async aggregates sit here rather
+* than on {@link Result}; the namespace
 * already conveys "async", so the members drop the `Async` suffix their free
 * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is
 * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;
@@ -1573,6 +1579,7 @@ const AsyncResult = {
 	Ok: OkAsync,
 	Err: ErrAsync,
 	Do: DoAsync,
+	fromExecutor,
 	fromPromise,
 	fromSafePromise,
 	all: allAsync,
@@ -1669,4 +1676,4 @@ function TaggedError(tag, options) {
 	return TaggedErrorBase;
 }
 //#endregion
-export { AsyncResult, Do, DoAsync, Err, ErrAsync, GetError, NonExhaustiveError, Ok, OkAsync, P, Result, TaggedError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match };
+export { AsyncResult, Do, DoAsync, Err, ErrAsync, GetError, NonExhaustiveError, Ok, OkAsync, P, Result, TaggedError, all, allAsync, allFromDict, allFromDictAsync, fromExecutor, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match };

package/package.json

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