unthrown 0.1.0 → 0.3.0

package/dist/index.d.mts

@@ -39,6 +39,23 @@ type ResultMethods<T, E> = {
    * @param f - the side effect (its return value is ignored).
    */
   tap(f: (value: T) => void): Result$1<T, E>;
+  /**
+   * Run a **failable** side effect on the success value, keeping the original
+   * value but threading the effect's error.
+   *
+   * @remarks
+   * This is to {@link ResultMethods.tap | tap} what
+   * {@link ResultMethods.flatMap | flatMap} is to {@link ResultMethods.map | map}:
+   * `f` returns a `Result`, but its **success value is discarded** — on success
+   * the original value flows through (`Result<T, E | E2>`), while an `Err` (or
+   * `Defect`) from `f` short-circuits. Runs only on `Ok`; `Err` and `Defect` pass
+   * through. If `f` throws, the throw becomes a `Defect`. Use it for a validation
+   * or write whose _result_ matters but whose _value_ you don't need.
+   *
+   * @typeParam E2 - the error type the effect may introduce.
+   * @param f - the failable side effect; its `Ok` value is ignored.
+   */
+  flatTap<E2>(f: (value: T) => Result$1<unknown, E2>): Result$1<T, E | E2>;
   /**
    * Replace the success value with a constant `value`.
    *
@@ -172,10 +189,10 @@ type ResultMethods<T, E> = {
    *
    * @throws Re-throws on a `Defect`.
    */
-  getOrUndefined(): T | undefined; /** Whether this result is `Ok`. */
-  isOk(): boolean; /** Whether this result is `Err`. */
-  isErr(): boolean; /** Whether this result is a `Defect`. */
-  isDefect(): boolean; /** Lift this synchronous `Result` into an {@link AsyncResult}. */
+  getOrUndefined(): T | undefined; /** Whether this result is `Ok` — narrows `this` to its {@link OkView} on `true`. */
+  isOk(): this is OkView<T, E>; /** Whether this result is `Err` — narrows `this` to its {@link ErrView} on `true`. */
+  isErr(): this is ErrView<E, T>; /** Whether this result is a `Defect` — narrows `this` to its {@link DefectView} on `true`. */
+  isDefect(): this is DefectView<T, E>; /** Lift this synchronous `Result` into an {@link AsyncResult}. */
   toAsync(): AsyncResult<T, E>;
 };
 /** The `Ok` variant of a {@link Result}: a success carrying a `value`. */
