unthrown 5.0.0 → 5.1.0

package/dist/index.cjs

@@ -25,7 +25,7 @@ var NonExhaustiveError = class extends Error {
 	constructor(input) {
 		let printed;
 		try {
-			printed = JSON.stringify(input);
+			printed = JSON.stringify(input) ?? String(input);
 		} catch {
 			printed = String(input);
 		}
@@ -261,7 +261,7 @@ var Res = class {
 		if (this.tag !== "Ok") return passThrough(this);
 		try {
 			const r = f(this.value);
-			return isResult(r) ? r : nonResultCallbackDefect();
+			return isResult(r) ? r : nonResultCallbackDefect(r);
 		} catch (cause) {
 			return defectRes(cause);
 		}
@@ -269,7 +269,7 @@ var Res = class {
 	tap(f) {
 		if (this.tag !== "Ok") return this;
 		try {
-			f(this.value);
+			silenceIfThenable(f(this.value));
 			return this;
 		} catch (cause) {
 			return defectRes(cause);
@@ -279,7 +279,7 @@ var Res = class {
 		if (this.tag !== "Ok") return this;
 		try {
 			const r = f(this.value);
-			if (!isResult(r)) return nonResultCallbackDefect();
+			if (!isResult(r)) return nonResultCallbackDefect(r);
 			return r.tag === "Ok" ? this : passThrough(r);
 		} catch (cause) {
 			return defectRes(cause);
@@ -289,7 +289,7 @@ var Res = class {
 		if (this.tag !== "Ok") return passThrough(this);
 		try {
 			const r = f(this.value);
-			if (!isResult(r)) return nonResultCallbackDefect();
+			if (!isResult(r)) return nonResultCallbackDefect(r);
 			if (r.tag !== "Ok") return passThrough(r);
 			return okRes({
 				...scopeOf(this.value),
@@ -341,7 +341,7 @@ var Res = class {
 		try {
 			const out = runMatch(f, this.error);
 			if (isDefectMarker(out)) return defectRes(out.cause);
-			if (!isResult(out)) return nonResultCallbackDefect();
+			if (!isResult(out)) return nonResultCallbackDefect(out);
 			return out;
 		} catch (cause) {
 			return defectRes(cause);
@@ -362,6 +362,7 @@ var Res = class {
 		try {
 			const out = runMatch(f, this.error);
 			if (isDefectMarker(out)) return observerThrowToDefect(out.cause, this.error);
+			silenceIfThenable(out);
 			return this;
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.error);
@@ -372,7 +373,7 @@ var Res = class {
 		try {
 			const r = runMatch(f, this.error);
 			if (isDefectMarker(r)) return observerThrowToDefect(r.cause, this.error);
-			if (!isResult(r)) return nonResultCallbackDefect();
+			if (!isResult(r)) return nonResultCallbackDefect(r);
 			return r.tag === "Ok" ? this : passThrough(r);
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.error);
@@ -382,7 +383,7 @@ var Res = class {
 		if (this.tag !== "Defect") return this;
 		try {
 			const r = f(this.cause);
-			return isResult(r) ? r : nonResultCallbackDefect();
+			return isResult(r) ? r : nonResultCallbackDefect(r);
 		} catch (cause) {
 			return defectRes(cause);
 		}
@@ -390,7 +391,7 @@ var Res = class {
 	tapDefect(f) {
 		if (this.tag !== "Defect") return this;
 		try {
-			f(this.cause);
+			silenceIfThenable(f(this.cause));
 			return this;
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.cause);
@@ -399,7 +400,7 @@ var Res = class {
 	tapFailure(f) {
 		if (this.tag === "Ok") return this;
 		try {
-			f(this);
+			silenceIfThenable(f(this));
 			return this;
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.tag === "Err" ? this.error : this.cause);
@@ -564,6 +565,30 @@ function passThrough(self) {
 	return self;
 }
 /**
+* Adopt-and-silence a thenable a combinator is about to **discard**.
+*
+* @remarks
+* The observers (`tap`, `tapErrCases`, `tapDefect`, `tapFailure`) throw their
+* callback's return value away, and the `Result`-returning combinators reject a
+* non-`Result` one. Either way, a thenable that slipped past `NotThenable` (a
+* cast, a raw-JS caller) is dropped while still in flight — and if it later
+* rejects, nothing is holding it, so the rejection floats unhandled and takes
+* the process down on Node by default. Worse for an observer: its whole job is
+* to make a failure visible, and this is the one path where the failure is
+* invisible.
+*
+* Adopting it costs one microtask and makes the rejection a no-op. The
+* boundaries already do exactly this for a thenable `qualify` and a thenable
+* `fn` (see `interop.ts`); this is the same net on the combinator side.
+*
+* @internal
+*/
+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);
+	} catch {}
+}
+/**
 * The Defect minted when a callback constrained to return a `Result` returns
 * something else — reachable only from untyped/cast callers (in typed code the
 * constraint is a compile error). The combinator-side sibling of the
@@ -573,7 +598,8 @@ function passThrough(self) {
 *
 * @internal
 */
-function nonResultCallbackDefect() {
+function nonResultCallbackDefect(returned) {
+	silenceIfThenable(returned);
 	return defectRes(/* @__PURE__ */ new TypeError("unthrown: a combinator callback returned a non-Result value"));
 }
 /**
@@ -658,7 +684,7 @@ var AsyncRes = class AsyncRes {
 			if (r.tag !== "Ok") return passThrough(r);
 			try {
 				const inner = await f(r.value);
-				return isResult(inner) ? inner : nonResultCallbackDefect();
+				return isResult(inner) ? inner : nonResultCallbackDefect(inner);
 			} catch (cause) {
 				return defectRes(cause);
 			}
@@ -668,7 +694,7 @@ var AsyncRes = class AsyncRes {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Ok") return r;
 			try {
-				f(r.value);
+				silenceIfThenable(f(r.value));
 				return r;
 			} catch (cause) {
 				return defectRes(cause);
@@ -680,7 +706,7 @@ var AsyncRes = class AsyncRes {
 			if (r.tag !== "Ok") return passThrough(r);
 			try {
 				const inner = await f(r.value);
-				if (!isResult(inner)) return nonResultCallbackDefect();
+				if (!isResult(inner)) return nonResultCallbackDefect(inner);
 				return inner.tag === "Ok" ? r : passThrough(inner);
 			} catch (cause) {
 				return defectRes(cause);
@@ -692,7 +718,7 @@ var AsyncRes = class AsyncRes {
 			if (r.tag !== "Ok") return passThrough(r);
 			try {
 				const inner = await f(r.value);
-				if (!isResult(inner)) return nonResultCallbackDefect();
+				if (!isResult(inner)) return nonResultCallbackDefect(inner);
 				if (inner.tag !== "Ok") return passThrough(inner);
 				return okRes({
 					...scopeOf(r.value),
@@ -751,7 +777,7 @@ var AsyncRes = class AsyncRes {
 				const out = runMatch(f, r.error);
 				if (isDefectMarker(out)) return defectRes(out.cause);
 				const inner = await out;
-				if (!isResult(inner)) return nonResultCallbackDefect();
+				if (!isResult(inner)) return nonResultCallbackDefect(inner);
 				return inner;
 			} catch (cause) {
 				return defectRes(cause);
@@ -776,6 +802,7 @@ var AsyncRes = class AsyncRes {
 			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);
@@ -789,7 +816,7 @@ var AsyncRes = class AsyncRes {
 				const out = runMatch(f, r.error);
 				if (isDefectMarker(out)) return observerThrowToDefect(out.cause, r.error);
 				const inner = await out;
-				if (!isResult(inner)) return nonResultCallbackDefect();
+				if (!isResult(inner)) return nonResultCallbackDefect(inner);
 				return inner.tag === "Ok" ? passThrough(r) : passThrough(inner);
 			} catch (cause) {
 				return observerThrowToDefect(cause, r.error);
@@ -801,7 +828,7 @@ var AsyncRes = class AsyncRes {
 			if (r.tag !== "Defect") return r;
 			try {
 				const inner = await f(r.cause);
-				return isResult(inner) ? inner : nonResultCallbackDefect();
+				return isResult(inner) ? inner : nonResultCallbackDefect(inner);
 			} catch (cause) {
 				return defectRes(cause);
 			}
@@ -811,7 +838,7 @@ var AsyncRes = class AsyncRes {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Defect") return r;
 			try {
-				f(r.cause);
+				silenceIfThenable(f(r.cause));
 				return r;
 			} catch (cause) {
 				return observerThrowToDefect(cause, r.cause);
@@ -822,7 +849,7 @@ var AsyncRes = class AsyncRes {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag === "Ok") return r;
 			try {
-				f(r);
+				silenceIfThenable(f(r));
 				return r;
 			} catch (cause) {
 				return observerThrowToDefect(cause, r.tag === "Err" ? r.error : r.cause);
@@ -1090,6 +1117,11 @@ function fromNullable(value, onAbsent) {
 * — and a thenable slipped past the types at runtime becomes a `Defect` (never
 * an `Err(Promise)`), its orphaned rejection silenced.
 *
+* `fn` is **synchronous** too. An `async` `fn` rejects *after* this boundary has
+* already returned, so its rejection could never reach `qualify`: it becomes a
+* `Defect` (never `Ok(<Promise>)`) and the orphaned rejection is silenced rather
+* than left to float. Reach for {@link fromPromise} to wrap async work.
+*
 * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
 * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
 * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is
@@ -1126,7 +1158,8 @@ function fromThrowable(fn, qualify) {
 	const triage = qualify;
 	return (...args) => {
 		try {
-			return Ok(fn(...args));
+			const value = fn(...args);
+			return isThenable(value) ? thenableReturnDefect(value) : Ok(value);
 		} catch (cause) {
 			return qualifyToResult(cause, triage);
 		}
@@ -1143,6 +1176,10 @@ function fromThrowable(fn, qualify) {
 * `qualify`. When some throws *are* anticipated, reach for
 * {@link fromThrowable} and triage them.
 *
+* `fn` is **synchronous**: an `async` `fn` becomes a `Defect` (never
+* `Ok(<Promise>)`), with its orphaned rejection silenced rather than left to
+* float. Reach for {@link fromSafePromise} to wrap async work.
+*
 * @typeParam A - the wrapped function's argument tuple.
 * @typeParam T - the wrapped function's return type.
 * @param fn - the throwing function to wrap.
@@ -1164,7 +1201,8 @@ function fromThrowable(fn, qualify) {
 function fromSafeThrowable(fn) {
 	return (...args) => {
 		try {
-			return Ok(fn(...args));
+			const value = fn(...args);
+			return isThenable(value) ? thenableReturnDefect(value) : Ok(value);
 		} catch (cause) {
 			return defectRes(cause);
 		}
@@ -1260,7 +1298,33 @@ function qualifyToResult(cause, qualify) {
 	}
 }
 /**
-* Runtime thenable probe for the belt-and-braces guard above. Called inside the
+* The Defect minted when a **synchronous** boundary's `fn` returns a thenable —
+* i.e. an `async` function was handed to {@link fromThrowable} /
+* {@link fromSafeThrowable}.
+*
+* @remarks
+* This is the sibling of the thenable-`qualify` net in {@link qualifyToResult},
+* and it closes a strictly worse hole. A synchronous boundary only ever sees a
+* synchronous `throw`, so an async `fn`'s rejection never reaches `qualify` at
+* all: it would sit inside `Ok(<Promise>)`, un-triaged, and then float as an
+* unhandled rejection — which terminates the process on Node by default.
+*
+* Unlike the combinator callbacks, this cannot be banned at compile time
+* without collateral damage: `T & NotThenable<T>` on `fn`'s return makes a
+* **generic** function unassignable, so `fromSafeThrowable(structuredClone)`
+* stops compiling and `T` collapses to `unknown`. (The phantom rest-tuple guard
+* `fromPromise` uses fares worse.) So the ban is enforced here, at runtime,
+* where it costs nothing: a Defect, plus adopt-and-silence so the orphaned
+* rejection cannot float.
+*
+* @internal
+*/
+function thenableReturnDefect(value) {
+	Promise.resolve(value).then(void 0, () => void 0);
+	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

package/dist/index.d.cts

@@ -296,10 +296,17 @@ type Bound<T, K extends string, U> = Prettify<Omit<T, K> & { readonly [P in K]:
  * would escape the pipeline as an unhandled rejection instead of a `Defect`.
  * Lift async work with {@link fromPromise} and compose it with `flatMap`.
  *
+ * Spelled with `Extract`, not `[R] extends [PromiseLike<…>]`, so the ban also
+ * fires when only SOME arms of a union return are thenable — a *sometimes*-async
+ * callback (`flag ? 1 : work()`) is still an unawaited effect whose rejection
+ * the pipeline never sees. The tuple-wrapped form is false for a partial union
+ * and let exactly that through. This is the same reasoning `fromPromise`'s
+ * async-qualify guard already used.
+ *
  * @typeParam R - the callback's inferred return type.
  * @category Types
  */
-type NotThenable<R> = [R] extends [PromiseLike<unknown>] ? "unthrown: combinator callbacks are synchronous — lift async work with fromPromise and compose with flatMap" : unknown;
+type NotThenable<R> = [Extract<R, PromiseLike<unknown>>] extends [never] ? unknown : "unthrown: combinator callbacks are synchronous — lift async work with fromPromise and compose with flatMap";
 /**
  * The built-in match builder over an error union `E`, as produced by
  * `match(error)`. This is what an error combinator's callback receives — chain
@@ -1558,6 +1565,11 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  * — and a thenable slipped past the types at runtime becomes a `Defect` (never
  * an `Err(Promise)`), its orphaned rejection silenced.
  *
+ * `fn` is **synchronous** too. An `async` `fn` rejects *after* this boundary has
+ * already returned, so its rejection could never reach `qualify`: it becomes a
+ * `Defect` (never `Ok(<Promise>)`) and the orphaned rejection is silenced rather
+ * than left to float. Reach for {@link fromPromise} to wrap async work.
+ *
  * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
  * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
  * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is
@@ -1602,6 +1614,10 @@ declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T,
  * `qualify`. When some throws *are* anticipated, reach for
  * {@link fromThrowable} and triage them.
  *
+ * `fn` is **synchronous**: an `async` `fn` becomes a `Defect` (never
+ * `Ok(<Promise>)`), with its orphaned rejection silenced rather than left to
+ * float. Reach for {@link fromSafePromise} to wrap async work.
+ *
  * @typeParam A - the wrapped function's argument tuple.
  * @typeParam T - the wrapped function's return type.
  * @param fn - the throwing function to wrap.

package/dist/index.d.mts

@@ -296,10 +296,17 @@ type Bound<T, K extends string, U> = Prettify<Omit<T, K> & { readonly [P in K]:
  * would escape the pipeline as an unhandled rejection instead of a `Defect`.
  * Lift async work with {@link fromPromise} and compose it with `flatMap`.
  *
+ * Spelled with `Extract`, not `[R] extends [PromiseLike<…>]`, so the ban also
+ * fires when only SOME arms of a union return are thenable — a *sometimes*-async
+ * callback (`flag ? 1 : work()`) is still an unawaited effect whose rejection
+ * the pipeline never sees. The tuple-wrapped form is false for a partial union
+ * and let exactly that through. This is the same reasoning `fromPromise`'s
+ * async-qualify guard already used.
+ *
  * @typeParam R - the callback's inferred return type.
  * @category Types
  */
-type NotThenable<R> = [R] extends [PromiseLike<unknown>] ? "unthrown: combinator callbacks are synchronous — lift async work with fromPromise and compose with flatMap" : unknown;
+type NotThenable<R> = [Extract<R, PromiseLike<unknown>>] extends [never] ? unknown : "unthrown: combinator callbacks are synchronous — lift async work with fromPromise and compose with flatMap";
 /**
  * The built-in match builder over an error union `E`, as produced by
  * `match(error)`. This is what an error combinator's callback receives — chain
@@ -1558,6 +1565,11 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  * — and a thenable slipped past the types at runtime becomes a `Defect` (never
  * an `Err(Promise)`), its orphaned rejection silenced.
  *
+ * `fn` is **synchronous** too. An `async` `fn` rejects *after* this boundary has
+ * already returned, so its rejection could never reach `qualify`: it becomes a
+ * `Defect` (never `Ok(<Promise>)`) and the orphaned rejection is silenced rather
+ * than left to float. Reach for {@link fromPromise} to wrap async work.
+ *
  * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
  * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
  * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is
@@ -1602,6 +1614,10 @@ declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T,
  * `qualify`. When some throws *are* anticipated, reach for
  * {@link fromThrowable} and triage them.
  *
+ * `fn` is **synchronous**: an `async` `fn` becomes a `Defect` (never
+ * `Ok(<Promise>)`), with its orphaned rejection silenced rather than left to
+ * float. Reach for {@link fromSafePromise} to wrap async work.
+ *
  * @typeParam A - the wrapped function's argument tuple.
  * @typeParam T - the wrapped function's return type.
  * @param fn - the throwing function to wrap.

package/dist/index.mjs

@@ -24,7 +24,7 @@ var NonExhaustiveError = class extends Error {
 	constructor(input) {
 		let printed;
 		try {
-			printed = JSON.stringify(input);
+			printed = JSON.stringify(input) ?? String(input);
 		} catch {
 			printed = String(input);
 		}
@@ -260,7 +260,7 @@ var Res = class {
 		if (this.tag !== "Ok") return passThrough(this);
 		try {
 			const r = f(this.value);
-			return isResult(r) ? r : nonResultCallbackDefect();
+			return isResult(r) ? r : nonResultCallbackDefect(r);
 		} catch (cause) {
 			return defectRes(cause);
 		}
@@ -268,7 +268,7 @@ var Res = class {
 	tap(f) {
 		if (this.tag !== "Ok") return this;
 		try {
-			f(this.value);
+			silenceIfThenable(f(this.value));
 			return this;
 		} catch (cause) {
 			return defectRes(cause);
@@ -278,7 +278,7 @@ var Res = class {
 		if (this.tag !== "Ok") return this;
 		try {
 			const r = f(this.value);
-			if (!isResult(r)) return nonResultCallbackDefect();
+			if (!isResult(r)) return nonResultCallbackDefect(r);
 			return r.tag === "Ok" ? this : passThrough(r);
 		} catch (cause) {
 			return defectRes(cause);
@@ -288,7 +288,7 @@ var Res = class {
 		if (this.tag !== "Ok") return passThrough(this);
 		try {
 			const r = f(this.value);
-			if (!isResult(r)) return nonResultCallbackDefect();
+			if (!isResult(r)) return nonResultCallbackDefect(r);
 			if (r.tag !== "Ok") return passThrough(r);
 			return okRes({
 				...scopeOf(this.value),
@@ -340,7 +340,7 @@ var Res = class {
 		try {
 			const out = runMatch(f, this.error);
 			if (isDefectMarker(out)) return defectRes(out.cause);
-			if (!isResult(out)) return nonResultCallbackDefect();
+			if (!isResult(out)) return nonResultCallbackDefect(out);
 			return out;
 		} catch (cause) {
 			return defectRes(cause);
@@ -361,6 +361,7 @@ var Res = class {
 		try {
 			const out = runMatch(f, this.error);
 			if (isDefectMarker(out)) return observerThrowToDefect(out.cause, this.error);
+			silenceIfThenable(out);
 			return this;
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.error);
@@ -371,7 +372,7 @@ var Res = class {
 		try {
 			const r = runMatch(f, this.error);
 			if (isDefectMarker(r)) return observerThrowToDefect(r.cause, this.error);
-			if (!isResult(r)) return nonResultCallbackDefect();
+			if (!isResult(r)) return nonResultCallbackDefect(r);
 			return r.tag === "Ok" ? this : passThrough(r);
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.error);
@@ -381,7 +382,7 @@ var Res = class {
 		if (this.tag !== "Defect") return this;
 		try {
 			const r = f(this.cause);
-			return isResult(r) ? r : nonResultCallbackDefect();
+			return isResult(r) ? r : nonResultCallbackDefect(r);
 		} catch (cause) {
 			return defectRes(cause);
 		}
@@ -389,7 +390,7 @@ var Res = class {
 	tapDefect(f) {
 		if (this.tag !== "Defect") return this;
 		try {
-			f(this.cause);
+			silenceIfThenable(f(this.cause));
 			return this;
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.cause);
@@ -398,7 +399,7 @@ var Res = class {
 	tapFailure(f) {
 		if (this.tag === "Ok") return this;
 		try {
-			f(this);
+			silenceIfThenable(f(this));
 			return this;
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.tag === "Err" ? this.error : this.cause);
@@ -563,6 +564,30 @@ function passThrough(self) {
 	return self;
 }
 /**
+* Adopt-and-silence a thenable a combinator is about to **discard**.
+*
+* @remarks
+* The observers (`tap`, `tapErrCases`, `tapDefect`, `tapFailure`) throw their
+* callback's return value away, and the `Result`-returning combinators reject a
+* non-`Result` one. Either way, a thenable that slipped past `NotThenable` (a
+* cast, a raw-JS caller) is dropped while still in flight — and if it later
+* rejects, nothing is holding it, so the rejection floats unhandled and takes
+* the process down on Node by default. Worse for an observer: its whole job is
+* to make a failure visible, and this is the one path where the failure is
+* invisible.
+*
+* Adopting it costs one microtask and makes the rejection a no-op. The
+* boundaries already do exactly this for a thenable `qualify` and a thenable
+* `fn` (see `interop.ts`); this is the same net on the combinator side.
+*
+* @internal
+*/
+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);
+	} catch {}
+}
+/**
 * The Defect minted when a callback constrained to return a `Result` returns
 * something else — reachable only from untyped/cast callers (in typed code the
 * constraint is a compile error). The combinator-side sibling of the
@@ -572,7 +597,8 @@ function passThrough(self) {
 *
 * @internal
 */
-function nonResultCallbackDefect() {
+function nonResultCallbackDefect(returned) {
+	silenceIfThenable(returned);
 	return defectRes(/* @__PURE__ */ new TypeError("unthrown: a combinator callback returned a non-Result value"));
 }
 /**
@@ -657,7 +683,7 @@ var AsyncRes = class AsyncRes {
 			if (r.tag !== "Ok") return passThrough(r);
 			try {
 				const inner = await f(r.value);
-				return isResult(inner) ? inner : nonResultCallbackDefect();
+				return isResult(inner) ? inner : nonResultCallbackDefect(inner);
 			} catch (cause) {
 				return defectRes(cause);
 			}
@@ -667,7 +693,7 @@ var AsyncRes = class AsyncRes {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Ok") return r;
 			try {
-				f(r.value);
+				silenceIfThenable(f(r.value));
 				return r;
 			} catch (cause) {
 				return defectRes(cause);
@@ -679,7 +705,7 @@ var AsyncRes = class AsyncRes {
 			if (r.tag !== "Ok") return passThrough(r);
 			try {
 				const inner = await f(r.value);
-				if (!isResult(inner)) return nonResultCallbackDefect();
+				if (!isResult(inner)) return nonResultCallbackDefect(inner);
 				return inner.tag === "Ok" ? r : passThrough(inner);
 			} catch (cause) {
 				return defectRes(cause);
@@ -691,7 +717,7 @@ var AsyncRes = class AsyncRes {
 			if (r.tag !== "Ok") return passThrough(r);
 			try {
 				const inner = await f(r.value);
-				if (!isResult(inner)) return nonResultCallbackDefect();
+				if (!isResult(inner)) return nonResultCallbackDefect(inner);
 				if (inner.tag !== "Ok") return passThrough(inner);
 				return okRes({
 					...scopeOf(r.value),
@@ -750,7 +776,7 @@ var AsyncRes = class AsyncRes {
 				const out = runMatch(f, r.error);
 				if (isDefectMarker(out)) return defectRes(out.cause);
 				const inner = await out;
-				if (!isResult(inner)) return nonResultCallbackDefect();
+				if (!isResult(inner)) return nonResultCallbackDefect(inner);
 				return inner;
 			} catch (cause) {
 				return defectRes(cause);
@@ -775,6 +801,7 @@ var AsyncRes = class AsyncRes {
 			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);
@@ -788,7 +815,7 @@ var AsyncRes = class AsyncRes {
 				const out = runMatch(f, r.error);
 				if (isDefectMarker(out)) return observerThrowToDefect(out.cause, r.error);
 				const inner = await out;
-				if (!isResult(inner)) return nonResultCallbackDefect();
+				if (!isResult(inner)) return nonResultCallbackDefect(inner);
 				return inner.tag === "Ok" ? passThrough(r) : passThrough(inner);
 			} catch (cause) {
 				return observerThrowToDefect(cause, r.error);
@@ -800,7 +827,7 @@ var AsyncRes = class AsyncRes {
 			if (r.tag !== "Defect") return r;
 			try {
 				const inner = await f(r.cause);
-				return isResult(inner) ? inner : nonResultCallbackDefect();
+				return isResult(inner) ? inner : nonResultCallbackDefect(inner);
 			} catch (cause) {
 				return defectRes(cause);
 			}
@@ -810,7 +837,7 @@ var AsyncRes = class AsyncRes {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Defect") return r;
 			try {
-				f(r.cause);
+				silenceIfThenable(f(r.cause));
 				return r;
 			} catch (cause) {
 				return observerThrowToDefect(cause, r.cause);
@@ -821,7 +848,7 @@ var AsyncRes = class AsyncRes {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag === "Ok") return r;
 			try {
-				f(r);
+				silenceIfThenable(f(r));
 				return r;
 			} catch (cause) {
 				return observerThrowToDefect(cause, r.tag === "Err" ? r.error : r.cause);
@@ -1089,6 +1116,11 @@ function fromNullable(value, onAbsent) {
 * — and a thenable slipped past the types at runtime becomes a `Defect` (never
 * an `Err(Promise)`), its orphaned rejection silenced.
 *
+* `fn` is **synchronous** too. An `async` `fn` rejects *after* this boundary has
+* already returned, so its rejection could never reach `qualify`: it becomes a
+* `Defect` (never `Ok(<Promise>)`) and the orphaned rejection is silenced rather
+* than left to float. Reach for {@link fromPromise} to wrap async work.
+*
 * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
 * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
 * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is
@@ -1125,7 +1157,8 @@ function fromThrowable(fn, qualify) {
 	const triage = qualify;
 	return (...args) => {
 		try {
-			return Ok(fn(...args));
+			const value = fn(...args);
+			return isThenable(value) ? thenableReturnDefect(value) : Ok(value);
 		} catch (cause) {
 			return qualifyToResult(cause, triage);
 		}
@@ -1142,6 +1175,10 @@ function fromThrowable(fn, qualify) {
 * `qualify`. When some throws *are* anticipated, reach for
 * {@link fromThrowable} and triage them.
 *
+* `fn` is **synchronous**: an `async` `fn` becomes a `Defect` (never
+* `Ok(<Promise>)`), with its orphaned rejection silenced rather than left to
+* float. Reach for {@link fromSafePromise} to wrap async work.
+*
 * @typeParam A - the wrapped function's argument tuple.
 * @typeParam T - the wrapped function's return type.
 * @param fn - the throwing function to wrap.
@@ -1163,7 +1200,8 @@ function fromThrowable(fn, qualify) {
 function fromSafeThrowable(fn) {
 	return (...args) => {
 		try {
-			return Ok(fn(...args));
+			const value = fn(...args);
+			return isThenable(value) ? thenableReturnDefect(value) : Ok(value);
 		} catch (cause) {
 			return defectRes(cause);
 		}
@@ -1259,7 +1297,33 @@ function qualifyToResult(cause, qualify) {
 	}
 }
 /**
-* Runtime thenable probe for the belt-and-braces guard above. Called inside the
+* The Defect minted when a **synchronous** boundary's `fn` returns a thenable —
+* i.e. an `async` function was handed to {@link fromThrowable} /
+* {@link fromSafeThrowable}.
+*
+* @remarks
+* This is the sibling of the thenable-`qualify` net in {@link qualifyToResult},
+* and it closes a strictly worse hole. A synchronous boundary only ever sees a
+* synchronous `throw`, so an async `fn`'s rejection never reaches `qualify` at
+* all: it would sit inside `Ok(<Promise>)`, un-triaged, and then float as an
+* unhandled rejection — which terminates the process on Node by default.
+*
+* Unlike the combinator callbacks, this cannot be banned at compile time
+* without collateral damage: `T & NotThenable<T>` on `fn`'s return makes a
+* **generic** function unassignable, so `fromSafeThrowable(structuredClone)`
+* stops compiling and `T` collapses to `unknown`. (The phantom rest-tuple guard
+* `fromPromise` uses fares worse.) So the ban is enforced here, at runtime,
+* where it costs nothing: a Defect, plus adopt-and-silence so the orphaned
+* rejection cannot float.
+*
+* @internal
+*/
+function thenableReturnDefect(value) {
+	Promise.resolve(value).then(void 0, () => void 0);
+	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

package/package.json

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