unthrown 5.8.0 → 5.10.0

package/dist/index.cjs

@@ -18,24 +18,63 @@ const PATTERN_BRAND = Symbol.for("unthrown.matcher.pattern");
 * is a bug).
 *
 * @category Errors
+*
+* @example
+* ```ts
+* import { match, NonExhaustiveError } from "unthrown";
+*
+* // A value typed "a" | "b" that is really "c" (a cast, a raw-JS caller):
+* const rogue = "c" as "a" | "b";
+* try {
+*   match(rogue)
+*     .with("a", () => 1)
+*     .with("b", () => 2)
+*     .exhaustive();
+* } catch (error) {
+*   error instanceof NonExhaustiveError; // => true
+*   (error as NonExhaustiveError).input; // => "c"
+* }
+* ```
 */
 var NonExhaustiveError = class extends Error {
 	/** The value no arm matched. */
 	input;
 	constructor(input) {
-		let printed;
-		try {
-			printed = JSON.stringify(input) ?? String(input);
-		} catch {
-			printed = String(input);
-		}
-		super(`unthrown: no pattern matched the value ${printed}`);
+		super(`unthrown: no pattern matched the value ${printValue(input)}`);
 		this.name = "NonExhaustiveError";
 		this.input = input;
 		Object.setPrototypeOf(this, new.target.prototype);
 	}
 };
 /**
+* Render a rogue value for {@link NonExhaustiveError}'s message — **total**,
+* because the error is constructed inside the throw → defect net and a throw
+* here would replace the diagnostic with an unrelated one (or escape `match`).
+*
+* @remarks
+* Each step can fail for a different input, so each is guarded: `JSON.stringify`
+* RETURNS undefined for a function, a symbol or `undefined` and throws for a
+* bigint or a circular object; `String()` throws for a null-prototype object or
+* a hostile `toString` / `Symbol.toPrimitive`; `Object.prototype.toString`
+* throws only for a Proxy whose `get` trap does. The last resort is a constant.
+*
+* @internal
+*/
+function printValue(input) {
+	try {
+		const json = JSON.stringify(input);
+		if (json !== void 0) return json;
+	} catch {}
+	try {
+		return String(input);
+	} catch {}
+	try {
+		return Object.prototype.toString.call(input);
+	} catch {
+		return "<unprintable value>";
+	}
+}
+/**
 * Is `x` a *plain* object (prototype `Object.prototype` or `null`) — an object
 * literal, the only object shape that acts as a structural pattern?
 *
@@ -123,6 +162,24 @@ Object.freeze(MatcherImpl.prototype);
 * {@link P}).
 *
 * @category Constructors
+*
+* @example
+* ```ts
+* import { match, type Result } from "unthrown";
+*
+* // Matching a whole Result natively — every variant named, `.exhaustive()` last:
+* declare const r: Result<number, "odd" | "negative">;
+* const label = match(r)
+*   .with({ tag: "Ok" }, (ok) => `got ${ok.value}`)
+*   .with({ tag: "Err" }, (err) => `failed: ${err.error}`)
+*   .with({ tag: "Defect" }, () => "bug")
+*   .exhaustive();
+*
+* // Inside a combinator, return the un-terminated builder — it runs `.exhaustive()`:
+* const reason = r.mapErrCases((matcher) =>
+*   matcher.with("odd", () => "not even" as const).with("negative", () => "below zero" as const),
+* ); // Result<number, "not even" | "below zero">
+* ```
 */
 function match(value) {
 	return new MatcherImpl(value);
@@ -156,17 +213,49 @@ const universal = pattern(() => true);
 *   (`.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).
+*   error class). **Exhaustiveness here is structural, the check is not:**
+*   two classes with the same shape (`class A extends Error {}`,
+*   `class B extends Error {}`) are one type to the compiler, so a match
+*   naming only `A` compiles as exhaustive while a `B` fails `instanceof A`
+*   at runtime and becomes a `Defect`. Give each class a distinguishing field
+*   (a `readonly kind = "A"` literal) or use `TaggedError`, and the missing
+*   arm is a compile error again.
 * - `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
+*
+* @example
+* ```ts
+* import { P, TaggedError, type Result } from "unthrown";
+*
+* class NotFound extends TaggedError("NotFound")<{ id: string }> {}
+* class Conflict extends TaggedError("Conflict") {}
+* class VendorTimeout extends Error {
+*   readonly afterMs = 30_000;
+* }
+*
+* declare const r: Result<string, NotFound | Conflict | VendorTimeout | "rate_limited">;
+* const status = r.match({
+*   ok: () => 200,
+*   errCases: (matcher) =>
+*     matcher
+*       .with(P.tag("NotFound"), () => 404) // a TaggedError, narrowed with its payload
+*       .with(P.tag("Conflict"), () => 409)
+*       .with(P.instanceOf(VendorTimeout), (e) => (e.afterMs > 10_000 ? 504 : 503))
+*       .with(
+*         P.when((v): v is "rate_limited" => v === "rate_limited"),
+*         () => 429,
+*       ),
+*   defect: () => 500,
+* });
+* ```
 */
 const P = Object.freeze({
 	_: universal,
-	tag: (value) => ({ _tag: value }),
+	tag: (value) => Object.freeze({ _tag: value }),
 	instanceOf: (cls) => pattern((value) => value instanceof cls),
 	when: (guard) => pattern(guard)
 });
@@ -328,6 +417,7 @@ var Res = class {
 		try {
 			const out = runMatch(f, this.error);
 			if (isDefectMarker(out)) return defectRes(out.cause);
+			if (isThenable(out)) return asyncBranchDefect(out);
 			return errRes(out);
 		} catch (cause) {
 			return defectRes(cause);
@@ -349,6 +439,7 @@ var Res = class {
 		try {
 			const out = runMatch(f, this.error);
 			if (isDefectMarker(out)) return defectRes(out.cause);
+			if (isThenable(out)) return asyncBranchDefect(out);
 			return okRes(out);
 		} catch (cause) {
 			return defectRes(cause);
@@ -518,7 +609,8 @@ function defectRes(cause) {
 * brand the prototype carries — so a `Result` built by **another copy** of
 * unthrown, e.g. the CJS and ESM builds loaded side by side, is still
 * recognised). A look-alike plain object (`{ tag: "Ok" }`) carries neither and
-* is **not** matched. An `AsyncResult` is not a `Result` and returns `false`.
+* is **not** matched; nor is a forgery built on the real prototype whose `tag` or
+* payload is a getter (both must be own data properties). An `AsyncResult` is not a `Result` and returns `false`.
 *
 * @returns `true` when `x` is a `Result` produced by this library.
 *
@@ -545,13 +637,42 @@ function defectRes(cause) {
 * @category Guards
 */
 function isResult(x) {
-	if (x instanceof Res) return true;
 	try {
-		return (typeof x === "object" || typeof x === "function") && x !== null && Reflect.get(x, RESULT_BRAND) === true;
+		return (x instanceof Res || (typeof x === "object" || typeof x === "function") && x !== null && Reflect.get(x, RESULT_BRAND) === true) && hasOwnVariantShape(x);
 	} catch {
 		return false;
 	}
 }
+/** Each variant's payload key. @internal */
+const PAYLOAD_KEY = {
+	Ok: "value",
+	Err: "error",
+	Defect: "cause"
+};
+/**
+* Does `x` carry a variant's shape as own **data** properties — `tag` one of
+* the three variants, plus that variant's payload key?
+*
+* @remarks
+* A brand is not enough: the prototype (and so the brand) is reachable from any
+* genuine `Result`, so `Object.create(protoOf(Ok(1)))` with a throwing `tag` or
+* payload getter passed the guard and then threw — raw out of `all`, or as a
+* rejection out of an `AsyncResult` that must never reject. Every genuine
+* `Result`, from any copy of the library, is a frozen object literal whose `tag`
+* and payload are own data properties, so reading their descriptors (which
+* never runs a getter) accepts all of them and no getter-bearing forgery.
+*
+* @internal
+*/
+function hasOwnVariantShape(x) {
+	const tag = Object.getOwnPropertyDescriptor(x, "tag");
+	if (tag === void 0 || !("value" in tag)) return false;
+	const variant = tag.value;
+	if (variant !== "Ok" && variant !== "Err" && variant !== "Defect") return false;
+	const key = PAYLOAD_KEY[variant];
+	const payload = Object.getOwnPropertyDescriptor(x, key);
+	return payload !== void 0 && "value" in payload;
+}
 /**
 * Reuse a non-matching variant (an `Err` or `Defect`) as a differently-typed
 * `Result`, with no runtime work. Sound because the passed-through variant
@@ -577,9 +698,9 @@ function passThrough(self) {
 * - 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.
+* - to classify a value that is then **discarded** (a `Defect` minted, the
+*   value handed to {@link silenceIfThenable}), where the only correct answer
+*   is to drop it without throwing — and without starting a lazy thenable.
 *
 * Calling it bare, outside both, is a bug: the throw escapes into whatever
 * context invoked it.
@@ -590,27 +711,37 @@ 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**.
+* Silence a **genuine `Promise`** a combinator or boundary is about to
+* **discard** — and leave every other thenable untouched.
 *
 * @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
+* non-`Result` one. Either way, a promise 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.
+* invisible. Attaching a no-op rejection handler costs nothing and changes no
+* outcome.
 *
-* 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.
+* Only a `Promise` **instance** is touched. A promise is already running, so
+* handling its rejection starts nothing; a non-`Promise` thenable may be
+* **lazy** — a `PrismaPromise`, a query builder — whose work begins only when
+* `then` is called. Adopting one (`Promise.resolve(x)` calls `x.then`) would
+* *run* the effect the caller is being told was refused: `fromSafeThrowable(()
+* => prisma.user.deleteMany())` returned a `Defect` and deleted the rows
+* anyway. A lazy thenable that is never started cannot reject, so there is
+* nothing to silence. Callers still *classify* any thenable (a `Defect` where
+* the spec says so) via {@link isThenable}; this only decides what to adopt.
+*
+* Total: a hostile `then` getter or `Symbol.hasInstance` path is swallowed.
 *
 * @internal
 */
 function silenceIfThenable(value) {
 	try {
-		if (isThenable(value)) Promise.resolve(value).then(void 0, () => void 0);
+		if (value instanceof Promise) value.then(void 0, () => void 0);
 	} catch {}
 }
 /**
@@ -628,6 +759,19 @@ function nonResultCallbackDefect(returned) {
 	return defectRes(/* @__PURE__ */ new TypeError("unthrown: a combinator callback returned a non-Result value"));
 }
 /**
+* The Defect minted when a non-awaiting error transformer (`mapErrCases` /
+* `recoverErrCases`) gets a thenable branch output past the compile-time ban
+* (a cast, an untyped caller): never `Err(<Promise>)` / `Ok(<Promise>)` — a
+* Promise in the channel is un-triaged — and a genuine Promise is silenced so
+* its rejection cannot float. The sibling of the aggregates' async-`merge` net.
+*
+* @internal
+*/
+function asyncBranchDefect(out) {
+	silenceIfThenable(out);
+	return defectRes(/* @__PURE__ */ new TypeError("unthrown: mapErrCases/recoverErrCases branches must be SYNCHRONOUS, but one returned a thenable — lift async work with fromPromise and use flatMapErrCases"));
+}
+/**
 * Drive an error-combinator callback: build `match(error)`, hand it (plus the
 * injected `defect`) to the callback, and `.run()` the returned exhaustive
 * builder to its output. `.run()` executes `.exhaustive()` — type-forced
@@ -676,10 +820,23 @@ function observerThrowToDefect(thrown, original) {
 * @internal
 */
 function scopeOf(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("bind/let requires an object scope — start a do-chain with Do()");
+	if (typeof value !== "object" || value === null || !isPlainScope(value)) throw new TypeError("bind/let requires a plain object scope — start a do-chain with Do()");
 	return value;
 }
 /**
+* A *plain* object: its prototype is `null` or an `Object.prototype` (any
+* realm's — recognised by having no prototype of its own). The spread that
+* merges a `bind`/`let` key copies only own enumerable data, so a class
+* instance's getters and prototype methods — and an array's identity — would
+* silently vanish while the type still claimed them.
+*
+* @internal
+*/
+function isPlainScope(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || Object.getPrototypeOf(proto) === null;
+}
+/**
 * The sole runtime implementation of {@link AsyncResult}: wraps a
 * `Promise<Result>` constructed never to reject. Operates on the public `Result`
 * union (via `tag`), never on `Res` internals. Never re-exported from `index.ts`.
@@ -769,7 +926,7 @@ var AsyncRes = class AsyncRes {
 	ensure(predicate, onFail) {
 		return this.#lift((r) => r.ensure(predicate, onFail));
 	}
-	mapErrCases(f) {
+	mapErrCases(f, ..._guard) {
 		return this.#lift((r) => r.mapErrCases(f));
 	}
 	flatMapErrCases(f) {
@@ -786,7 +943,7 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
-	recoverErrCases(f) {
+	recoverErrCases(f, ..._guard) {
 		return this.#lift((r) => r.recoverErrCases(f));
 	}
 	tapErrCases(f) {
@@ -1124,12 +1281,17 @@ function fromNullable(value, onAbsent) {
 function fromThrowable(fn, qualify) {
 	const triage = qualify;
 	return (...args) => {
+		let value;
 		try {
-			const value = fn(...args);
-			return isThenable(value) ? thenableReturnDefect(value) : Ok(value);
+			value = fn(...args);
 		} catch (cause) {
 			return qualifyToResult(cause, triage);
 		}
+		try {
+			return isThenable(value) ? thenableReturnDefect(value, SYNC_FN_THENABLE) : Ok(value);
+		} catch (cause) {
+			return defectRes(cause);
+		}
 	};
 }
 /**
@@ -1169,7 +1331,7 @@ function fromSafeThrowable(fn) {
 	return (...args) => {
 		try {
 			const value = fn(...args);
-			return isThenable(value) ? thenableReturnDefect(value) : Ok(value);
+			return isThenable(value) ? thenableReturnDefect(value, SYNC_FN_THENABLE) : Ok(value);
 		} catch (cause) {
 			return defectRes(cause);
 		}
@@ -1311,7 +1473,7 @@ function fromExecutor(executor) {
 	};
 	try {
 		const returned = executor(settle, defect);
-		if (isThenable(returned)) Promise.resolve(returned).then(void 0, (cause) => settle(defect(cause)));
+		if (returned instanceof Promise) returned.then(void 0, (cause) => settle(defect(cause)));
 	} catch (cause) {
 		settle(defect(cause));
 	}
@@ -1322,7 +1484,7 @@ function qualifyToResult(cause, qualify) {
 		const q = qualify(cause, defect);
 		if (isDefectMarker(q)) return defectRes(q.cause);
 		if (isThenable(q)) {
-			Promise.resolve(q).then(void 0, () => void 0);
+			silenceIfThenable(q);
 			return defectRes(/* @__PURE__ */ new TypeError("unthrown: qualify must be synchronous — it returned a thenable; triage the cause without awaiting"));
 		}
 		return errRes(q);
@@ -1331,30 +1493,78 @@ function qualifyToResult(cause, qualify) {
 	}
 }
 /**
-* The Defect minted when a **synchronous** boundary's `fn` returns a thenable —
-* i.e. an `async` function was handed to {@link fromThrowable} /
-* {@link fromSafeThrowable}.
+* The message for {@link thenableReturnDefect} at a **synchronous boundary** —
+* an `async` function handed to {@link fromThrowable} / {@link fromSafeThrowable}.
+*
+* @internal
+*/
+const SYNC_FN_THENABLE = "unthrown: fromThrowable/fromSafeThrowable wrap a SYNCHRONOUS function, but `fn` returned a thenable — its rejection would escape qualification. Use fromPromise/fromSafePromise instead.";
+/**
+* The message for {@link thenableReturnDefect} in an **accumulating aggregate** —
+* an `async` `merge` handed to {@link validateAll} and friends.
+*
+* @internal
+*/
+const MERGE_THENABLE = "unthrown: an accumulating aggregate's `merge` must be SYNCHRONOUS, but it returned a thenable — its rejection would escape qualification.";
+/**
+* The Defect minted where a callback that must be **synchronous** returned a
+* thenable: a `fn` handed to {@link fromThrowable} / {@link fromSafeThrowable},
+* or a `merge` handed to an accumulating aggregate.
 *
 * @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.
+* unhandled rejection — which terminates the process on Node by default. An
+* async `merge` is the same hole one channel over: `Err(<Promise>)`.
+*
+* The `fn` case 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.) `merge` *is* `NotThenable`-constrained, but a cast or an untyped
+* caller still reaches here. Either way the runtime answer is the same, and it
+* costs nothing: a Defect, plus a no-op rejection handler so an orphaned Promise
+* cannot float.
 *
-* 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, message) {
+	silenceIfThenable(value);
+	return defectRes(new TypeError(message));
+}
+/**
+* A record's own **enumerable** keys — strings and symbols — with their values.
+*
+* @remarks
+* `Object.keys` / `Object.values` skip symbol keys, so a symbol-keyed `Err`
+* silently vanished from the fold while the types (`keyof R` includes it)
+* promised otherwise. `Reflect.ownKeys` filtered to the enumerable ones is
+* `Object.keys` plus symbols, in the same order (strings first, then symbols).
+* May throw on an out-of-contract container (`null`, a throwing getter) — every
+* caller routes that to a `Defect`.
+*
+* @internal
+*/
+function ownEntries(record) {
+	const keys = Reflect.ownKeys(record).filter((key) => Object.prototype.propertyIsEnumerable.call(record, key));
+	return [keys, keys.map((key) => record[key])];
+}
+/**
+* Build an async aggregate's settled promise, turning a synchronous throw while
+* reading an out-of-contract container (`allAsync(undefined)`, a throwing
+* getter) into a `Defect` — the returned `AsyncResult` still never rejects and
+* the call never throws.
 *
 * @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."));
+function settleOrDefect(build) {
+	try {
+		return new AsyncRes(build());
+	} catch (cause) {
+		return new AsyncRes(Promise.resolve(defectRes(cause)));
+	}
 }
 /**
 * Fold an array of settled `Result`s: first `Err` wins, any `Defect` dominates,
@@ -1366,22 +1576,46 @@ function thenableReturnDefect(value) {
 function nonResultDefect() {
 	return defectRes(/* @__PURE__ */ new TypeError("unthrown: aggregate received a non-Result element"));
 }