@@ -258,7 +275,8 @@ type Awaitable<T> = {
  * {@link fromPromise} forces. To do further async work, re-enter through a
  * qualified boundary and compose it: `ar.flatMap((v) => fromPromise(work(v),
  * qualify))`. The eliminators (`unwrap`, …) return promises; the binds
- * (`flatMap`, `orElse`, `recoverDefect`) additionally accept an `AsyncResult`.
+ * (`flatMap`, `flatTap`, `orElse`, `recoverDefect`) additionally accept an
+ * `AsyncResult`.
  *
  * To pattern-match an `AsyncResult`, `await` it first: `match(await ar)`.
  *
@@ -272,7 +290,13 @@ type AsyncResult<T, E> = Awaitable<Result$1<T, E>> & {
    * (never a raw `Promise`); a throw becomes a `Defect`.
    */
   flatMap<U, E2>(f: (value: T) => Result$1<U, E2> | AsyncResult<U, E2>): AsyncResult<U, E | E2>; /** Asynchronous `tap`. `f` is synchronous; a throw becomes a `Defect`. */
-  tap(f: (value: T) => void): AsyncResult<T, E>; /** Asynchronous `as`. */
+  tap(f: (value: T) => void): AsyncResult<T, E>;
+  /**
+   * Asynchronous `flatTap` — a failable tap that keeps the original value. `f`
+   * may return a `Result` **or** an `AsyncResult`; its `Ok` value is discarded,
+   * an `Err`/`Defect` short-circuits, and a throw becomes a `Defect`.
+   */
+  flatTap<E2>(f: (value: T) => Result$1<unknown, E2> | AsyncResult<unknown, E2>): AsyncResult<T, E | E2>; /** Asynchronous `as`. */
   as<U>(value: U): AsyncResult<U, E>; /** Asynchronous `mapErr`. `f` is synchronous; a throw becomes a `Defect`. */
   mapErr<E2>(f: (error: E) => E2): AsyncResult<T, E2>; /** Asynchronous `orElse`. `f` may return a `Result` or an `AsyncResult`. */
   orElse<U, E2>(f: (error: E) => Result$1<U, E2> | AsyncResult<U, E2>): AsyncResult<T | U, E2>; /** Asynchronous `recover`. `f` is synchronous; a throw becomes a `Defect`. */
@@ -310,6 +334,18 @@ type ErrOf<R> = R extends {
   readonly tag: "Err";
   readonly error: infer E;
 } ? E : never;
+/**
+ * Extract the success type `T` from an {@link AsyncResult}.
+ *
+ * @typeParam R - the `AsyncResult` type to inspect.
+ */
+type AsyncOkOf<R> = R extends AsyncResult<infer T, unknown> ? T : never;
+/**
+ * Extract the error type `E` from an {@link AsyncResult}.
+ *
+ * @typeParam R - the `AsyncResult` type to inspect.
+ */
+type AsyncErrOf<R> = R extends AsyncResult<unknown, infer E> ? E : never;
 //#endregion
 //#region src/constructors.d.ts
 /**
@@ -449,9 +485,16 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  * {@link Defect} (via {@link defect}) — there is no path that leaves `unknown`
  * in `E`. A throw inside `qualify` itself is treated as a `Defect`.
  *
+ * 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
+ * out-of-band and must not pollute the error channel); reach for
+ * {@link fromSafePromise} when every failure is a defect.
+ *
  * @typeParam A - the wrapped function's argument tuple.
  * @typeParam T - the wrapped function's return type.
- * @typeParam E - the modeled error type.
+ * @typeParam R - `qualify`'s return type; the modeled error `E` is
+ * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).
  * @param fn - the throwing function to wrap.
  * @param qualify - triages a thrown cause into `E` or a `Defect`.
  * @returns a function with the same arguments returning `Result<T, E>`.
@@ -463,7 +506,7 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  * parse("{}").unwrap();
  * ```
  */
-declare function fromThrowable<A extends unknown[], T, E>(fn: (...args: A) => T, qualify: (cause: unknown) => E | Defect): (...args: A) => Result$1<T, E>;
+declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T, qualify: (cause: unknown) => R): (...args: A) => Result$1<T, Exclude<R, Defect>>;
 /**
  * Wrap a `Promise` (or a thunk producing one) as an {@link AsyncResult}, forcing
  * every rejection to be triaged.
@@ -474,8 +517,14 @@ declare function fromThrowable<A extends unknown[], T, E>(fn: (...args: A) => T,
  * `await`-ing it always yields a `Result`. A throw inside `qualify` is itself a
  * `Defect`.
  *
+ * 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`; when every
+ * rejection is a defect, prefer {@link fromSafePromise}.
+ *
  * @typeParam T - the resolved value type.
- * @typeParam E - the modeled error type.
+ * @typeParam R - `qualify`'s return type; the modeled error `E` is
+ * `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).
  * @param promise - the promise, or a thunk returning one.
  * @param qualify - triages a rejection cause into `E` or a `Defect`.
  *
@@ -487,7 +536,7 @@ declare function fromThrowable<A extends unknown[], T, E>(fn: (...args: A) => T,
  * );
  * ```
  */
-declare function fromPromise<T, E>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown) => E | Defect): AsyncResult<T, E>;
+declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown) => R): AsyncResult<T, Exclude<R, Defect>>;
 /**
  * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection
  * becomes a `Defect`.
@@ -502,25 +551,96 @@ declare function fromPromise<T, E>(promise: Promise<T> | (() => Promise<T>), qua
  */
 declare function fromSafePromise<T>(promise: Promise<T> | (() => Promise<T>)): AsyncResult<T, never>;
 /**
- * Collect a tuple of {@link Result}s into a single `Result` of the tuple of
+ * The success channel of {@link all} / {@link allAsync}: a **positional tuple**
+ * for a fixed-length input (including the empty tuple), or a homogeneous
+ * **array** for a dynamic one.
+ *
+ * @remarks
+ * The split keys off the input's `length`: a fixed tuple has a literal length
+ * (`number extends Rs["length"]` is false → keep the positional `Ts`), while a
+ * general array has `length: number` (→ collapse to `Ts[number][]`). Checking
+ * length rather than `Rs extends [unknown, ...unknown[]]` keeps `all([])` typed
+ * as `Result<[], …>` instead of `Result<never[], …>`.
+ *
+ * @typeParam Rs - the tuple/array of input `Result` types.
+ * @typeParam Ts - per-element extracted success types (`OkOf` for `all`,
+ * `AsyncOkOf` for `allAsync`).
+ * @internal
+ */
+type AllOk<Rs extends readonly unknown[], Ts extends readonly unknown[]> = number extends Rs["length"] ? Ts[number][] : Ts;
+/** 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}. */
+type AsyncResultRecord = Record<string, AsyncResult<unknown, unknown>>;
+/**
+ * Collect a tuple/array of {@link Result}s into a single `Result` of all their
  * success values.
  *
  * @remarks
  * Short-circuits on the **first** `Err` (later entries are not inspected for
  * their error); any `Defect` present **dominates**, winning even over an earlier
- * `Err`. Positional types are preserved, so `all([ok(1), ok("a")])` is
- * `Result<[number, string], …>`.
- *
- * @typeParam Rs - the tuple of input `Result` types.
- * @param results - the results to combine.
+ * `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}.
  *
  * @example
  * ```ts
  * import { all, ok } from "unthrown";
- * all([ok(1), ok("a"), ok(true)]).unwrap(); // [1, "a", true]
+ * all([ok(1), ok("a"), ok(true)]).unwrap(); // [1, "a", true] (typed [number, string, boolean])
+ * all([ok(1), ok(2)] as Result<number, never>[]).unwrap(); // number[]
+ * ```
+ */
+declare function all<Rs extends readonly Result$1<unknown, unknown>[]>(results: readonly [...Rs]): Result$1<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>>;
+/**
+ * Collect a **record** of {@link Result}s into a single `Result` of a record of
+ * their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is
+ * `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for
+ * parallel work you'd rather not tuple.
+ *
+ * @remarks
+ * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`
+ * dominates. This is **not** error accumulation.
+ *
+ * @example
+ * ```ts
+ * import { allFromDict, ok } from "unthrown";
+ * allFromDict({ id: ok(1), name: ok("ada") }).unwrap(); // { id: 1, name: "ada" }
+ * ```
+ */
+declare function allFromDict<R extends ResultRecord>(results: R): Result$1<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>>;
+/**
+ * The asynchronous counterpart of {@link all}: combine a tuple/array of
+ * {@link AsyncResult}s into one `AsyncResult` of all their success values.
+ *
+ * @remarks
+ * 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}.
+ *
+ * @example
+ * ```ts
+ * import { allAsync, fromSafePromise } from "unthrown";
+ * await allAsync([fromSafePromise(a()), fromSafePromise(b())]);
  * ```
  */
