unthrown 5.7.0 → 5.9.0

package/dist/index.d.cts

@@ -1788,6 +1788,24 @@ declare function fromExecutor<T = never, E = never>(executor: (settle: Settle<T,
  * @internal
  */
 type AllOk<Rs extends readonly unknown[], Ts extends readonly unknown[]> = number extends Rs["length"] ? Ts[number][] : Ts;
+/**
+ * A `[key, error]` pair from a record aggregate, correlated per key.
+ *
+ * @remarks
+ * `-?` because the mapped type is homomorphic: an optional input key would
+ * otherwise carry its optionality through and put `undefined` in the entry
+ * union, breaking the documented `([key, error]) => …` destructure. An entry
+ * whose error channel is `never` (an infallible input — every `@unthrown/drizzle`
+ * read) is dropped rather than emitted as an uninhabited `[K, never]` arm, which
+ * a `switch` over the key would still have to write a dead case for.
+ *
+ * @internal
+ */
+type DictErrEntry<R> = { [K in keyof R]-?: [ErrOf<R[K]>] extends [never] ? never : readonly [K, ErrOf<R[K]>]; }[keyof R];
+/** The {@link AsyncResult} counterpart of {@link DictErrEntry}. @internal */
+type AsyncDictErrEntry<R> = { [K in keyof R]-?: [AsyncErrOf<R[K]>] extends [never] ? never : readonly [K, AsyncErrOf<R[K]>]; }[keyof R];
+/** A non-empty readonly list — `merge` runs only when an `Err` was collected. @internal */
+type NonEmpty<T> = readonly [T, ...T[]];
 /** A record of `Result`s — the input to {@link allFromDict}. */
 type ResultRecord = Record<string, Result$1<unknown, unknown>>;
 /** A record of `AsyncResult`s — the input to {@link allFromDictAsync}. */
@@ -1802,7 +1820,8 @@ type AsyncResultRecord = Record<string, AsyncResult$1<unknown, unknown>>;
  * `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
  *
@@ -1823,7 +1842,9 @@ declare function all<Rs extends readonly Result$1<unknown, unknown>[]>(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
  *
@@ -1844,7 +1865,8 @@ declare function allFromDict<R extends ResultRecord>(results: R): Result$1<{ [K
  * 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
  *
@@ -1866,7 +1888,8 @@ declare function allAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[]>
  *
  * @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
  *
@@ -1882,6 +1905,153 @@ declare function allAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[]>
  * ```
  */
 declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): AsyncResult$1<{ [K in keyof R]: AsyncOkOf<R[K]>; }, AsyncErrOf<R[keyof R]>>;
+/**
+ * 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>
+ * ```
+ */
+declare function validateAll<Rs extends readonly Result$1<unknown, unknown>[], E2>(results: readonly [...Rs], merge: (errors: NonEmpty<ErrOf<Rs[number]>>) => E2 & NotThenable<E2>): Result$1<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]>; }>, E2>;
+/**
+ * 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 `Object.keys` order.
+ *
+ * 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")
+ * ```
+ */
+declare function validateAllFromDict<R extends ResultRecord, E2>(results: R, merge: (entries: NonEmpty<DictErrEntry<R>>) => E2 & NotThenable<E2>): Result$1<{ [K in keyof R]: OkOf<R[K]>; }, E2>;
+/**
+ * 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")
+ * ```
+ */
+declare function validateAllAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[], E2>(results: readonly [...Rs], merge: (errors: NonEmpty<AsyncErrOf<Rs[number]>>) => E2 & NotThenable<E2>): AsyncResult$1<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]>; }>, E2>;
+/**
+ * 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")
+ * ```
+ */
+declare function validateAllFromDictAsync<R extends AsyncResultRecord, E2>(results: R, merge: (entries: NonEmpty<AsyncDictErrEntry<R>>) => E2 & NotThenable<E2>): AsyncResult$1<{ [K in keyof R]: AsyncOkOf<R[K]>; }, E2>;
 //#endregion
 //#region src/facade.d.ts
 /**
@@ -1889,7 +2059,8 @@ declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): Asyn
  * 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
@@ -1919,6 +2090,8 @@ declare const Result: {
   readonly fromSafeThrowable: typeof fromSafeThrowable;
   readonly all: typeof all;
   readonly allFromDict: typeof allFromDict;
+  readonly validateAll: typeof validateAll;
+  readonly validateAllFromDict: typeof validateAllFromDict;
   readonly isOk: typeof isOk;
   readonly isErr: typeof isErr;
   readonly isDefect: typeof isDefect;
@@ -1944,7 +2117,8 @@ type Result<T, E> = Result$1<T, E>;
  * 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
@@ -1955,7 +2129,8 @@ type Result<T, E> = Result$1<T, E>;
  * 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.
  *
@@ -1980,6 +2155,8 @@ declare const AsyncResult: {
   readonly fromSafePromise: typeof fromSafePromise;
   readonly all: typeof allAsync;
   readonly allFromDict: typeof allFromDictAsync;
+  readonly validateAll: typeof validateAllAsync;
+  readonly validateAllFromDict: typeof validateAllFromDictAsync;
 };
 /**
  * `AsyncResult<T, E>` — the async counterpart of {@link Result}. Shares its name
@@ -2104,4 +2281,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, type Settle, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromExecutor, 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, validateAll, validateAllAsync, validateAllFromDict, validateAllFromDictAsync };

package/dist/index.d.mts

@@ -1788,6 +1788,24 @@ declare function fromExecutor<T = never, E = never>(executor: (settle: Settle<T,
  * @internal
  */
 type AllOk<Rs extends readonly unknown[], Ts extends readonly unknown[]> = number extends Rs["length"] ? Ts[number][] : Ts;