-function foldArray(results) {
-	let firstErr;
-	let firstDefect;
-	const values = [];
-	for (const r of results) {
-		if (!isResult(r)) {
-			firstDefect ??= nonResultDefect();
-			break;
+/**
+* Resolve every input concurrently (order preserved), adopting each one
+* defensively: a cast/untyped rejecting thenable becomes a `Defect` rather than
+* rejecting the internal promise, so the "an `AsyncResult`'s internal promise
+* never rejects" invariant holds even for out-of-contract input.
+*
+* @internal
+*/
+function settleAll(results) {
+	return Promise.all(results.map((r) => Promise.resolve(r).then((x) => x, (cause) => defectRes(cause))));
+}
+function foldArray(results, merge) {
+	try {
+		let firstErr;
+		let firstDefect;
+		const values = [];
+		const errors = [];
+		for (const [i, r] of results.entries()) {
+			if (!isResult(r)) {
+				firstDefect ??= nonResultDefect();
+				break;
+			}
+			if (r.tag === "Defect") {
+				firstDefect ??= r;
+				break;
+			} else if (r.tag === "Err") {
+				if (merge) errors.push([i, r.error]);
+				else firstErr ??= r;
+			} else values.push(r.value);
 		}
-		if (r.tag === "Defect") {
-			firstDefect ??= r;
-			break;
-		} else if (r.tag === "Err") firstErr ??= r;
-		else values.push(r.value);
+		if (firstDefect) return firstDefect;
+		if (merge && errors.length > 0) {
+			const merged = merge(errors);
+			if (isThenable(merged)) return thenableReturnDefect(merged, MERGE_THENABLE);
+			return Err(merged);
+		}
+		return firstErr ?? Ok(values);
+	} catch (cause) {
+		return defectRes(cause);
 	}
-	return firstDefect ?? firstErr ?? Ok(values);
 }
 /**
 * Fold a record of settled `Result`s with the same rules, else `Ok` of the
@@ -1399,9 +1633,23 @@ function foldArray(results) {
 *
 * @internal
 */
-function foldRecord(results) {
-	const keys = Object.keys(results);
-	return foldArray(Object.values(results)).map((values) => Object.fromEntries(keys.map((key, i) => [key, values[i]])));
+function foldRecord(results, merge) {
+	let keys;
+	let values;
+	try {
+		[keys, values] = ownEntries(results);
+	} catch (cause) {
+		return defectRes(cause);
+	}
+	return foldArray(values, merge && ((errors) => merge(nameErrors(errors, keys)))).map((values) => Object.fromEntries(keys.map((key, i) => [key, values[i]])));
+}
+/** Drop the accumulated indices — the positional forms merge errors alone. @internal */
+function stripIndices(errors) {
+	return errors.map(([, e]) => e);
+}
+/** Pair each accumulated index back onto its key. @internal */
+function nameErrors(errors, keys) {
+	return errors.map(([i, e]) => [keys[i], e]);
 }
 /**
 * Collect a tuple/array of {@link Result}s into a single `Result` of all their
@@ -1413,7 +1661,8 @@ function foldRecord(results) {
 * `Err`. A **fixed tuple** keeps its positional types — `all([Ok(1), Ok("a")])`
 * is `Result<[number, string], …>` — while a **dynamic array** `Result<T, E>[]`
 * collapses to `Result<T[], E>` with no cast. For a **record** keyed by name,
-* use {@link allFromDict}.
+* use {@link allFromDict}. To report **every** `Err` instead of only the first,
+* use {@link validateAll}.
 *
 * @category Aggregate
 *
@@ -1436,7 +1685,9 @@ function all(results) {
 *
 * @remarks
 * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`
-* dominates. This is **not** error accumulation.
+* dominates. This is **not** error accumulation — for that, reach for
+* {@link validateAllFromDict}, which accumulates every `Err` and folds them into
+* one modeled error.
 *
 * @category Aggregate
 *
@@ -1459,7 +1710,8 @@ function allFromDict(results) {
 * The inputs are resolved **concurrently** (order preserved); the resolved
 * `Result`s are then folded with the same rules as {@link all} — first `Err`
 * short-circuits, any `Defect` dominates. As ever, the returned `AsyncResult`'s
-* internal promise never rejects. For a **record**, use {@link allFromDictAsync}.
+* internal promise never rejects. For a **record**, use {@link allFromDictAsync};
+* to report **every** `Err`, use {@link validateAllAsync}.
 *
 * @category Aggregate
 *
@@ -1475,7 +1727,7 @@ function allFromDict(results) {
 * ```
 */
 function allAsync(results) {
-	return new AsyncRes(Promise.all(results.map((r) => Promise.resolve(r).then((x) => x, (cause) => defectRes(cause)))).then((resolved) => foldArray(resolved)));
+	return settleOrDefect(() => settleAll(results).then((resolved) => foldArray(resolved)));
 }
 /**
 * The asynchronous counterpart of {@link allFromDict}: combine a record of
@@ -1483,7 +1735,8 @@ function allAsync(results) {
 *
 * @remarks
 * Resolved concurrently (order preserved), folded with the {@link all} rules,
-* and the internal promise never rejects.
+* and the internal promise never rejects. To report **every** `Err`, use
+* {@link validateAllFromDictAsync}.
 *
 * @category Aggregate
 *
@@ -1499,8 +1752,169 @@ function allAsync(results) {
 * ```
 */
 function allFromDictAsync(results) {
-	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]])))));
+	return settleOrDefect(() => {
+		const [keys, values] = ownEntries(results);
+		return settleAll(values).then((resolved) => foldRecord(Object.fromEntries(keys.map((key, i) => [key, resolved[i]]))));
+	});
+}
+/**
+* Collect a tuple/array of {@link Result}s, **accumulating every** `Err` and
+* merging them into a single modeled error — the accumulating counterpart of
+* {@link all}.
+*
+* @remarks
+* Same success channel as {@link all}: a **fixed tuple** keeps its positional
+* types, a **dynamic array** collapses to `Result<T[], E2>`. The difference is
+* the error channel — instead of the first `Err` winning, every `Err` is
+* collected in input order and handed to `merge`, whose return becomes the
+* modeled error.
+*
+* `merge` receives a **non-empty** list, so it is total: it is called only when
+* at least one `Err` was collected. It is **not** called when every element is
+* `Ok`, nor when a `Defect` is present.
+*
+* Any `Defect` still **dominates** — it wins over the accumulated errors, which
+* are discarded and never reach `merge`. A defect means something in this batch
+* failed in a way nobody modeled, so the violations computed alongside it are
+* not trustworthy. An out-of-contract non-`Result` element becomes a
+* `TypeError`-caused `Defect` the same way, and a throw inside `merge` becomes
+* a `Defect` too.
+*
+* `merge` must be **synchronous** — an `async` one is a compile error
+* ({@link NotThenable}), since a `Promise` in `E` is an unqualified rejection.
+*
+* For **schema-shaped** input (a request body, a form), reach for
+* `@unthrown/standard-schema`'s `fromSchema` instead — a validator already
+* hands you every issue as the modeled error. `validateAll` is for independent
+* checks you wrote yourself. For a **record** keyed by name, use
+* {@link validateAllFromDict}.
+*
+* @typeParam Rs - the tuple/array of input `Result` types.
+* @typeParam E2 - the merged error type.
+* @param results - the results to collect.
+* @param merge - folds the collected errors into one modeled error.
+*
+* @category Aggregate
+*
+* @example
+* ```ts
+* import { validateAll, Ok, Err } from "unthrown";
+*
+* // every Err is collected, not just the first
+* validateAll([Ok(1), Err("stock"), Err("credit")], (errors) => errors.join(" and "));
+* // => Err("stock and credit")
+*
+* // all-Ok keeps the positional tuple; `merge` never runs
+* validateAll([Ok(1), Ok("a")], (errors) => errors.join());
+* // => Ok([1, "a"]) typed Result<[number, string], string>
+* ```
+*/
+function validateAll(results, merge) {
+	return foldArray(results, (errors) => merge(stripIndices(errors)));
+}
+/**
+* Collect a **record** of {@link Result}s, accumulating every `Err` — the
+* accumulating counterpart of {@link allFromDict}, and the named counterpart of
+* {@link validateAll}.
+*
+* @remarks
+* `merge` receives a non-empty list of **`[key, error]` entries**, correlated
+* per key: `{ a: Result<A, E1>; b: Result<B, E2> }` yields
+* `["a", E1] | ["b", E2]`, so a `switch` on the key narrows the error and an
+* impossible pairing does not typecheck. That is what keeps two checks sharing
+* one error type distinguishable. Entries come in key order — `Object.keys`
+* order, then enumerable symbol keys (a symbol key is folded like any other).
+*
+* Every other rule matches {@link validateAll}: any `Defect` dominates and
+* discards the accumulated errors, a throw in `merge` becomes a `Defect`, and
+* `merge` must be synchronous.
+*
+* @typeParam R - the record of input `Result` types.
+* @typeParam E2 - the merged error type.
+* @param results - the results to collect, keyed by name.
+* @param merge - folds the collected `[key, error]` entries into one error.
+*
+* @category Aggregate
+*
+* @example
+* ```ts
+* import { validateAllFromDict, Ok, Err } from "unthrown";
+*
+* validateAllFromDict(
+*   { vatRate: Err("out of range"), currency: Ok("EUR"), dueDate: Err("past") },
+*   (entries) => entries.map(([key, error]) => `${key}: ${error}`).join("; "),
+* );
+* // => Err("vatRate: out of range; dueDate: past")
+* ```
+*/
+function validateAllFromDict(results, merge) {
+	return foldRecord(results, (entries) => merge(entries));
+}
+/**
+* The asynchronous counterpart of {@link validateAll}: collect a tuple/array of
+* {@link AsyncResult}s, accumulating every `Err` into one merged error.
+*
+* @remarks
+* Every {@link validateAll} rule holds, with the inputs resolved
+* **concurrently** (order preserved) — as with {@link allAsync}, no work is
+* short-circuited either way; the fail-fast/accumulating split is purely which
+* errors get reported. The internal promise never rejects: an out-of-contract
+* rejecting thenable becomes a dominating `Defect`. `merge` stays synchronous
+* here too — this is exactly where its rejection would land unqualified in `E`.
+* For a **record**, use {@link validateAllFromDictAsync}.
+*
+* @typeParam Rs - the tuple/array of input `AsyncResult` types.
+* @typeParam E2 - the merged error type.
+* @param results - the async results to collect.
+* @param merge - folds the collected errors into one modeled error.
+*
+* @category Aggregate
+*
+* @example
+* ```ts
+* import { validateAllAsync, OkAsync, ErrAsync } from "unthrown";
+*
+* const checked = validateAllAsync(
+*   [OkAsync(1), ErrAsync("stock"), ErrAsync("credit")],
+*   (errors) => errors.join(" and "),
+* );
+* // (await checked) => Err("stock and credit")
+* ```
+*/
+function validateAllAsync(results, merge) {
+	return settleOrDefect(() => settleAll(results).then((resolved) => foldArray(resolved, (errors) => merge(stripIndices(errors)))));
+}
+/**
+* The asynchronous counterpart of {@link validateAllFromDict}: collect a record
+* of {@link AsyncResult}s, accumulating every `Err` into one merged error.
+*
+* @remarks
+* The {@link validateAllFromDict} rules, over inputs resolved concurrently as
+* in {@link validateAllAsync}.
+*
+* @typeParam R - the record of input `AsyncResult` types.
+* @typeParam E2 - the merged error type.
+* @param results - the async results to collect, keyed by name.
+* @param merge - folds the collected `[key, error]` entries into one error.
+*
+* @category Aggregate
+*
+* @example
+* ```ts
+* import { validateAllFromDictAsync, OkAsync, ErrAsync } from "unthrown";
+*
+* const checked = validateAllFromDictAsync(
+*   { stock: ErrAsync("none left"), credit: OkAsync(500) },
+*   (entries) => entries.map(([key, error]) => `${key}: ${error}`).join("; "),
+* );
+* // (await checked) => Err("stock: none left")
+* ```
+*/
+function validateAllFromDictAsync(results, merge) {
+	return settleOrDefect(() => {
+		const [keys, values] = ownEntries(results);
+		return settleAll(values).then((resolved) => foldRecord(Object.fromEntries(keys.map((key, i) => [key, resolved[i]])), (entries) => merge(entries)));
+	});
 }
 //#endregion
 //#region src/facade.ts