-declare function all<Rs extends readonly Result$1<unknown, unknown>[]>(results: readonly [...Rs]): Result$1<{ [K in keyof Rs]: OkOf<Rs[K]> }, ErrOf<Rs[number]>>;
+declare function allAsync<Rs extends readonly AsyncResult<unknown, unknown>[]>(results: readonly [...Rs]): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>>;
+/**
+ * The asynchronous counterpart of {@link allFromDict}: combine a record of
+ * {@link AsyncResult}s into one `AsyncResult` of a record of their values.
+ *
+ * @remarks
+ * Resolved concurrently (order preserved), folded with the {@link all} rules,
+ * and the internal promise never rejects.
+ *
+ * @example
+ * ```ts
+ * import { allFromDictAsync, fromSafePromise } from "unthrown";
+ * await allFromDictAsync({ a: fromSafePromise(a()), b: fromSafePromise(b()) });
+ * ```
+ */
+declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>>;
 //#endregion
 //#region src/facade.d.ts
 /**
@@ -528,7 +648,9 @@ declare function all<Rs extends readonly Result$1<unknown, unknown>[]>(results:
  * discoverable namespace: {@link Result.ok}, {@link Result.err},
  * {@link Result.defect}, {@link Result.fromNullable}, {@link Result.fromThrowable},
  * {@link Result.fromPromise}, {@link Result.fromSafePromise}, {@link Result.all},
- * {@link Result.isOk}, {@link Result.isErr}, {@link Result.isDefect}.
+ * {@link Result.allAsync}, {@link Result.allFromDict},
+ * {@link Result.allFromDictAsync}, {@link Result.isOk}, {@link Result.isErr},
+ * {@link Result.isDefect}.
  *
  * @remarks
  * Purely additive sugar — each member **is** the corresponding free function.
@@ -551,6 +673,9 @@ declare const Result: {
   readonly fromPromise: typeof fromPromise;
   readonly fromSafePromise: typeof fromSafePromise;
   readonly all: typeof all;
+  readonly allAsync: typeof allAsync;
+  readonly allFromDict: typeof allFromDict;
+  readonly allFromDictAsync: typeof allFromDictAsync;
   readonly isOk: typeof isOk;
   readonly isErr: typeof isErr;
   readonly isDefect: typeof isDefect;
@@ -592,8 +717,26 @@ type TaggedErrorConstructor<Tag extends string> = {
  * field in the payload is forwarded to `Error`. The `_tag` always reflects
  * `tag` and cannot be overridden by the payload.
  *
+ * `_tag` is the discriminant used by {@link matchTags}; `Error.name` is the
+ * human-facing label in stack traces and logs. By default they coincide, but
+ * they can be **decoupled** with `options.name` — so a tag can be namespaced for
+ * collision-safety (`"@my-lib/RetryableError"`) without that slash-prefixed
+ * string leaking into `Error.name`:
+ *
+ * ```ts
+ * class RetryableError extends TaggedError("@my-lib/RetryableError", {
+ *   name: "RetryableError",
+ * })<{ message: string }> {}
+ *
+ * const e = new RetryableError({ message: "boom" });
+ * e._tag; // "@my-lib/RetryableError" — namespaced discriminant
+ * e.name; // "RetryableError"          — clean display name
+ * ```
+ *
  * @typeParam Tag - the string literal discriminant.
- * @param tag - the discriminant value, also used as the error `name`.
+ * @param tag - the discriminant value; also the default error `name`.
+ * @param options - optional overrides. `options.name` sets `Error.name`
+ * independently of `tag` (defaults to `tag`).
  *
  * @example
  * ```ts
@@ -604,7 +747,9 @@ type TaggedErrorConstructor<Tag extends string> = {
  * new HttpError({ status: 500 }).status; // 500
  * ```
  */