+/**
+ * A `[key, error]` pair from a record aggregate, correlated per key.
+ *
+ * @remarks
+ * `-?` because the mapped type is homomorphic: an optional input key would
+ * otherwise carry its optionality through and put `undefined` in the entry
+ * union, breaking the documented `([key, error]) => …` destructure. An entry
+ * whose error channel is `never` (an infallible input — every `@unthrown/drizzle`
+ * read) is dropped rather than emitted as an uninhabited `[K, never]` arm, which
+ * a `switch` over the key would still have to write a dead case for.
+ *
+ * @internal
+ */
+type DictErrEntry<R> = { [K in keyof R]-?: [ErrOf<R[K]>] extends [never] ? never : readonly [K, ErrOf<R[K]>]; }[keyof R];
+/** The {@link AsyncResult} counterpart of {@link DictErrEntry}. @internal */
+type AsyncDictErrEntry<R> = { [K in keyof R]-?: [AsyncErrOf<R[K]>] extends [never] ? never : readonly [K, AsyncErrOf<R[K]>]; }[keyof R];
+/** A non-empty readonly list — `merge` runs only when an `Err` was collected. @internal */
+type NonEmpty<T> = readonly [T, ...T[]];
 /** A record of `Result`s — the input to {@link allFromDict}. */
 type ResultRecord = Record<string, Result$1<unknown, unknown>>;
 /** A record of `AsyncResult`s — the input to {@link allFromDictAsync}. */
@@ -1802,7 +1820,8 @@ type AsyncResultRecord = Record<string, AsyncResult$1<unknown, unknown>>;
  * `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
  *
@@ -1823,7 +1842,9 @@ declare function all<Rs extends readonly Result$1<unknown, unknown>[]>(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
  *
@@ -1844,7 +1865,8 @@ declare function allFromDict<R extends ResultRecord>(results: R): Result$1<{ [K
  * 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
  *
@@ -1866,7 +1888,8 @@ declare function allAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[]>
  *
  * @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
  *
@@ -1882,6 +1905,153 @@ declare function allAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[]>
  * ```
  */
 declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): AsyncResult$1<{ [K in keyof R]: AsyncOkOf<R[K]>; }, AsyncErrOf<R[keyof R]>>;
+/**
+ * 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>
+ * ```
+ */
+declare function validateAll<Rs extends readonly Result$1<unknown, unknown>[], E2>(results: readonly [...Rs], merge: (errors: NonEmpty<ErrOf<Rs[number]>>) => E2 & NotThenable<E2>): Result$1<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]>; }>, E2>;
+/**
+ * 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 `Object.keys` order.
+ *
+ * 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")
+ * ```
+ */
+declare function validateAllFromDict<R extends ResultRecord, E2>(results: R, merge: (entries: NonEmpty<DictErrEntry<R>>) => E2 & NotThenable<E2>): Result$1<{ [K in keyof R]: OkOf<R[K]>; }, E2>;
+/**
+ * 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")
+ * ```
+ */
+declare function validateAllAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[], E2>(results: readonly [...Rs], merge: (errors: NonEmpty<AsyncErrOf<Rs[number]>>) => E2 & NotThenable<E2>): AsyncResult$1<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]>; }>, E2>;
+/**
+ * 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")
+ * ```
+ */
+declare function validateAllFromDictAsync<R extends AsyncResultRecord, E2>(results: R, merge: (entries: NonEmpty<AsyncDictErrEntry<R>>) => E2 & NotThenable<E2>): AsyncResult$1<{ [K in keyof R]: AsyncOkOf<R[K]>; }, E2>;
 //#endregion
 //#region src/facade.d.ts
 /**
@@ -1889,7 +2059,8 @@ declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): Asyn
  * 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
@@ -1919,6 +2090,8 @@ declare const Result: {
   readonly fromSafeThrowable: typeof fromSafeThrowable;
   readonly all: typeof all;
   readonly allFromDict: typeof allFromDict;
+  readonly validateAll: typeof validateAll;
+  readonly validateAllFromDict: typeof validateAllFromDict;
   readonly isOk: typeof isOk;
   readonly isErr: typeof isErr;
   readonly isDefect: typeof isDefect;
@@ -1944,7 +2117,8 @@ type Result<T, E> = Result$1<T, E>;
  * 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
@@ -1955,7 +2129,8 @@ type Result<T, E> = Result$1<T, E>;
  * 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.
  *
@@ -1980,6 +2155,8 @@ declare const AsyncResult: {
   readonly fromSafePromise: typeof fromSafePromise;
   readonly all: typeof allAsync;
   readonly allFromDict: typeof allFromDictAsync;
+  readonly validateAll: typeof validateAllAsync;
+  readonly validateAllFromDict: typeof validateAllFromDictAsync;
 };
 /**
  * `AsyncResult<T, E>` — the async counterpart of {@link Result}. Shares its name
@@ -2104,4 +2281,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, type Settle, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromExecutor, 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, validateAll, validateAllAsync, validateAllFromDict, validateAllFromDictAsync };