@@ -1509,7 +1923,8 @@ function allFromDictAsync(results) {
 * single, discoverable namespace: {@link Result.Ok}, {@link Result.Err},
 * {@link Result.Do}, {@link Result.fromNullable}, {@link Result.fromThrowable},
 * {@link Result.fromSafeThrowable}, {@link Result.all},
-* {@link Result.allFromDict}, {@link Result.isOk}, {@link Result.isErr},
+* {@link Result.allFromDict}, {@link Result.validateAll},
+* {@link Result.validateAllFromDict}, {@link Result.isOk}, {@link Result.isErr},
 * {@link Result.isDefect}, {@link Result.isResult}.
 *
 * @remarks
@@ -1539,6 +1954,8 @@ const Result = {
 	fromSafeThrowable,
 	all,
 	allFromDict,
+	validateAll,
+	validateAllFromDict,
 	isOk,
 	isErr,
 	isDefect,
@@ -1549,7 +1966,8 @@ const Result = {
 * the matching namespace: {@link AsyncResult.Ok}, {@link AsyncResult.Err},
 * {@link AsyncResult.Do}, {@link AsyncResult.fromExecutor},
 * {@link AsyncResult.fromPromise}, {@link AsyncResult.fromSafePromise},
-* {@link AsyncResult.all}, {@link AsyncResult.allFromDict}.
+* {@link AsyncResult.all}, {@link AsyncResult.allFromDict},
+* {@link AsyncResult.validateAll}, {@link AsyncResult.validateAllFromDict}.
 *
 * @remarks
 * The async sibling of {@link Result}. Statics are grouped by what they
@@ -1560,7 +1978,8 @@ const Result = {
 * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is
 * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;
 * `AsyncResult.allFromDict` is
-* `allFromDictAsync`). Like {@link Result}, the free functions remain the
+* `allFromDictAsync`; `AsyncResult.validateAll` is `validateAllAsync`). Like
+* {@link Result}, the free functions remain the
 * primary, tree-shakeable API; the value `AsyncResult` and the type
 * {@link AsyncResult} share one name.
 *
@@ -1584,7 +2003,9 @@ const AsyncResult = {
 	fromPromise,
 	fromSafePromise,
 	all: allAsync,
-	allFromDict: allFromDictAsync
+	allFromDict: allFromDictAsync,
+	validateAll: validateAllAsync,
+	validateAllFromDict: validateAllFromDictAsync
 };
 //#endregion
 //#region src/tagged.ts
@@ -1704,3 +2125,7 @@ exports.isErr = isErr;
 exports.isOk = isOk;
 exports.isResult = isResult;
 exports.match = match;
+exports.validateAll = validateAll;
+exports.validateAllAsync = validateAllAsync;
+exports.validateAllFromDict = validateAllFromDict;
+exports.validateAllFromDictAsync = validateAllFromDictAsync;