-declare function TaggedError<Tag extends string>(tag: Tag): TaggedErrorConstructor<Tag>;
+declare function TaggedError<Tag extends string>(tag: Tag, options?: {
+  readonly name?: string;
+}): TaggedErrorConstructor<Tag>;
 /**
  * The handler object {@link matchTags} requires: a branch per error tag, plus
  * `Ok` and `Defect`. Miss a tag and it will not compile — the exhaustiveness is
@@ -659,5 +804,5 @@ declare function matchTags<T, E extends {
   _tag: string;
 }, R>(result: AsyncResult<T, E>, handlers: TagHandlers<T, E, R>): Promise<R>;
 //#endregion
-export { type AsyncResult, type Awaitable, type Defect, type DefectView, type ErrOf, type ErrView, type OkOf, type OkView, Result, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, defect, err, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, matchTags, ok };
+export { type AsyncErrOf, type AsyncOkOf, type AsyncResult, type Awaitable, type Defect, type DefectView, type ErrOf, type ErrView, type OkOf, type OkView, Result, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, defect, err, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, matchTags, ok };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":";;AAWA;;;;;;;;KAAY,aAAA;EAqB6B;;;;;;;;;EAXvC,GAAA,IAAO,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,QAAA,CAAO,CAAA,EAAG,CAAA;EAoBV;;;;;;;;;;EAT5B,OAAA,QAAe,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,QAAA,CAAO,CAAA,EAAG,EAAA,IAAM,QAAA,CAAO,CAAA,EAAG,CAAA,GAAI,EAAA;EAkC7C;;;;;;;;EAzBjB,GAAA,CAAI,CAAA,GAAI,KAAA,EAAO,CAAA,YAAa,QAAA,CAAO,CAAA,EAAG,CAAA;EA+CP;;;;;;;;;;;;;;;;EA9B/B,OAAA,KAAY,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,QAAA,UAAgB,EAAA,IAAM,QAAA,CAAO,CAAA,EAAG,CAAA,GAAI,EAAA;EAmEE;;;;;;;EA3DnE,EAAA,IAAM,KAAA,EAAO,CAAA,GAAI,QAAA,CAAO,CAAA,EAAG,CAAA;EAiFG;;;;;;;;;EAtE9B,MAAA,KAAW,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,EAAA,GAAK,QAAA,CAAO,CAAA,EAAG,EAAA;EAsGnB;;;;;;;;;;EA3FxB,MAAA,QAAc,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,QAAA,CAAO,CAAA,EAAG,EAAA,IAAM,QAAA,CAAO,CAAA,GAAI,CAAA,EAAG,EAAA;EA8G9B;;;;;;;;;;;;;EAhG/B,OAAA,IAAW,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,QAAA,CAAO,CAAA,GAAI,CAAA;EAjFnB;;;;;;;EAyFxB,MAAA,CAAO,CAAA,GAAI,KAAA,EAAO,CAAA,YAAa,QAAA,CAAO,CAAA,EAAG,CAAA;EA9Ef;;;;;;;;;;;;;EA6F1B,aAAA,QAAqB,CAAA,GAAI,KAAA,cAAmB,QAAA,CAAO,CAAA,EAAG,EAAA,IAAM,QAAA,CAAO,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,EAAA;EApFlD;;;;;;EA2F5B,SAAA,CAAU,CAAA,GAAI,KAAA,qBAA0B,QAAA,CAAO,CAAA,EAAG,CAAA;EA1ErB;;;;;;;;;;;;;EAyF7B,KAAA,IAAS,KAAA;IAAS,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA;IAAG,GAAA,GAAM,KAAA,EAAO,CAAA,KAAM,CAAA;IAAG,MAAA,GAAS,KAAA,cAAmB,CAAA;EAAA,IAAM,CAAA;EAtEnE;;;;;;;;EA+E5B,MAAA,IAAU,CAAA;EApEQ;;;;;;;EA4ElB,SAAA,IAAa,CAAA;EA5EgD;;;;;;;EAoF7D,QAAA,CAAS,QAAA,EAAU,CAAA,GAAI,CAAA;EAtEgB;;;;;;EA6EvC,YAAA,CAAa,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,CAAA;EArEI;;;;;EA2EtC,SAAA,IAAa,CAAA;EA5D+B;;;;;EAkE5C,cAAA,IAAkB,CAAA,cAlEqD;EAqEvE,IAAA,YAAgB,MAAA,CAAO,CAAA,EAAG,CAAA,GArEoD;EAuE9E,KAAA,YAAiB,OAAA,CAAQ,CAAA,EAAG,CAAA,GAhEd;EAkEd,QAAA,YAAoB,UAAA,CAAW,CAAA,EAAG,CAAA,GAlEM;EAqExC,OAAA,IAAW,WAAA,CAAY,CAAA,EAAG,CAAA;AAAA;;KAIhB,MAAA,iBAAuB,aAAA,CAAc,CAAA,EAAG,CAAA;EAAA,SACzC,GAAA;EAAA,SACA,KAAA,EAAO,CAAA;AAAA;;KAGN,OAAA,iBAAwB,aAAA,CAAc,CAAA,EAAG,CAAA;EAAA,SAC1C,GAAA;EAAA,SACA,KAAA,EAAO,CAAA;AAAA;;KAGN,UAAA,yBAAmC,aAAA,CAAc,CAAA,EAAG,CAAA;EAAA,SACrD,GAAA;EAAA,SACA,KAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAhBkB;AAI7B;KAoDY,QAAA,SAAe,MAAA,CAAO,CAAA,EAAG,CAAA,IAAK,OAAA,CAAQ,CAAA,EAAG,CAAA,IAAK,UAAA,CAAW,CAAA,EAAG,CAAA;;;;;;;;;;;;;;KAe5D,SAAA;EACV,IAAA,KAAS,CAAA,EAAG,WAAA,KAAgB,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,WAAA,CAAY,CAAA,YAAa,WAAA,CAAY,CAAA;AAAA;AAlEjE;AAGnB;;;;;;;;;;;;;;;;;;AAHmB,KAwFP,WAAA,SAAoB,SAAA,CAAU,QAAA,CAAO,CAAA,EAAG,CAAA;EAhFxC,0EAkFV,GAAA,IAAO,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,WAAA,CAAY,CAAA,EAAG,CAAA;EAlFvB;;;;EAuFpB,OAAA,QAAe,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,QAAA,CAAO,CAAA,EAAG,EAAA,IAAM,WAAA,CAAY,CAAA,EAAG,EAAA,IAAM,WAAA,CAAY,CAAA,EAAG,CAAA,GAAI,EAAA,GAvF9B;EAyF1D,GAAA,CAAI,CAAA,GAAI,KAAA,EAAO,CAAA,YAAa,WAAA,CAAY,CAAA,EAAG,CAAA;EAzFX;;;;;EA+FhC,OAAA,KACE,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,QAAA,UAAgB,EAAA,IAAM,WAAA,UAAqB,EAAA,IAC3D,WAAA,CAAY,CAAA,EAAG,CAAA,GAAI,EAAA,GA/FR;EAiGd,EAAA,IAAM,KAAA,EAAO,CAAA,GAAI,WAAA,CAAY,CAAA,EAAG,CAAA,GAzDtB;EA4DV,MAAA,KAAW,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,EAAA,GAAK,WAAA,CAAY,CAAA,EAAG,EAAA,GA5DhC;EA8DhB,MAAA,QAAc,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,QAAA,CAAO,CAAA,EAAG,EAAA,IAAM,WAAA,CAAY,CAAA,EAAG,EAAA,IAAM,WAAA,CAAY,CAAA,GAAI,CAAA,EAAG,EAAA,GA9DpD;EAgEnC,OAAA,IAAW,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,WAAA,CAAY,CAAA,GAAI,CAAA,UAhEA;EAkEhD,MAAA,CAAO,CAAA,GAAI,KAAA,EAAO,CAAA,YAAa,WAAA,CAAY,CAAA,EAAG,CAAA,GAlEN;EAqExC,aAAA,QACE,CAAA,GAAI,KAAA,cAAmB,QAAA,CAAO,CAAA,EAAG,EAAA,IAAM,WAAA,CAAY,CAAA,EAAG,EAAA,IACrD,WAAA,CAAY,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,EAAA,GAvE4C;EAyEtE,SAAA,CAAU,CAAA,GAAI,KAAA,qBAA0B,WAAA,CAAY,CAAA,EAAG,CAAA,GAzEW;EA4ElE,KAAA,IAAS,KAAA;IACP,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA;IAClB,GAAA,GAAM,KAAA,EAAO,CAAA,KAAM,CAAA;IACnB,MAAA,GAAS,KAAA,cAAmB,CAAA;EAAA,IAC1B,OAAA,CAAQ,CAAA,GAhFuB;EAkFnC,MAAA,IAAU,OAAA,CAAQ,CAAA,GAlF8B;EAoFhD,SAAA,IAAa,OAAA,CAAQ,CAAA,GApFmC;EAsFxD,QAAA,CAAS,QAAA,EAAU,CAAA,GAAI,OAAA,CAAQ,CAAA,GAtFuC;EAwFtE,YAAA,CAAa,CAAA,GAAI,KAAA,EAAO,CAAA,KAAM,CAAA,GAAI,OAAA,CAAQ,CAAA,GAxF6B;EA0FvE,SAAA,IAAa,OAAA,CAAQ,CAAA,UA3EF;EA6EnB,cAAA,IAAkB,OAAA,CAAQ,CAAA;AAAA;;;;;;KAQhB,IAAA,MAAU,CAAC;EAAA,SAAoB,GAAA;EAAA,SAAoB,KAAA;AAAA,IAAmB,CAAA;;;;;;KAMtE,KAAA,MAAW,CAAC;EAAA,SAAoB,GAAA;EAAA,SAAqB,KAAA;AAAA,IAAmB,CAAA;;;;AA1FC;AAsBrF;KA0EY,SAAA,MAAe,CAAA,SAAU,WAAW,qBAAqB,CAAA;;;;;;KAMzD,UAAA,MAAgB,CAAA,SAAU,WAAW,qBAAqB,CAAA;;;AA5WtE;;;;;;;;;;;;AAAA,iBCMgB,EAAA,IAAM,KAAA,EAAO,CAAA,GAAI,QAAA,CAAO,CAAA;;;;;;;;;;;;;iBAgBxB,GAAA,IAAO,KAAA,EAAO,CAAA,GAAI,QAAA,QAAc,CAAA;;;;;;;;;;;;;iBAgBhC,IAAA,OAAW,CAAA,EAAG,QAAA,CAAO,CAAA,EAAG,CAAA,IAAK,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;iBAQ5C,KAAA,OAAY,CAAA,EAAG,QAAA,CAAO,CAAA,EAAG,CAAA,IAAK,CAAA,IAAK,OAAA,CAAQ,CAAA,EAAG,CAAA;;;;;;iBAQ9C,QAAA,OAAe,CAAA,EAAG,QAAA,CAAO,CAAA,EAAG,CAAA,IAAK,CAAA,IAAK,UAAA,CAAW,CAAA,EAAG,CAAA;;;ADtDpE;;;;;;;;;;;AAAA,cEiBa,WAAA,sBAAiC,KAAA;EFIW;;;;EAAA,SEC9C,KAAA,EAAO,CAAA;cACJ,KAAA,EAAO,CAAA;AAAA;;;cChCf,MAAA;AHSN;;;;;;;;;;AAAA,KGGY,MAAA;EAAA,UACA,MAAM;EAAA,SACP,KAAK;AAAA;;;;;;;;;;;;;;;;;iBAmBA,MAAA,CAAO,KAAA,YAAiB,MAAM;;;;;;;;;;;;;;;;;;;;;;iBCP9B,YAAA,OACd,KAAA,EAAO,CAAA,qBACP,QAAA,QAAgB,CAAA,GACf,QAAA,CAAO,WAAA,CAAY,CAAA,GAAI,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCV,aAAA,4BACd,EAAA,MAAQ,IAAA,EAAM,CAAA,KAAM,CAAA,EACpB,OAAA,GAAU,KAAA,cAAmB,CAAA,OACxB,IAAA,EAAM,CAAA,KAAM,QAAA,CAAO,CAAA,EAAG,OAAA,CAAQ,CAAA,EAAG,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCxB,WAAA,OACd,OAAA,EAAS,OAAA,CAAQ,CAAA,WAAY,OAAA,CAAQ,CAAA,IACrC,OAAA,GAAU,KAAA,cAAmB,CAAA,GAC5B,WAAA,CAAY,CAAA,EAAG,OAAA,CAAQ,CAAA,EAAG,MAAA;;;;;;;;;;;;;iBAuBb,eAAA,IACd,OAAA,EAAS,OAAA,CAAQ,CAAA,WAAY,OAAA,CAAQ,CAAA,KACpC,WAAA,CAAY,CAAA;;;;;;;;;;;;;;;;;;KAuCV,KAAA,gFAGc,EAAA,aAAe,EAAA,aAAe,EAAA;;KAG5C,YAAA,GAAe,MAAM,SAAS,QAAA;;KAE9B,iBAAA,GAAoB,MAAM,SAAS,WAAA;;;;;;;;;;;;;;;;;;;;iBAgExB,GAAA,qBAAwB,QAAA,sBACtC,OAAA,eAAsB,EAAA,IACrB,QAAA,CAAO,KAAA,CAAM,EAAA,gBAAkB,EAAA,GAAK,IAAA,CAAK,EAAA,CAAG,CAAA,OAAQ,KAAA,CAAM,EAAA;;;;;;;;;;;;;;;;;iBAuB7C,WAAA,WAAsB,YAAA,EACpC,OAAA,EAAS,CAAA,GACR,QAAA,eAAqB,CAAA,GAAI,IAAA,CAAK,CAAA,CAAE,CAAA,MAAO,KAAA,CAAM,CAAA,OAAQ,CAAA;;;;;;;;;;;;;;;;;iBAoBxC,QAAA,qBAA6B,WAAA,sBAC3C,OAAA,eAAsB,EAAA,IACrB,WAAA,CAAY,KAAA,CAAM,EAAA,gBAAkB,EAAA,GAAK,SAAA,CAAU,EAAA,CAAG,CAAA,OAAQ,UAAA,CAAW,EAAA;;;;;;;;;;;;;;;iBA0B5D,gBAAA,WAA2B,iBAAA,EACzC,OAAA,EAAS,CAAA,GACR,WAAA,eAA0B,CAAA,GAAI,SAAA,CAAU,CAAA,CAAE,CAAA,MAAO,UAAA,CAAW,CAAA,OAAQ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;cC5R1D,MAAA;EAAA;;;;;;;;;;;;;;;KAoBD,MAAA,SAAe,QAAA,CAAW,CAAA,EAAG,CAAA;;;KCxDpC,KAAA,GAAQ,MAAM;;;;;;;;KASP,mBAAA,+BAAkD,KAAA,IAAS,KAAA,GACrE,QAAA,CAAS,CAAA;EAAA,SAAgB,IAAA,EAAM,GAAA;AAAA;;;;;;;;;;;KAYrB,sBAAA;EAAA,eACK,KAAA,OAAY,IAAA,QAAY,CAAA,wBAAyB,CAAA,GAAI,mBAAA,CAAoB,GAAA,EAAK,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2C/E,WAAA,qBACd,GAAA,EAAK,GAAA,EACL,OAAA;EAAA,SAAqB,IAAA;AAAA,IACpB,sBAAA,CAAuB,GAAA;;;;;;;;;;KA4Bd,WAAA;EAA2B,IAAA;AAAA;EACrC,EAAA,GAAK,KAAA,EAAO,CAAA,KAAM,CAAA;EAClB,MAAA,GAAS,KAAA,cAAmB,CAAA;AAAA,YAClB,CAAA,YAAa,KAAA,EAAO,OAAA,CAAQ,CAAA;EAAK,IAAA,EAAM,CAAA;AAAA,OAAS,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgC5C,SAAA;EAAyB,IAAA;AAAA,MACvC,MAAA,EAAQ,QAAA,CAAO,CAAA,EAAG,CAAA,GAClB,QAAA,EAAU,WAAA,CAAY,CAAA,EAAG,CAAA,EAAG,CAAA,IAC3B,CAAA;AAAA,iBACa,SAAA;EAAyB,IAAA;AAAA,MACvC,MAAA,EAAQ,WAAA,CAAY,CAAA,EAAG,CAAA,GACvB,QAAA,EAAU,WAAA,CAAY,CAAA,EAAG,CAAA,EAAG,CAAA,IAC3B,OAAA,CAAQ,CAAA"}

package/dist/index.mjs

@@ -56,6 +56,15 @@ var Res = class {
 			return defectRes(cause);
 		}
 	}
+	flatTap(f) {
+		if (this.tag !== "Ok") return this;
+		try {
+			const r = f(this.value);
+			return r.tag === "Ok" ? this : r;
+		} catch (cause) {
+			return defectRes(cause);
+		}
+	}
 	as(value) {
 		if (this.tag !== "Ok") return this;
 		return okRes(value);
@@ -243,6 +252,17 @@ var AsyncRes = class AsyncRes {
 			}
 		}));
 	}
+	flatTap(f) {
+		return new AsyncRes(this.promise.then(async (r) => {
+			if (r.tag !== "Ok") return r;
+			try {
+				const inner = await f(r.value);
+				return inner.tag === "Ok" ? r : inner;
+			} catch (cause) {
+				return defectRes(cause);
+			}
+		}));
+	}
 	as(value) {
 		return new AsyncRes(this.promise.then((r) => r.tag === "Ok" ? okRes(value) : r));
 	}
@@ -465,9 +485,16 @@ function fromNullable(value, onAbsent) {
 * {@link Defect} (via {@link defect}) — there is no path that leaves `unknown`
 * in `E`. A throw inside `qualify` itself is treated as a `Defect`.
 *
+* 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
+* out-of-band and must not pollute the error channel); reach for
+* {@link fromSafePromise} when every failure is a defect.
+*
 * @typeParam A - the wrapped function's argument tuple.
 * @typeParam T - the wrapped function's return type.
-* @typeParam E - the modeled error type.
+* @typeParam R - `qualify`'s return type; the modeled error `E` is
+* `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).
 * @param fn - the throwing function to wrap.
 * @param qualify - triages a thrown cause into `E` or a `Defect`.
 * @returns a function with the same arguments returning `Result<T, E>`.
@@ -480,11 +507,12 @@ function fromNullable(value, onAbsent) {
 * ```
 */
 function fromThrowable(fn, qualify) {
+	const triage = qualify;
 	return (...args) => {
 		try {
 			return ok(fn(...args));
 		} catch (cause) {
-			return qualifyToResult(cause, qualify);
+			return qualifyToResult(cause, triage);
 		}
 	};
 }
@@ -498,8 +526,14 @@ function fromThrowable(fn, qualify) {
 * `await`-ing it always yields a `Result`. A throw inside `qualify` is itself a
 * `Defect`.
 *
+* 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`; when every
+* rejection is a defect, prefer {@link fromSafePromise}.
+*
 * @typeParam T - the resolved value type.
-* @typeParam E - the modeled error type.
+* @typeParam R - `qualify`'s return type; the modeled error `E` is
+* `Exclude<R, Defect>` (its `Defect` arm, if any, is subtracted).
 * @param promise - the promise, or a thunk returning one.
 * @param qualify - triages a rejection cause into `E` or a `Defect`.
 *
@@ -512,7 +546,8 @@ function fromThrowable(fn, qualify) {
 * ```
 */
 function fromPromise(promise, qualify) {
-	return new AsyncRes((typeof promise === "function" ? Promise.resolve().then(promise) : promise).then((value) => okRes(value), (cause) => qualifyToResult(cause, qualify)));
+	const triage = qualify;
+	return new AsyncRes((typeof promise === "function" ? Promise.resolve().then(promise) : promise).then((value) => okRes(value), (cause) => qualifyToResult(cause, triage)));
 }
 /**
 * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection
@@ -538,34 +573,124 @@ function qualifyToResult(cause, qualify) {
 	}
 }
 /**
-* Collect a tuple of {@link Result}s into a single `Result` of the tuple of
+* Fold an array of settled `Result`s: first `Err` wins, any `Defect` dominates,
+* else `Ok` of the values array.
+*
+* @internal
+*/
+function foldArray(results) {
+	let firstErr;
+	let firstDefect;
+	const values = [];
+	for (const r of results) if (r.tag === "Defect") firstDefect ??= r;
+	else if (r.tag === "Err") firstErr ??= r;
+	else values.push(r.value);
+	return firstDefect ?? firstErr ?? ok(values);
+}
+/**
+* Fold a record of settled `Result`s with the same rules, else `Ok` of the
+* record of values. Keys are written with `Object.defineProperty` so a
+* caller-supplied `"__proto__"` key cannot pollute the prototype.
+*
+* @internal
+*/
+function foldRecord(results) {
+	let firstErr;
+	let firstDefect;
+	const values = {};
+	for (const [key, r] of Object.entries(results)) if (r.tag === "Defect") firstDefect ??= r;
+	else if (r.tag === "Err") firstErr ??= r;
+	else Object.defineProperty(values, key, {
+		value: r.value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return firstDefect ?? firstErr ?? ok(values);
+}
+/**
+* Collect a tuple/array of {@link Result}s into a single `Result` of all their
 * success values.
 *
 * @remarks
 * Short-circuits on the **first** `Err` (later entries are not inspected for
 * their error); any `Defect` present **dominates**, winning even over an earlier
-* `Err`. Positional types are preserved, so `all([ok(1), ok("a")])` is
-* `Result<[number, string], …>`.
-*
-* @typeParam Rs - the tuple of input `Result` types.
-* @param results - the results to combine.
+* `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}.
 *
 * @example
 * ```ts
 * import { all, ok } from "unthrown";
-* all([ok(1), ok("a"), ok(true)]).unwrap(); // [1, "a", true]
+* all([ok(1), ok("a"), ok(true)]).unwrap(); // [1, "a", true] (typed [number, string, boolean])
+* all([ok(1), ok(2)] as Result<number, never>[]).unwrap(); // number[]
 * ```
 */
 function all(results) {
-	const values = [];
-	let firstErr;
-	let firstDefect;
-	for (const r of results) if (r.tag === "Defect") firstDefect ??= r;
-	else if (r.tag === "Err") firstErr ??= r;
-	else values.push(r.value);
-	if (firstDefect) return firstDefect;
-	if (firstErr) return firstErr;
-	return ok(values);
+	return foldArray(results);
+}
+/**
+* Collect a **record** of {@link Result}s into a single `Result` of a record of
+* their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is
+* `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for
+* parallel work you'd rather not tuple.
+*
+* @remarks
+* Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`
+* dominates. This is **not** error accumulation.
+*
+* @example
+* ```ts
+* import { allFromDict, ok } from "unthrown";
+* allFromDict({ id: ok(1), name: ok("ada") }).unwrap(); // { id: 1, name: "ada" }
+* ```
+*/
+function allFromDict(results) {
+	return foldRecord(results);
+}
+/**
+* The asynchronous counterpart of {@link all}: combine a tuple/array of
+* {@link AsyncResult}s into one `AsyncResult` of all their success values.
+*
+* @remarks
+* 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}.
+*
+* @example
+* ```ts
+* import { allAsync, fromSafePromise } from "unthrown";
+* await allAsync([fromSafePromise(a()), fromSafePromise(b())]);
+* ```
+*/
+function allAsync(results) {
+	return new AsyncRes(Promise.all(results).then((resolved) => foldArray(resolved)));
+}
+/**
+* The asynchronous counterpart of {@link allFromDict}: combine a record of
+* {@link AsyncResult}s into one `AsyncResult` of a record of their values.
+*
+* @remarks
+* Resolved concurrently (order preserved), folded with the {@link all} rules,
+* and the internal promise never rejects.
+*
+* @example
+* ```ts
+* import { allFromDictAsync, fromSafePromise } from "unthrown";
+* await allFromDictAsync({ a: fromSafePromise(a()), b: fromSafePromise(b()) });
+* ```
+*/
+function allFromDictAsync(results) {
+	const entries = Object.entries(results);
+	return new AsyncRes(Promise.all(entries.map(([, ar]) => ar)).then((resolved) => {
+		const byKey = Object.create(null);
+		entries.forEach(([key], i) => {
+			byKey[key] = resolved[i];
+		});
+		return foldRecord(byKey);
+	}));
 }
 //#endregion
 //#region src/facade.ts
@@ -574,7 +699,9 @@ function all(results) {
 * discoverable namespace: {@link Result.ok}, {@link Result.err},
 * {@link Result.defect}, {@link Result.fromNullable}, {@link Result.fromThrowable},
 * {@link Result.fromPromise}, {@link Result.fromSafePromise}, {@link Result.all},
-* {@link Result.isOk}, {@link Result.isErr}, {@link Result.isDefect}.
+* {@link Result.allAsync}, {@link Result.allFromDict},
+* {@link Result.allFromDictAsync}, {@link Result.isOk}, {@link Result.isErr},
+* {@link Result.isDefect}.
 *
 * @remarks
 * Purely additive sugar — each member **is** the corresponding free function.
@@ -597,6 +724,9 @@ const Result = {
 	fromPromise,
 	fromSafePromise,
 	all,
+	allAsync,
+	allFromDict,
+	allFromDictAsync,
 	isOk,
 	isErr,
 	isDefect
@@ -613,8 +743,26 @@ const Result = {
 * field in the payload is forwarded to `Error`. The `_tag` always reflects
 * `tag` and cannot be overridden by the payload.
 *
+* `_tag` is the discriminant used by {@link matchTags}; `Error.name` is the
+* human-facing label in stack traces and logs. By default they coincide, but
+* they can be **decoupled** with `options.name` — so a tag can be namespaced for
+* collision-safety (`"@my-lib/RetryableError"`) without that slash-prefixed
+* string leaking into `Error.name`:
+*
+* ```ts
+* class RetryableError extends TaggedError("@my-lib/RetryableError", {
+*   name: "RetryableError",
+* })<{ message: string }> {}
+*
+* const e = new RetryableError({ message: "boom" });
+* e._tag; // "@my-lib/RetryableError" — namespaced discriminant
+* e.name; // "RetryableError"          — clean display name
+* ```
+*
 * @typeParam Tag - the string literal discriminant.
-* @param tag - the discriminant value, also used as the error `name`.
+* @param tag - the discriminant value; also the default error `name`.
+* @param options - optional overrides. `options.name` sets `Error.name`
+* independently of `tag` (defaults to `tag`).
 *
 * @example
 * ```ts
@@ -625,14 +773,15 @@ const Result = {
 * new HttpError({ status: 500 }).status; // 500
 * ```
 */
-function TaggedError(tag) {
+function TaggedError(tag, options) {
+	const displayName = options?.name ?? tag;
 	class TaggedErrorBase extends Error {
 		_tag;
 		constructor(props) {
 			super(typeof props?.["message"] === "string" ? props["message"] : void 0);
 			if (props) Object.assign(this, props);
 			this._tag = tag;
-			this.name = tag;
+			this.name = displayName;
 			Object.setPrototypeOf(this, new.target.prototype);
 		}
 	}
@@ -650,6 +799,6 @@ function matchTags(result, handlers) {
 	});
 }
 //#endregion
-export { Result, TaggedError, UnwrapError, all, defect, err, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, matchTags, ok };
+export { Result, TaggedError, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, defect, err, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, matchTags, ok };
 
 //# sourceMappingURL=index.mjs.map