unthrown 5.9.0 → 5.10.0

package/dist/index.d.cts

@@ -63,26 +63,53 @@ type UniversalPattern = PatternMatcher<unknown> & {
  * @internal
  */
 type MatchedOf<Pt> = Pt extends PatternMatcher<infer M> ? M : Pt extends object ? { [K in keyof Pt]: MatchedOf<Pt[K]>; } : Pt;
+/**
+ * Reject a **keyless object pattern** (`{}`) where it is written.
+ *
+ * @remarks
+ * At runtime an empty object pattern matches *every* object (no key to
+ * disagree on), and at the type level `MatchedOf<{}>` is `{}`, so `Exclude`
+ * removes every non-nullish case — an unflagged catch-all, invisible to
+ * `@unthrown/oxlint`'s `no-catch-all-pattern`. Mapping it to a branded string
+ * makes the argument unassignable, with the reason in the error. `null` /
+ * `undefined` (also keyless) stay legal literal patterns, and every `P.*`
+ * pattern carries a symbol key. The check recurses into structural patterns:
+ * a nested `{ data: {} }` is rejected too, since the type level treats `{}` as
+ * matching a primitive `data` while the runtime rejects a non-object there — a
+ * match that compiles as exhaustive and then throws.
+ *
+ * @internal
+ */
+type NoEmptyPattern<Pt> = [Pt] extends [null | undefined] ? Pt : [Pt] extends [PatternMatcher<unknown>] ? Pt : [keyof Pt] extends [never] ? "unthrown: an empty object pattern `{}` matches every object — name the case (a key to match on), or use P._ deliberately" : Pt extends object ? { [K in keyof Pt]: NoEmptyPattern<Pt[K]>; } : Pt;
 /**
  * The diagnostic type of `.exhaustive` on a builder that has NOT covered every
  * case: not callable (so it fails the `ExhaustiveMatch` constraint at the call
  * site), and it names the remaining cases so the error reads as a to-do list.
+ * The alias NAME is the diagnostic: the compiler prints "Type
+ * 'UnhandledCases<NotFound>' provides no match for the signature …", so it
+ * says what is wrong and lists what is left (it was `NonExhaustive<…>`).
  *
  * @internal
  */
-type NonExhaustive<Remaining> = {
+type UnhandledCases<Remaining> = {
   readonly "unthrown: this match is not exhaustive — add a `.with(…)` for the remaining cases": Remaining;
 };
 /**
  * The "no output type declared" sentinel for a builder's `Declared` parameter.
- * A `unique symbol` so no user type can collide with it. Declaration-only —
- * `tsc` emits it into the `.d.ts` without it needing to be exported.
+ *
+ * @remarks
+ * A string-keyed brand, **not** a `unique symbol`: every unpinned builder's
+ * type carries it (`Matcher<E, R, O, Unset>`), so a consumer's
+ * `export const m = match(x).with(…)` has to be able to print it under
+ * declaration emit. A non-exported `unique symbol` cannot be named there
+ * (TS2527), while an object literal type can always be written out. No user
+ * type collides with it in practice — the key is the explanation.
  *
  * @internal
  */
-declare const UNSET: unique symbol;
-/** @internal */
-type Unset = typeof UNSET;
+type Unset = {
+  readonly "unthrown: no output type declared — call .returnType<R>() to pin one": true;
+};
 /**
  * A branch handler's return position: free inference (`O2`) while the builder
  * is unpinned — today's behaviour, unchanged — or the declared type once
@@ -148,7 +175,7 @@ type Matcher<E, Remaining, O, Declared = Unset> = {
    * `Remaining`, so cases already handled by earlier arms are excluded); the
    * matched cases are subtracted from `Remaining`.
    */
-  with<const Pts extends readonly [unknown, ...unknown[]], O2>(...args: [...patterns: Pts, handler: (value: Extract<Remaining, MatchedOf<Pts[number]>>) => BranchReturn<Declared, O2>]): Matcher<E, Exclude<Remaining, MatchedOf<Pts[number]>>, O | O2, Declared>;
+  with<const Pts extends readonly [unknown, ...unknown[]], O2>(...args: [...patterns: { [I in keyof Pts]: NoEmptyPattern<Pts[I]>; }, handler: (value: Extract<Remaining, MatchedOf<Pts[number]>>) => BranchReturn<Declared, O2>]): Matcher<E, Exclude<Remaining, MatchedOf<Pts[number]>>, O | O2, Declared>;
   /**
    * Declare the match's output type up front: every subsequent branch handler
    * is checked against `R`, and the match evaluates to `R` instead of the
@@ -183,7 +210,7 @@ type Matcher<E, Remaining, O, Declared = Unset> = {
    * naming the remaining cases, and the builder fails the `ExhaustiveMatch`
    * constraint at the combinator call site.
    */
-  exhaustive: [Remaining] extends [never] ? () => PinnedOut<Declared, O> : NonExhaustive<Remaining>;
+  exhaustive: [Remaining] extends [never] ? () => PinnedOut<Declared, O> : UnhandledCases<Remaining>;
   /**
    * Execute the match (the combinators call this; it runs `.exhaustive()`).
    * A value with no matching arm throws {@link NonExhaustiveError} —
@@ -200,8 +227,25 @@ type Matcher<E, Remaining, O, Declared = Unset> = {
  * 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"
+ * }
+ * ```
  */
-declare class NonExhaustiveError extends Error {
+export declare class NonExhaustiveError extends Error {
   /** The value no arm matched. */
   readonly input: unknown;
   constructor(input: unknown);
@@ -220,8 +264,26 @@ declare class NonExhaustiveError extends Error {
  * {@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">
+ * ```
  */
-declare function match<const E>(value: E): Matcher<E, E, never>;
+export declare function match<const E>(value: E): Matcher<E, E, never>;
 /**
  * The pattern namespace (unthrown's own; the former ts-pattern `P`):
  *
@@ -246,1932 +308,2014 @@ declare function match<const E>(value: E): Matcher<E, E, never>;
  *   (`.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,
+ * });
+ * ```
  */
-declare const P: Readonly<{
+export declare const P: Readonly<{
   _: UniversalPattern;
   tag: <const Tag extends string>(value: Tag) => {
-    _tag: Tag;
+    readonly _tag: Tag;
   };
   instanceOf: <C extends abstract new (...args: never[]) => unknown>(cls: C) => PatternMatcher<InstanceType<C>>;
   when: <G>(guard: (value: unknown) => value is G) => PatternMatcher<G>;
 }>;
 //#endregion
-//#region src/types.d.ts
+//#region src/core.d.ts
 /**
- * Flatten an intersection into a single object literal so accumulated `bind` /
- * `let` scopes display cleanly (`{ a; b }` rather than `{ a } & { b }`).
+ * Thrown by a {@link Result}'s `get` / `getErr` when the assertion is
+ * wrong on a *modeled* result — `get()` on an `Err`, or `getErr()` on an
+ * `Ok`.
  *
- * @internal
- */
-type Prettify<T> = { [K in keyof T]: T[K]; } & {};
-/**
- * The scope produced by a `bind` / `let` step: `T` with `K` added (as a readonly
- * property of type `U`). `Omit<T, K>` first drops any existing `K`, so re-binding
- * a name **overwrites** it — matching the runtime spread — rather than producing
- * an unsound `T[K] & U` intersection.
+ * @remarks
+ * The offending value is exposed two ways: the typed {@link GetError.error}
+ * property for programmatic access, and the standard `Error.cause` for the
+ * runtime and devtools to chain — when `E` is an `Error` (e.g. a `TaggedError`)
+ * its original stack is printed under "caused by".
  *
- * @internal
+ * A `Defect` is never wrapped in a `GetError`: its original cause is
+ * re-thrown (with its original stack) instead.
+ *
+ * `get()` and `getErr()` are type-gated (`this: Result<T, never>` /
+ * `Result<never, E>`), so the wrong-variant branch that throws this is
+ * unreachable through well-typed code — it remains only as a defensive guard
+ * against unsound runtime misuse (e.g. an `as` cast past the gate).
+ *
+ * @typeParam E - the type of the {@link GetError.error} it carries.
+ *
+ * @category Errors
  */
-type Bound<T, K extends string, U> = Prettify<Omit<T, K> & { readonly [P in K]: U; }>;
+export declare class GetError<E = unknown> extends Error {
+  /**
+   * The offending value: the `Err` error for `get()`, or the `Ok` value for
+   * `getErr()`.
+   */
+  readonly error: E;
+  constructor(error: E);
+}
 /**
- * Compile-time rejection of a thenable callback result — the type-level
- * enforcement of "combinator callbacks are synchronous" (see the
- * {@link AsyncResult} remarks).
+ * Type guard: is `x` a {@link Result} (any of `Ok` / `Err` / `Defect`)?
  *
  * @remarks
- * Resolves to `unknown` (a no-op in an intersection) for any non-thenable `R`,
- * and to an explanatory string-literal type when `R` is a `PromiseLike` — so an
- * `async` callback fails to compile with the explanation in the error. Without
- * this, `async () => …` would be assignable to `() => void`, and its rejection
- * would escape the pipeline as an unhandled rejection instead of a `Defect`.
- * Lift async work with {@link fromPromise} and compose it with `flatMap`.
+ * Unlike {@link isOk} / {@link isErr} / {@link isDefect}, which narrow a value
+ * already known to be a `Result`, this narrows from `unknown` — useful at an
+ * untyped boundary. It checks the value carries the `Result` prototype
+ * (`instanceof` first, falling back to the `Symbol.for("unthrown.Result")`
+ * 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; 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`.
  *
- * Spelled with `Extract`, not `[R] extends [PromiseLike<…>]`, so the ban also
- * fires when only SOME arms of a union return are thenable — a *sometimes*-async
- * callback (`flag ? 1 : work()`) is still an unawaited effect whose rejection
- * the pipeline never sees. The tuple-wrapped form is false for a partial union
- * and let exactly that through. This is the same reasoning `fromPromise`'s
- * async-qualify guard already used.
+ * @returns `true` when `x` is a `Result` produced by this library.
  *
- * @typeParam R - the callback's inferred return type.
- * @category Types
+ * @example
+ * ```ts
+ * import { isResult, Ok, P } from "unthrown";
+ *
+ * isResult(Ok(1)); // => true
+ * isResult({ tag: "Ok" }); // => false (look-alike, wrong prototype)
+ * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)
+ *
+ * const x: unknown = Ok(1);
+ * if (isResult(x))
+ *   // `E` is `unknown` here — an untyped boundary has no cases to enumerate,
+ *   // so the `P._` escape hatch is the only arm that can terminate the match:
+ *   // oxlint-disable-next-line unthrown/no-catch-all-pattern -- untyped boundary: `E` is `unknown`
+ *   x.match({
+ *     ok: () => 1,
+ *     errCases: (m) => m.with(P._, () => 0),
+ *     defect: () => -1,
+ *   });
+ * ```
+ *
+ * @category Guards
  */
-type NotThenable<R> = [Extract<R, PromiseLike<unknown>>] extends [never] ? unknown : "unthrown: combinator callbacks are synchronous — lift async work with fromPromise and compose with flatMap";
+export declare function isResult(x: unknown): x is Result<unknown, unknown>;
+//#endregion
+//#region src/do.d.ts
 /**
- * The built-in match builder over an error union `E`, as produced by
- * `match(error)`. This is what an error combinator's callback receives — chain
- * `.with(pattern, handler)` on it; the combinator itself calls `.exhaustive()`,
- * so the callback returns the **un-terminated** builder.
+ * Start a do-notation chain with an empty object scope, grown step by step with
+ * `bind` (for `Result`-returning steps) and `let` (for pure values).
  *
  * @remarks
- * Named via `ReturnType<typeof match<E>>` (i.e. `Matcher<E, E, never>`),
- * keeping this alias stable however the builder evolves.
+ * Capitalised because `do` is a reserved word. Each step receives the scope
+ * accumulated so far; the error types union across `bind`s, and a throw in any
+ * step becomes a `Defect`. To go asynchronous, lift the chain with `toAsync()`
+ * (then a `bind` may return an `AsyncResult`).
  *
- * @typeParam E - the error union being matched.
- * @category Types
- */
-type ErrMatcher<E> = ReturnType<typeof match<E>>;
-/**
- * The shape an error-combinator callback must return: an **exhaustive**
- * match builder. `exhaustive` is required to be *callable* — on a builder
- * that hasn't covered every case the matcher types it as a branded diagnostic
- * (not a function), so a non-exhaustive chain fails to satisfy this and errors
- * at the call site. `run` carries the output type.
+ * @example
+ * ```ts
+ * import { Do, Ok } from "unthrown";
  *
- * @typeParam O - the union of the branch return types (the builder's output).
- * @internal
+ * const result = Do()
+ *   .bind("user", () => findUser(id)) // Result<User, NotFound>
+ *   .bind("org", ({ user }) => findOrg(user.orgId)) // Result<Org, NotFound>
+ *   .let("label", ({ user, org }) => `${user.name} @ ${org.name}`)
+ *   .map(({ user, org, label }) => render(user, org, label));
+ * // Result<View, NotFound>
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { Do, Ok, Err } from "unthrown";
+ *
+ * // Ok path — the scope accumulates:
+ * Do()
+ *   .bind("a", () => Ok(2))
+ *   .let("b", ({ a }) => a * 10)
+ *   .map(({ a, b }) => a + b); // => Ok(22)
+ *
+ * // Err path — the first Err short-circuits the rest:
+ * Do()
+ *   .bind("a", () => Err("boom"))
+ *   .let("b", ({ a }) => a); // => Err("boom")
+ * ```
+ *
+ * @category Do-notation
  */
-type ExhaustiveMatch<O> = {
-  exhaustive: (...args: never[]) => unknown;
-  run: () => O;
-};
+export declare function Do(): Result<{}, never>;
 /**
- * The output of an `ExhaustiveMatch` — the union of its branch returns.
+ * Start an **asynchronous** do-notation chain with an empty object scope — the
+ * pre-lifted form of {@link Do}, sparing you `Do().toAsync()`.
  *
- * @internal
+ * @remarks
+ * From here a `bind` may return a `Result` **or** an `AsyncResult`; the scope
+ * accumulates exactly as in a sync {@link Do} chain, and a throw in any step
+ * becomes a `Defect`. Named with the `Async` suffix the async free functions
+ * carry (`OkAsync`, `allAsync`); the {@link AsyncResult} companion aliases it as
+ * `AsyncResult.Do` (the namespace already says "async", so the suffix drops).
+ *
+ * @example
+ * ```ts
+ * import { DoAsync, Ok } from "unthrown";
+ *
+ * const result = await DoAsync()
+ *   .bind("user", () => findUser(id)) // AsyncResult<User, NotFound>
+ *   .bind("plan", ({ user }) => Ok(user.plan)) // a sync Result is accepted too
+ *   .let("label", ({ user, plan }) => `${user.name} on ${plan}`);
+ * // Result<{ user: User; plan: Plan; label: string }, NotFound>
+ * ```
+ *
+ * @category Do-notation
  */
-type MatchOut<M> = M extends ExhaustiveMatch<infer O> ? O : never;
+export declare function DoAsync(): AsyncResult<{}, never>;
+//#endregion
+//#region src/interop.d.ts
 /**
- * The outgoing modeled-error type a transforming match produces: the builder's
- * output with the `Defect` arm **subtracted** (`Exclude<O, Defect>`, the same
- * inference as the boundary `qualify`, Thesis #3). A branch that returns
- * `defect(cause)` therefore contributes nothing to the modeled channel.
+ * Bridge a nullable value into a {@link Result}: absence becomes a **modeled**
+ * `Err`. The sanctioned alternative to an `Option` type.
  *
- * @internal
+ * @remarks
+ * `null` and `undefined` map to `Err(onAbsent())`; any other value (including
+ * falsy ones like `0`, `""`, `false`) maps to `Ok`.
+ *
+ * @typeParam T - the (nullable) value type.
+ * @typeParam E - the error produced when the value is absent.
+ * @param value - the possibly-absent value.
+ * @param onAbsent - lazily produces the error for the absent case.
+ *
+ * @category Interop
+ *
+ * @example
+ * ```ts
+ * import { fromNullable } from "unthrown";
+ *
+ * const map = new Map([["a", 1]]);
+ * fromNullable(map.get("a"), () => "absent").getOr(0); // => 1
+ * fromNullable(map.get("z"), () => "absent"); // => Err("absent")
+ * fromNullable(0, () => "absent").getOr(-1); // => 0 (falsy but present)
+ * ```
  */
-type MatchErrOut<M> = Exclude<MatchOut<M>, Defect>;
+export declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () => E): Result<NonNullable<T>, E>;
 /**
- * The fluent method surface every {@link Result} variant carries — the
- * combinators (`map`, `flatMap`, `mapErrCases`, `match`, `get`, …), documented one
- * per entry below. Factored out so the three variants ({@link OkView},
- * {@link ErrView}, {@link DefectView}) can each intersect it; {@link AsyncResult}
- * mirrors this surface with async signatures.
+ * Wrap a throwing synchronous function so it returns a {@link Result} instead of
+ * throwing.
  *
  * @remarks
- * This type exists to **document** the surface and to power narrowing — not to be
- * authored against. You obtain it by holding a `Result` (or `AsyncResult`), never
- * by implementing your own `Result`-like; treat it as read-only reference.
+ * `qualify` **must** triage every thrown cause into a modeled error `E` or a
+ * `Defect` (via the injected `defect` helper, its second argument) — there is no
+ * path that leaves `unknown` in `E`. A throw inside `qualify` itself is treated
+ * as a `Defect`. `qualify` is **synchronous**: an `async` qualify is rejected at
+ * compile time ({@link NotThenable}) — its `Promise` would land in `E` un-triaged
+ * — and a thenable slipped past the types at runtime becomes a `Defect` (never
+ * an `Err(Promise)`), its orphaned rejection silenced.
  *
- * @typeParam T - the success value type.
- * @typeParam E - the modeled error type.
- * @category Methods
- */
-type ResultMethods<out T, out E> = {
-  /**
-   * Transform the success value with `f`.
-   *
-   * Runs `f` only on `Ok`; `Err` and `Defect` pass through untouched. If `f`
-   * throws, the thrown value is captured as a `Defect`.
-   *
-   * An async callback is rejected at compile time ({@link NotThenable}).
-   *
-   * @typeParam U - the mapped success type.
-   * @param f - maps the current success value to a new one.
-   */
-  map<U>(f: (value: T) => U & NotThenable<U>): Result$1<U, E>;
-  /**
-   * Sequence a dependent, `Result`-returning step (monadic bind).
-   *
-   * Runs `f` only on `Ok`; `Err` and `Defect` pass through. The error channels
-   * combine, widening to `E | E2`. If `f` throws, the throw becomes a `Defect`.
-   *
-   * @typeParam U - the success type of the next step.
-   * @typeParam E2 - the error type the next step may introduce.
-   * @param f - produces the next `Result` from the current success value.
-   */
-  flatMap<U, E2>(f: (value: T) => Result$1<U, E2>): Result$1<U, E | E2>;
-  /**
-   * Run a side effect on the success value and pass the `Result` through
-   * unchanged.
-   *
-   * Runs only on `Ok`. If `f` throws, the throw becomes a `Defect`. An async
-   * callback is rejected at compile time ({@link NotThenable}).
-   *
-   * @remarks
-   * `f`'s return value is **ignored** — a `Result` returned by the effect
-   * compiles but is discarded, `Err` and all. If the effect can fail, sequence
-   * it instead of tapping it: a `Result`-returning effect goes in
-   * {@link ResultMethods.flatTap | flatTap}; an `AsyncResult`-returning effect
-   * cannot be sequenced from the sync surface — lift the chain with
-   * {@link ResultMethods.toAsync | toAsync} and use the async
-   * {@link AsyncResultMethods.flatTap | flatTap} (which accepts both).
-   *
-   * @param f - the side effect (its return value is ignored).
-   */
-  tap<R>(f: (value: T) => R & NotThenable<R>): 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>;
-  /**
-   * Do-notation: run `f` for a `Result` and **bind its value** under `name` in
-   * an accumulating object scope.
-   *
-   * @remarks
-   * Begin a chain with {@link Do} (an empty object scope) and grow it step by
-   * step. `f` receives the scope accumulated so far and returns a `Result`; on
-   * `Ok` the value is added as `{ ...scope, [name]: value }`, on `Err`/`Defect`
-   * the chain short-circuits. Errors union (`E | E2`). A throw becomes a
-   * `Defect` — as does calling `bind` on a non-object scope (e.g. `Ok(5).bind`),
-   * which is misuse: the scope is always an object inside a real `Do()` chain.
-   * (`let` is the pure-value counterpart.)
-   *
-   * @typeParam K - the key the bound value is stored under.
-   * @typeParam U - the bound value type.
-   * @typeParam E2 - the error type `f` may introduce.
-   * @param name - the scope key.
-   * @param f - produces a `Result` from the accumulated scope.
-   */
-  bind<K extends string, U, E2>(name: K, f: (scope: T) => Result$1<U, E2>): Result$1<Bound<T, K, U>, E | E2>;
-  /**
-   * Do-notation: run `f` for a **plain value** and bind it under `name` in the
-   * accumulating object scope. The pure-value counterpart of {@link ResultMethods.bind | bind}.
-   *
-   * @remarks
-   * `f` receives the scope and returns a value (not a `Result`); it is added as
-   * `{ ...scope, [name]: value }`. Runs only on `Ok`; `Err`/`Defect` pass
-   * through. A throw becomes a `Defect`. An async callback is rejected at
-   * compile time ({@link NotThenable}).
-   *
-   * @typeParam K - the key the value is stored under.
-   * @typeParam U - the value type.
-   * @param name - the scope key.
-   * @param f - computes a value from the accumulated scope.
-   */
-  let<K extends string, U>(name: K, f: (scope: T) => U & NotThenable<U>): Result$1<Bound<T, K, U>, E>;
-  /**
-   * Replace the success value with a constant `value`.
-   *
-   * Runs only on `Ok`; `Err` and `Defect` pass through.
-   *
-   * @typeParam U - the replacement value type.
-   */
-  as<U>(value: U): Result$1<U, E>;
-  /**
-   * Drop the success value, collapsing the success type to `void`.
-   *
-   * The named form of `map(() => undefined)`. Runs only on `Ok` (the value is
-   * replaced with `undefined`); `Err` and `Defect` pass through. Unlike
-   * `as(undefined)` — which produces `Result<undefined, E>` — the success type
-   * is `void`: the value's story ends here.
-   */
-  discard(): Result$1<void, E>;
-  /**
-   * Validate the success value — keep the `Ok` when `predicate` holds,
-   * otherwise fail into the **modeled** channel with `Err(onFail(value))`.
-   *
-   * @remarks
-   * The named form of `flatMap((v) => (p(v) ? Ok(v) : Err(e)))`. With a
-   * **type-guard** predicate (`(v): v is U`) the success type is **refined** to
-   * `U` on the way through (this overload). Runs only on `Ok` — a passing value
-   * flows through as the *same* `Ok`; `Err` and `Defect` pass through
-   * untouched. A throw in `predicate` or `onFail` becomes a `Defect`.
-   *
-   * Both callbacks are synchronous: an async `onFail` is rejected at compile
-   * time ({@link NotThenable}), and an async predicate does not type-check
-   * either — its `Promise<boolean>` is not a `boolean` (and, being truthy,
-   * would have silently always passed).
-   *
-   * @typeParam U - the refined success type (type-guard form).
-   * @typeParam E2 - the error type `onFail` produces.
-   * @param predicate - the check; a type guard refines `T` to `U`.
-   * @param onFail - maps the failing value to the modeled error.
-   *
-   * @example
-   * ```ts
-   * // boolean form: gate a value
-   * Ok(-1).ensure((n) => n > 0, (n) => `negative: ${n}`); // Err("negative: -1")
-   *
-   * // type-guard form: refine the success type
-   * declare const r: Result<string | number, "e">;
-   * const s = r.ensure(
-   *   (v): v is string => typeof v === "string",
-   *   () => "not_a_string" as const,
-   * ); // Result<string, "e" | "not_a_string">
-   * ```
-   */
-  ensure<U extends T, E2>(predicate: (value: T) => value is U, onFail: (value: T) => E2 & NotThenable<E2>): Result$1<U, E | E2>;
-  /**
-   * Boolean form of {@link ResultMethods.ensure | ensure} — validates without
-   * refining, keeping the success type `T`.
-   */
-  ensure<E2>(predicate: (value: T) => boolean, onFail: (value: T) => E2 & NotThenable<E2>): Result$1<T, E | E2>;
-  /**
-   * Transform the modeled error by **matching it exhaustively**.
-   *
-   * @remarks
-   * The callback receives `match(error)` (an {@link ErrMatcher}) and the
-   * injected `defect` helper. Chain `.with(pattern, handler)` and **return the
-   * un-terminated builder** — `mapErrCases` calls `.exhaustive()` itself, so a
-   * missing case is a compile error at the call site (there is no `.exhaustive()`
-   * to forget, and no way to slip in `.otherwise()`). The outgoing error type is
-   * the union of the branch returns with the `Defect` arm subtracted
-   * (`Exclude<O, Defect>`) — a branch returning `defect(cause)` converts that case
-   * to a `Defect` and drops it from `E`. Runs only on `Err`; `Ok` and `Defect`
-   * pass through. A branch that throws also becomes a `Defect`.
-   *
-   * **Name every case.** Match on anything the matcher supports — `_tag`,
-   * `code`, structural shape, guards — and group the cases that share a handler
-   * with `.with(a, b, handler)`. `.with(P._, …)` is the wildcard **escape
-   * hatch**, not the default: it makes any match exhaustive, so it also absorbs
-   * every case `E` grows later. Two uses are sanctioned — a helper generic in
-   * `E`, where no arm list can prove exhaustiveness against an unresolved type
-   * parameter, and an `E` that is a single type rather than a union of cases
-   * (see {@link P} for both). `@unthrown/oxlint`'s `no-catch-all-pattern` (in
-   * its `recommended` preset) flags the rest.
-   *
-   * @typeParam M - the exhaustive builder the callback returns.
-   * @param f - builds the match over the error (returns the un-terminated builder).
-   */
-  mapErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T, MatchErrOut<M>>;
-  /**
-   * Sequence from an `Err` by producing another `Result` — the error-channel
-   * mirror of {@link ResultMethods.flatMap | flatMap}, **matching the error
-   * exhaustively** ({@link ErrMatcher}; the combinator calls `.exhaustive()`).
-   *
-   * Each branch returns a `Result`; the outgoing channels are the unions of the
-   * branch-returned `Result`s' channels. A branch may return `defect(cause)`.
-   * Runs only on `Err`; `Ok` and `Defect` pass through.
-   *
-   * @typeParam M - the exhaustive builder the callback returns.
-   * @param f - builds the match; each branch produces a fallback `Result`.
-   */
-  flatMapErrCases<M extends ExhaustiveMatch<Result$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>>;
-  /**
-   * Recover from an `Err` by producing a success value, emptying the error
-   * channel — **matching the error exhaustively** ({@link ErrMatcher}). Pairs
-   * with {@link ResultMethods.recoverDefect | recoverDefect}.
-   *
-   * @remarks
-   * The result type is `Result<T | U, never>`, but `never` describes only the
-   * **error** channel — a `Defect` can still be present at runtime. A branch may
-   * return `defect(cause)` (which stays a `Defect`, not a recovery). Runs only on
-   * `Err`; `Ok` and `Defect` pass through.
-   *
-   * @typeParam M - the exhaustive builder the callback returns.
-   * @param f - builds the match; each branch produces a success value.
-   */
-  recoverErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result$1<T | MatchErrOut<M>, never>;
-  /**
-   * Run a side effect on the error — **matched exhaustively** ({@link ErrMatcher})
-   * — and pass the `Result` through unchanged.
-   *
-   * @remarks
-   * The callback builds a match whose branches run side effects; their return
-   * values are ignored and the original `Err` flows through. Exhaustive like the
-   * transformers, and like them it wants every case named — `.with(P._, …)`
-   * remains the wildcard escape hatch. If a branch throws, the
-   * result is a `Defect` whose cause is an `AggregateError` of `[thrown, original
-   * failure]` — observing a failure never destroys it. An **async branch is
-   * rejected at compile time** ({@link NotThenable} on the builder output):
-   * because the branch results are discarded, a returned `Promise` would float
-   * unobserved and its rejection would vanish. The one branch return that is
-   * **not** discarded is the injected `defect(cause)` marker: it is the
-   * lint-clean, expression-position form of a `throw`, so it follows the throw
-   * rule above (an `AggregateError` of `[the branch's cause, original
-   * failure]`), never a silent no-op. A failable
-   * `Result`-returning effect belongs in
-   * {@link ResultMethods.flatTapErrCases | flatTapErrCases}.
-   *
-   * @param f - builds the match; branch returns are ignored, bar `defect(cause)`.
-   */
-  tapErrCases<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): Result$1<T, E>;
-  /**
-   * Run a **failable** side effect on the error, keeping the original error but
-   * threading the effect's own error — **matched exhaustively**
-   * ({@link ErrMatcher}).
-   *
-   * @remarks
-   * The error-channel mirror of {@link ResultMethods.flatTap | flatTap}: each
-   * branch returns a `Result` whose **success value is discarded** — on the
-   * effect's `Ok` the original `Err` flows through, while an `Err`/`Defect` from a
-   * branch short-circuits and threads its error. Note the asymmetry with a
-   * *throw*: a branch that **returns** a Defect-state `Result` **replaces** the
-   * original `Err` (Defect-dominance, the short-circuit rule — it is not
-   * aggregated), whereas a branch that **throws** produces a `Defect`
-   * aggregating `[thrown, original failure]` (observing a failure by throwing
-   * never destroys it). A branch returning the injected `defect(cause)` marker —
-   * reachable under a `returnType` pin — follows the *throw* rule, since it is
-   * the lint-clean, expression-position form of one.
-   *
-   * @typeParam M - the exhaustive builder the callback returns.
-   * @param f - builds the match; each branch is a failable effect (its `Ok` is ignored).
-   */
-  flatTapErrCases<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2>>): Result$1<T, E | E2>;
-  /**
-   * Recover from a `Defect` — the **only** combinator that can touch one.
-   *
-   * @remarks
-   * Runs `f` only when a `Defect` is present, re-entering the modeled world by
-   * returning a `Result` (an `Ok` or a fresh `Err`). `Ok` and `Err` pass
-   * through. Recovering a Defect should be rare: usually you let it bubble to
-   * the edge. If `f` throws, the throw becomes a new `Defect`.
-   *
-   * @typeParam U - a success type the recovery may produce.
-   * @typeParam E2 - an error type the recovery may produce.
-   * @param f - maps the Defect's unknown cause to a recovering `Result`.
-   */
-  recoverDefect<U, E2>(f: (cause: unknown) => Result$1<U, E2>): Result$1<T | U, E | E2>;
-  /**
-   * Run a side effect on a present `Defect`'s cause (e.g. logging) and pass the
-   * `Defect` through unchanged. If `f` throws, the result is a `Defect` whose
-   * cause is an `AggregateError` of `[thrown, original failure]` — observing a
-   * failure never destroys it. An async callback is rejected at compile time
-   * ({@link NotThenable}).
-   *
-   * @param f - the side effect over the unknown cause.
-   */
-  tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): Result$1<T, E>;
-  /**
-   * Run a side effect on **any failure** — `Err` or `Defect` — and pass the
-   * `Result` through unchanged. The one cross-channel observer, for the shared
-   * "it went KO" concern (logging, metrics, rollback) that would otherwise be
-   * duplicated across {@link ResultMethods.tapErrCases | tapErrCases} and
-   * {@link ResultMethods.tapDefect | tapDefect}.
-   *
-   * @remarks
-   * `f` receives the narrowed **failure variant** ({@link FailureView}), not a
-   * payload — the payload union `E | unknown` would collapse to `unknown` and
-   * lose `E`'s typing. Branch on `failure.tag` to reach the typed payload
-   * (`"Err"` → `failure.error: E`, `"Defect"` → `failure.cause: unknown`), or
-   * treat it opaquely for a shared logger. Runs on `Err` and `Defect`; `Ok`
-   * passes through. It **observes without consuming**: the failure flows on
-   * unchanged — to also recover, use
-   * {@link ResultMethods.recoverErrCases | recoverErrCases} /
-   * {@link ResultMethods.recoverDefect | recoverDefect} (deliberately separate
-   * acts) or {@link ResultMethods.match | match} at the edge. If `f` throws, the
-   * result is a `Defect` whose cause is an `AggregateError` of `[thrown,
-   * original failure]` — observing a failure never destroys it. An async
-   * callback is rejected at compile time ({@link NotThenable}).
-   *
-   * @param f - the side effect over the failure variant (its return value is ignored).
-   */
-  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): Result$1<T, E>;
-  /**
-   * Exhaustively fold all three runtime states into a single value.
-   *
-   * @remarks
-   * Exactly one handler runs. Together with the throw-to-Defect guarantee, this
-   * is typically the single place a pipeline is handled at the edge — mapping
-   * `Ok`/`Err`/`Defect` to (for example) 2xx / 4xx / 5xx with no `try`/`catch`.
-   *
-   * The `errCases` handler does not take a single blanket callback: it receives
-   * `match(error)` (an {@link ErrMatcher}) and **matches the error exhaustively**,
-   * exactly like the error combinators — which is why the key carries the same
-   * `…Cases` suffix. Chain `.with(pattern, handler)` and **return the
-   * un-terminated builder** — `match` calls `.exhaustive()` itself, so a missing
-   * case is a compile error at the call site (no `.exhaustive()` to forget).
-   * Folding at the edge names every case too — `.with(P._, …)` is the wildcard
-   * escape hatch, not the default. Unlike the combinators the branches
-   * receive **no `defect` helper** — `match` is total elimination to a value,
-   * with no `Defect` output channel; the `defect` case handles a `Result` that
-   * already carries one. (A `Result` is also a discriminated union — for richer
-   * whole-`Result` matching, `match(result).with(…)`.)
-   *
-   * @typeParam ROk - the `ok` handler return type.
-   * @typeParam RDefect - the `defect` handler return type.
-   * @typeParam M - the exhaustive builder the `errCases` handler returns.
-   * @param cases - the `ok`/`defect` handlers plus the `errCases` matcher builder.
-   */
-  match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {
-    ok: (value: T) => ROk;
-    errCases: (matcher: ErrMatcher<E>) => M;
-    defect: (cause: unknown) => RDefect;
-  }): ROk | RDefect | MatchOut<M>;
-  /**
-   * Extract the success value.
-   *
-   * @remarks
-   * Compiles only when the error channel is empty (`E = never`) — eliminate
-   * modeled errors first (`match` / `recoverErrCases` / `flatMapErrCases`), or reach for the
-   * `getOr` / `getOrElse` / `getOrNull` / `getOrUndefined` family (which
-   * recover an `Err`). If you get a `'this' context` type error here, that is
-   * the gate: the receiver still has a non-`never` error channel.
-   *
-   * `E = never` empties only the **modeled** error channel — a `Defect` can
-   * still be present, and `get()` **rethrows its original cause** (it
-   * _panics_); `Result<T, never>` does not mean `get()` cannot throw.
-   *
-   * @returns the `Ok` value.
-   */
-  get(this: Result$1<T, never>): T;
-  /**
-   * Extract the modeled error.
-   *
-   * @remarks
-   * Compiles only when the success channel is empty (`T = never`) — eliminate
-   * the success case first. `T = never` is rarely the case in practice (a
-   * `Result` you hold usually still has a success type), so to inspect an
-   * error prefer an `isErr()` guard or, in tests, `@unthrown/vitest`'s
-   * `toBeErrWith`. A `Defect` still **rethrows its original cause** (a defect is
-   * a bug, not an absent value), so this does not mean `getErr()` can't throw.
-   *
-   * @returns the `Err` value.
-   */
-  getErr(this: Result$1<never, E>): E;
-  /**
-   * The success value, or `fallback` on `Err`.
-   *
-   * @typeParam U - the fallback type (may differ from `T`; the return widens to `T | U`).
-   * @param fallback - returned when the result is an `Err` (may be a different type; the return widens to `T | U`).
-   * @throws Re-throws on a `Defect` — a Defect is a bug, not an absent value, so
-   * it is never silently replaced.
-   */
-  getOr<U>(fallback: U): T | U;
-  /**
-   * The success value, or `f(error)` on `Err`.
-   *
-   * @typeParam U - the fallback type (may differ from `T`; the return widens to `T | U`).
-   * @param f - lazily computes the fallback from the error (may return a different type; the return widens to `T | U`).
-   * @throws Re-throws on a `Defect`.
-   */
-  getOrElse<U>(f: (error: E) => U): T | U;
-  /**
-   * The success value, or `null` on `Err`.
-   *
-   * @throws Re-throws on a `Defect`.
-   */
-  getOrNull(): T | null;
-  /**
-   * The success value, or `undefined` on `Err`.
-   *
-   * @throws Re-throws on a `Defect`.
-   */
-  getOrUndefined(): T | undefined;
-  /**
-   * The success value, or **throw** the modeled error on `Err`.
-   *
-   * @remarks
-   * A deliberate escape hatch off the errors-as-values model — it **throws the
-   * `Err` value as-is** at the call site, so a caller of the enclosing function
-   * sees a throw rather than a channel. Its home is **tests and scripts**,
-   * where "this `Result` had better be `Ok`" is the assertion and a throw is
-   * the correct failure mode.
-   *
-   * In production code, fold the error channel instead:
-   * {@link ResultMethods.recoverErrCases | recoverErrCases} empties `E`, so
-   * {@link ResultMethods.get | get} compiles and a case routed to the injected
-   * `defect(...)` panics with its original cause — with every case still named.
-   * {@link ResultMethods.match | match} and
-   * {@link ResultMethods.flatMapErrCases | flatMapErrCases} are the other two
-   * ways to keep the error a value. `@unthrown/oxlint`'s opt-in
-   * `no-get-or-throw` rule enforces this, exempting test files through an
-   * oxlint `overrides` entry.
-   *
-   * Type-gated as the **complement** of {@link ResultMethods.get | get}: it
-   * compiles only when the error channel is **non-empty** (`E` is not `never`) —
-   * there must be a modeled error for it to throw. On a `Result<T, never>` there
-   * is nothing to throw, so `getOrThrow` does not compile; use `get()` (which
-   * gates the other way). Together they partition extraction by the error
-   * channel's state, with no overlap.
-   *
-   * @returns the `Ok` value.
-   * @throws the modeled `error` on `Err`; re-throws the original `cause` on a
-   * `Defect` (a panic, like the rest of the `getOr…` family).
-   */
-  getOrThrow(this: [E] extends [never] ? "unthrown: getOrThrow is unnecessary here — the Err channel is empty (E = never), so there is nothing to throw. Use get() instead." : Result$1<T, E>): T;
-  /** 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$1<T, E>;
-};
+ * `fn` is **synchronous** too. An `async` `fn` rejects *after* this boundary has
+ * already returned, so its rejection could never reach `qualify`: it becomes a
+ * `Defect` (never `Ok(<Promise>)`) and the orphaned rejection is silenced rather
+ * than left to float. Reach for {@link fromPromise} to wrap async work.
+ *
+ * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
+ * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
+ * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is
+ * out-of-band and must not pollute the error channel); reach for
+ * {@link fromSafeThrowable} when every throw is a Defect.
+ *
+ * @typeParam A - the wrapped function's argument tuple.
+ * @typeParam T - the wrapped function's return 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 a modeled `E`, or marks it
+ * unmodeled by returning `defect(cause)` (the helper passed as its second arg).
+ * @returns a function with the same arguments returning `Result<T, E>`.
+ *
+ * @category Interop
+ *
+ * @example
+ * ```ts
+ * import { fromThrowable } from "unthrown";
+ *
+ * // Model the parse failure as an `Err`, everything unexpected as a `Defect`.
+ * const parse = fromThrowable(
+ *   (text: string) => JSON.parse(text) as unknown,
+ *   (cause, defect) =>
+ *     cause instanceof SyntaxError ? ("invalid_json" as const) : defect(cause),
+ * );
+ *
+ * parse('{"ok":true}').getOr(null); // => { ok: true }
+ * parse("nope"); // => Err("invalid_json")
+ * ```
+ */
+export declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T, qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R & NotThenable<R>): (...args: A) => Result<T, Exclude<R, Defect>>;
+/**
+ * Wrap a throwing synchronous function asserted **not** to fail in any modeled
+ * way: any throw becomes a `Defect`.
+ *
+ * @remarks
+ * The synchronous counterpart of {@link fromSafePromise}. Use it only when a
+ * throw genuinely indicates a bug rather than an anticipated outcome — the
+ * error channel is `never`, so there is nothing to triage; there is no
+ * `qualify`. When some throws *are* anticipated, reach for
+ * {@link fromThrowable} and triage them.
+ *
+ * `fn` is **synchronous**: an `async` `fn` becomes a `Defect` (never
+ * `Ok(<Promise>)`), with its orphaned rejection silenced rather than left to
+ * float. Reach for {@link fromSafePromise} to wrap async work.
+ *
+ * @typeParam A - the wrapped function's argument tuple.
+ * @typeParam T - the wrapped function's return type.
+ * @param fn - the throwing function to wrap.
+ * @returns a function with the same arguments returning `Result<T, never>`.
+ *
+ * @category Interop
+ *
+ * @example
+ * ```ts
+ * import { fromSafeThrowable } from "unthrown";
+ *
+ * // A decode failure here is a bug (the row came from our own schema), so
+ * // every throw is a defect — no throwaway `(cause, defect) => defect(cause)`.
+ * const decode = fromSafeThrowable((row: Row) => userSchema.parse(row));
+ *
+ * decode(row); // => Result<User, never> — a throw becomes a Defect
+ * ```
+ */
+export declare function fromSafeThrowable<A extends unknown[], T>(fn: (...args: A) => T): (...args: A) => Result<T, never>;
 /**
- * The `Ok` variant of a {@link Result}: a success carrying a `value`. This is
- * what a successful `isOk` guard narrows to, making `.value` reachable. It also
- * carries the shared fluent surface ({@link ResultMethods}).
+ * Wrap a `Promise` (or a thunk producing one) as an {@link AsyncResult}, forcing
+ * every rejection to be triaged.
+ *
+ * @remarks
+ * `qualify` **must** map each rejection cause into a modeled error `E` or a
+ * `Defect` (via the injected `defect` helper, its second argument). The returned
+ * `AsyncResult`'s internal promise never rejects; `await`-ing it always yields a
+ * `Result`. A throw inside `qualify` is itself a `Defect`. `qualify` is
+ * **synchronous**: an `async` qualify is rejected at compile time
+ * ({@link NotThenable}), and a thenable slipped past the types at runtime
+ * becomes a `Defect` (never an `Err(Promise)`), its orphaned rejection silenced.
+ *
+ * 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 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 a modeled `E`, or marks it
+ * unmodeled by returning `defect(cause)` (the helper passed as its second arg).
+ * @param _guard - compile-time only; never pass it. The phantom rest-tuple that
+ * enforces "qualify is synchronous": an `async` qualify makes this demand an
+ * impossible extra argument (whose type spells out the error), while a
+ * synchronous one leaves it empty. Encoded here — not on `qualify`'s return
+ * type — so `T`'s inference from `promise` is undisturbed.
+ *
+ * @category Interop
  *
  * @example
  * ```ts
- * if (r.isOk()) r.value; // r: OkView<T, E> here — .value is a T
- * ```
+ * import { fromPromise } from "unthrown";
  *
- * @category Types
+ * // A rejection with a NotFoundError becomes a modeled `Err`; anything else a Defect.
+ * const user = await fromPromise(fetchUser(id), (cause, defect) =>
+ *   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
+ * );
+ *
+ * if (user.isOk()) user.value; // => the fetched user
+ * // when fetchUser rejects with NotFoundError: user is Err("not_found")
+ * ```
  */
-interface OkView<out T, out E = never> extends ResultMethods<T, E> {
-  readonly tag: "Ok";
-  readonly value: T;
-}
+export declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R, ..._guard: [Extract<R, PromiseLike<unknown>>] extends [never] ? [] : ["unthrown: qualify must be synchronous — its Promise would land in E un-triaged"]): AsyncResult<T, Exclude<R, Defect>>;
 /**
- * The `Err` variant of a {@link Result}: a modeled failure carrying an `error`.
- * This is what a successful `isErr` guard narrows to, exposing `.error`. It also
- * carries the shared fluent surface ({@link ResultMethods}).
+ * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection
+ * becomes a `Defect`.
  *
  * @remarks
- * **Note the parameter order: `ErrView<E, T>` puts the error type _first_** — the
- * reverse of the `<T, E>` order used by {@link OkView}, {@link DefectView}, and
- * {@link Result} — because `Result<T, E>` narrows to `ErrView<E, T>` (the error is
- * the payload the guard makes reachable). You rarely write it by hand (a failed
- * `isErr()` narrows to it for you); if you do, mind the flip — `ErrView<MyError,
- * MyValue>`, not `ErrView<MyValue, MyError>`.
+ * Use this only when a rejection genuinely indicates a bug rather than an
+ * anticipated outcome — the error channel is `never`, so there is nothing to
+ * triage. (`await`-ing still yields a `Result`; it never throws.) The
+ * synchronous counterpart is {@link fromSafeThrowable}.
+ *
+ * @typeParam T - the resolved value type.
+ * @param promise - the promise, or a thunk returning one.
+ *
+ * @category Interop
  *
  * @example
  * ```ts
- * if (r.isErr()) r.error; // r: ErrView<E, T> here — .error is an E
+ * import { fromSafePromise } from "unthrown";
+ *
+ * (await fromSafePromise(Promise.resolve(3))).get(); // => 3
+ * // a rejection becomes a Defect (never a modeled Err):
+ * await fromSafePromise(Promise.reject(new Error("boom"))); // => Defect(Error("boom"))
  * ```
+ */
+export declare function fromSafePromise<T>(promise: Promise<T> | (() => Promise<T>)): AsyncResult<T, never>;
+/**
+ * The settler a {@link fromExecutor} executor receives. Settles the pending
+ * `AsyncResult` **once** — later calls are no-ops, exactly as `resolve` is on a
+ * `Promise`.
+ *
+ * @typeParam T - the success type.
+ * @typeParam E - the modeled error type.
  *
  * @category Types
  */
-interface ErrView<out E, out T = never> extends ResultMethods<T, E> {
-  readonly tag: "Err";
-  readonly error: E;
-}
+type Settle<T, E> = (result: Result<T, E> | Defect) => void;
 /**
- * The `Defect` variant of a {@link Result}: an unmodeled failure carrying a
- * `cause`. This is what a successful `isDefect` guard narrows to, exposing
- * `.cause`. It also carries the shared fluent surface ({@link ResultMethods}).
+ * Build an {@link AsyncResult} from a callback-style API — this library's
+ * answer to `new Promise((resolve, reject) => …)`.
+ *
+ * @remarks
+ * The settler takes a **`Result`**, not a value-or-reason pair: the caller names
+ * the variant, so no `unknown` can enter `E` and there is no `qualify` to pass.
+ * For a failure that is *not* modeled, settle the injected `defect` helper's
+ * marker — the same injection `qualify` receives, and the only way to reach the
+ * defect channel from inside an asynchronous callback (a `throw` there runs in
+ * its own turn, long after the executor body returned).
+ *
+ * `T` and `E` cannot be inferred from the body, since `settle` is a parameter.
+ * Supply them explicitly, or let them flow from an annotated target. Absent
+ * either, both default to `never` (Thesis #3: no path may produce `unknown` in
+ * `E`) — so an unannotated call is a compile error at the `settle(...)` call
+ * site, not a silently-`unknown` channel.
+ *
+ * An executor that never settles yields an `AsyncResult` that never resolves —
+ * the one hazard {@link fromPromise} does not have, and identical to
+ * `new Promise`.
+ *
+ * @typeParam T - the success type.
+ * @typeParam E - the modeled error type.
+ * @param executor - runs immediately; receives the settler and the `defect` helper.
+ *
+ * @category Interop
  *
  * @example
  * ```ts
- * if (r.isDefect()) r.cause; // r: DefectView<T, E> here — .cause is `unknown`
+ * import { fromExecutor, Err, Ok } from "unthrown";
+ *
+ * const listen = (port: number) =>
+ *   fromExecutor<Server, PortInUse>((settle, defect) => {
+ *     server.once("error", (cause) =>
+ *       isAddrInUse(cause) ? settle(Err(new PortInUse(port))) : settle(defect(cause)),
+ *     );
+ *     server.listen(port, () => settle(Ok(server)));
+ *   });
  * ```
+ */
+export declare function fromExecutor<T = never, E = never>(executor: (settle: Settle<T, E>, defect: (cause: unknown) => Defect) => void): AsyncResult<T, E>;
+/**
+ * The success channel of {@link all} / {@link allAsync}: a **positional tuple**
+ * for a fixed-length input (including the empty tuple), or a homogeneous
+ * **array** for a dynamic one.
  *
- * @category Types
+ * @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
  */
-interface DefectView<out T = never, out E = never> extends ResultMethods<T, E> {
-  readonly tag: "Defect";
-  readonly cause: unknown;
-}
+type AllOk<Rs extends readonly unknown[], Ts extends readonly unknown[]> = number extends Rs["length"] ? Ts[number][] : Ts;
 /**
- * A failure variant of a {@link Result}: an {@link ErrView} **or** a
- * {@link DefectView}. This is what a `tapFailure` callback receives — the
- * discriminated variant rather than a payload, because the payload union
- * `E | unknown` would collapse to `unknown` and lose `E`'s typing. Branch on
- * `tag` to narrow (`"Err"` → `.error: E`, `"Defect"` → `.cause: unknown`).
+ * A `[key, error]` pair from a record aggregate, correlated per key.
  *
  * @remarks
- * Like {@link ErrView}, the error type comes **first** (`FailureView<E, T>`) —
- * the error is the payload you are usually here for, and a shared observer can
- * spell just `FailureView<MyError>`.
+ * `-?` 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}. Keyed by any
+ * `PropertyKey`: a symbol key is folded like a string one (see
+ * {@link ownEntries}), so the constraint checks its value too.
+ */
+type ResultRecord = Record<PropertyKey, Result<unknown, unknown>>;
+/** A record of `AsyncResult`s — the input to {@link allFromDictAsync}. */
+type AsyncResultRecord = Record<PropertyKey, 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`. 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}. To report **every** `Err` instead of only the first,
+ * use {@link validateAll}.
+ *
+ * @category Aggregate
  *
  * @example
  * ```ts
- * const logKo = (f: FailureView<ApiError>) =>
- *   f.tag === "Err" ? logger.warn(f.error) : logger.error(f.cause);
- * result.tapFailure(logKo);
+ * import { all, Ok, Err } from "unthrown";
+ *
+ * all([Ok(1), Ok("a"), Ok(true)]).get(); // => [1, "a", true] (typed [number, string, boolean])
+ * all([Ok(1), Err("e"), Ok(3)]); // => Err("e") (short-circuits on the first Err)
  * ```
+ */
+export declare function all<Rs extends readonly Result<unknown, unknown>[]>(results: readonly [...Rs]): Result<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.
  *
- * @typeParam E - the modeled error type.
- * @typeParam T - the success value type (phantom here; a failure carries none).
- * @category Types
+ * @remarks
+ * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`
+ * 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
+ *
+ * @example
+ * ```ts
+ * import { allFromDict, Ok, Err } from "unthrown";
+ *
+ * allFromDict({ id: Ok(1), name: Ok("ada") }).get(); // => { id: 1, name: "ada" }
+ * allFromDict({ id: Ok(1), name: Err("missing") }); // => Err("missing")
+ * ```
  */
-type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
+export declare function allFromDict<R extends ResultRecord>(results: R): Result<{ [K in keyof R]: OkOf<R[K]>; }, ErrOf<R[keyof R]>>;
 /**
- * The core type of the library: a computation that has either succeeded with a
- * value of type `T` or failed with a *modeled* error of type `E`.
+ * The asynchronous counterpart of {@link all}: combine a tuple/array of
+ * {@link AsyncResult}s into one `AsyncResult` of all their success values.
  *
  * @remarks
- * A `Result` is a **discriminated union** of three variants, distinguished by a
- * `tag` of `"Ok"` | `"Err"` | `"Defect"`:
+ * 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};
+ * to report **every** `Err`, use {@link validateAllAsync}.
  *
- * - **`Ok`** — a success carrying a `value: T`.
- * - **`Err`** — a modeled, anticipated failure carrying an `error: E`.
- * - **`Defect`** — an *unmodeled* failure carrying an unknown `cause`. A Defect
- *   never appears in `E`; it is the library's third, out-of-band channel.
+ * @category Aggregate
  *
- * Because it is a real union, you can match it natively (a `switch` on `tag`, or
- * the built-in `match(...).with({ tag: "Ok" }, …).exhaustive()`), *and* it
- * carries the full method surface ({@link ResultMethods}) for fluent chaining.
- * Either way, the payload (`value`/`error`/`cause`) is only reachable after you
- * narrow — so "check before you access" still holds.
+ * @example
+ * ```ts
+ * import { allAsync, fromSafePromise } from "unthrown";
+ *
+ * const both = allAsync([
+ *   fromSafePromise(Promise.resolve(1)),
+ *   fromSafePromise(Promise.resolve(2)),
+ * ]);
+ * (await both).get(); // => [1, 2]
+ * ```
+ */
+export 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.
  *
- * @typeParam T - the success value type.
- * @typeParam E - the modeled error type (only anticipated domain failures).
+ * @remarks
+ * Resolved concurrently (order preserved), folded with the {@link all} rules,
+ * and the internal promise never rejects. To report **every** `Err`, use
+ * {@link validateAllFromDictAsync}.
+ *
+ * @category Aggregate
  *
  * @example
  * ```ts
- * import { Ok, Err, type Result } from "unthrown";
- *
- * function half(n: number): Result<number, "odd"> {
- *   return n % 2 === 0 ? Ok(n / 2) : Err("odd");
- * }
+ * import { allFromDictAsync, fromSafePromise } from "unthrown";
  *
- * const message = half(10).match({
- *   ok: (n) => `got ${n}`,
- *   // every case of `E` named — here the one literal it holds
- *   errCases: (matcher) => matcher.with("odd", () => "failed: odd"),
- *   defect: (cause) => `bug: ${String(cause)}`,
+ * const both = allFromDictAsync({
+ *   a: fromSafePromise(Promise.resolve(1)),
+ *   b: fromSafePromise(Promise.resolve("x")),
  * });
+ * (await both).get(); // => { a: 1, b: "x" }
  * ```
  */
-type Result$1<T, E> = OkView<T, E> | ErrView<E, T> | DefectView<T, E>;
+export declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]>; }, AsyncErrOf<R[keyof R]>>;
 /**
- * A success-only thenable: awaitable, but deliberately **not** a full
- * `PromiseLike`.
+ * 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
- * An {@link AsyncResult}'s internal promise never rejects, so `await`-ing one
- * always yields a {@link Result} and never throws — there is no rejection
- * channel to model, and none is advertised. At runtime it is still a thenable
- * (the only way `await` can collapse it), and `Promise.all` / `Promise.resolve`
- * will still adopt it — harmlessly, since it settles to a `Result` and never
- * rejects. What the narrowing prevents is treating it as a full promise:
- * `.catch()` / `.finally()` do not type-check, because there is no rejection to
- * handle.
+ * 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.
  *
- * @typeParam T - the value `await` resolves to.
+ * `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.
  *
- * @category Types
- */
-type Awaitable<out T> = {
-  then<R = T>(onfulfilled?: ((value: T) => R | PromiseLike<R>) | null): PromiseLike<R>;
-};
-/**
- * The async method surface every {@link AsyncResult} carries — the combinators
- * (`map`, `flatMap`, `mapErrCases`, `match`, `get`, …) with their asynchronous
- * signatures, documented one per entry below. The async mirror of
- * {@link ResultMethods}: each entry links its synchronous counterpart and states
- * only the async delta.
+ * 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.
  *
- * @remarks
- * Like {@link ResultMethods}, this type exists to **document** the surface — not
- * to be authored against; you obtain it by holding an `AsyncResult`. Its
- * combinator callbacks are **synchronous** (a raw `Promise` may never enter — see
- * the {@link AsyncResult} remarks); async work re-enters via {@link fromPromise}
- * and composes with `flatMap`. Systematic differences from the sync surface: the
- * binds return an `AsyncResult` (and additionally accept one), and the
- * eliminators return a `Promise`.
+ * `merge` must be **synchronous** — an `async` one is a compile error
+ * ({@link NotThenable}), since a `Promise` in `E` is an unqualified rejection.
  *
- * @typeParam T - the success value type.
- * @typeParam E - the modeled error type.
- * @category Methods
+ * 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>
+ * ```
  */
-type AsyncResultMethods<out T, out E> = {
-  /**
-   * Asynchronous {@link ResultMethods.map | map}: transforms the success value
-   * with `f`. `f` is synchronous; a throw becomes a `Defect`. An async callback
-   * is rejected at compile time ({@link NotThenable}).
-   */
-  map<U>(f: (value: T) => U & NotThenable<U>): AsyncResult$1<U, E>;
-  /**
-   * Asynchronous {@link ResultMethods.flatMap | flatMap}. Unlike the sync form,
-   * `f` may return a `Result` **or** an `AsyncResult` (never a raw `Promise`); a
-   * throw becomes a `Defect`.
-   *
-   * @remarks
-   * The async branch of `f`'s return type is spelled `Awaitable<Result<U, E2>> &
-   * { flatMap: unknown }` rather than `AsyncResult<U, E2>`: this is what you get
-   * by returning an `AsyncResult` (it satisfies both), but inference runs through
-   * the `Awaitable` then-channel so `U`/`E2` stay precise instead of collapsing
-   * to `unknown`, while the `{ flatMap: unknown }` marker still rejects a bare
-   * `Promise` (it has no `flatMap`). Just return a `Result` or an `AsyncResult`.
-   */
-  flatMap<U, E2>(f: (value: T) => Result$1<U, E2> | (Awaitable<Result$1<U, E2>> & {
-    flatMap: unknown;
-  })): AsyncResult$1<U, E | E2>;
-  /**
-   * Asynchronous {@link ResultMethods.tap | tap}. `f` is synchronous; a throw
-   * becomes a `Defect`. An async callback is rejected at compile time
-   * ({@link NotThenable}) — and so is a returned `AsyncResult` (it is
-   * awaitable). Beware the near-miss: _calling_ an `AsyncResult`-returning
-   * effect inside the callback without returning it compiles and leaves the
-   * effect floating — fire-and-forget, never awaited, its `Err`/`Defect`
-   * unobserved. If the effect returns a `Result`/`AsyncResult`, use
-   * {@link AsyncResultMethods.flatTap | flatTap}.
-   */
-  tap<R>(f: (value: T) => R & NotThenable<R>): AsyncResult$1<T, E>;
-  /**
-   * Asynchronous {@link ResultMethods.flatTap | 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> | (Awaitable<Result$1<unknown, E2>> & {
-    flatMap: unknown;
-  })): AsyncResult$1<T, E | E2>;
-  /**
-   * Asynchronous {@link ResultMethods.bind | bind} (do-notation). `f` may return
-   * a `Result` **or** an `AsyncResult`; its value is bound under `name` in the
-   * accumulating scope.
-   */
-  bind<K extends string, U, E2>(name: K, f: (scope: T) => Result$1<U, E2> | (Awaitable<Result$1<U, E2>> & {
-    flatMap: unknown;
-  })): AsyncResult$1<Bound<T, K, U>, E | E2>;
-  /**
-   * Asynchronous {@link ResultMethods.let | let} (do-notation). `f` returns a
-   * plain value, bound under `name`. An async callback is rejected at compile
-   * time ({@link NotThenable}).
-   */
-  let<K extends string, U>(name: K, f: (scope: T) => U & NotThenable<U>): AsyncResult$1<Bound<T, K, U>, E>;
-  /** Asynchronous {@link ResultMethods.as | as}: replaces the value with `value`. */
-  as<U>(value: U): AsyncResult$1<U, E>;
-  /** Asynchronous {@link ResultMethods.discard | discard}: drops the value, collapsing the success type to `void`. */
-  discard(): AsyncResult$1<void, E>;
-  /**
-   * Asynchronous {@link ResultMethods.ensure | ensure}: validate the success
-   * value — and, with a type-guard predicate (this overload), **refine** it —
-   * failing into the modeled channel with `Err(onFail(value))`. Both callbacks
-   * are synchronous (an async `onFail` is rejected at compile time,
-   * {@link NotThenable}); a throw in either becomes a `Defect`.
-   */
-  ensure<U extends T, E2>(predicate: (value: T) => value is U, onFail: (value: T) => E2 & NotThenable<E2>): AsyncResult$1<U, E | E2>;
-  /** Boolean form of the asynchronous {@link ResultMethods.ensure | ensure} — validates without refining, keeping `T`. */
-  ensure<E2>(predicate: (value: T) => boolean, onFail: (value: T) => E2 & NotThenable<E2>): AsyncResult$1<T, E | E2>;
-  /**
-   * Asynchronous {@link ResultMethods.mapErrCases | mapErrCases} — the same exhaustive
-   * {@link ErrMatcher} form; the combinator calls `.exhaustive()`.
-   */
-  mapErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T, MatchErrOut<M>>;
-  /**
-   * Asynchronous {@link ResultMethods.flatMapErrCases | flatMapErrCases} — the same
-   * exhaustive {@link ErrMatcher} form. Unlike the sync form, a branch may
-   * return a `Result` **or** an `AsyncResult`.
-   */
-  flatMapErrCases<M extends ExhaustiveMatch<Result$1<unknown, unknown> | AsyncResult$1<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | OkOf<MatchOut<M>> | AsyncOkOf<MatchOut<M>>, ErrOf<MatchOut<M>> | AsyncErrOf<MatchOut<M>>>;
-  /**
-   * Asynchronous {@link ResultMethods.recoverErrCases | recoverErrCases} — the same
-   * exhaustive {@link ErrMatcher} form. Branches are synchronous; a throw
-   * becomes a `Defect`.
-   */
-  recoverErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult$1<T | MatchErrOut<M>, never>;
-  /**
-   * Asynchronous {@link ResultMethods.tapErrCases | tapErrCases}. `f` is synchronous; if it
-   * throws — or a branch returns the injected `defect(cause)` marker, the
-   * expression-position form of a throw — the result is a `Defect` whose cause
-   * is an `AggregateError` of `[thrown, original failure]` — observing a failure
-   * never destroys it. An
-   * async branch is rejected at compile time ({@link NotThenable} on the
-   * builder output) — other branch results are discarded, so a rejected
-   * `Promise` would float unobserved. The
-   * {@link AsyncResultMethods.tap | tap} fire-and-forget caveat applies here
-   * too — a failable effect belongs in
-   * {@link AsyncResultMethods.flatTapErrCases | flatTapErrCases}.
-   */
-  tapErrCases<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): AsyncResult$1<T, E>;
-  /**
-   * Asynchronous {@link ResultMethods.flatTapErrCases | flatTapErrCases} — the
-   * error-channel mirror of `flatTap`. `f` may return a `Result` **or** an
-   * `AsyncResult`; its `Ok` value is discarded, an `Err`/`Defect` from `f`
-   * threads through, and if `f` throws — or a branch returns the injected
-   * `defect(cause)` marker, the expression-position form of a throw — the result
-   * is a `Defect` whose cause is an `AggregateError` of `[thrown, original
-   * failure]` — observing a failure never destroys it.
-   */
-  flatTapErrCases<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result$1<unknown, E2> | AsyncResult$1<unknown, E2>>): AsyncResult$1<T, E | E2>;
-  /**
-   * Asynchronous {@link ResultMethods.recoverDefect | recoverDefect}. `f` may
-   * return a `Result` or an `AsyncResult`.
-   */
-  recoverDefect<U, E2>(f: (cause: unknown) => Result$1<U, E2> | AsyncResult$1<U, E2>): AsyncResult$1<T | U, E | E2>;
-  /**
-   * Asynchronous {@link ResultMethods.tapDefect | tapDefect}. If `f` throws, the
-   * result is a `Defect` whose cause is an `AggregateError` of `[thrown,
-   * original failure]` — observing a failure never destroys it. An async
-   * callback is rejected at compile time ({@link NotThenable}).
-   */
-  tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): AsyncResult$1<T, E>;
-  /**
-   * Asynchronous {@link ResultMethods.tapFailure | tapFailure} — the
-   * cross-channel observer. `f` receives the narrowed failure variant
-   * ({@link FailureView}); if it throws, the result is a `Defect` whose cause
-   * is an `AggregateError` of `[thrown, original failure]` — observing a
-   * failure never destroys it. An async callback is rejected at compile time
-   * ({@link NotThenable}).
-   */
-  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): AsyncResult$1<T, E>;
-  /**
-   * Asynchronous {@link ResultMethods.match | match}. Handlers are synchronous
-   * (the `errCases` handler returns an exhaustive {@link ErrMatcher} builder, no
-   * `defect` helper); resolves to a `Promise` of the folded value.
-   */
-  match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {
-    ok: (value: T) => ROk;
-    errCases: (matcher: ErrMatcher<E>) => M;
-    defect: (cause: unknown) => RDefect;
-  }): Promise<ROk | RDefect | MatchOut<M>>;
-  /**
-   * Asynchronous {@link ResultMethods.get | get}. Compiles only when the
-   * error channel is empty (`this: AsyncResult<T, never>`); the returned promise
-   * rejects on a `Defect` (rethrowing its cause).
-   */
-  get(this: AsyncResult$1<T, never>): Promise<T>;
-  /**
-   * Asynchronous {@link ResultMethods.getErr | getErr}. Compiles only when
-   * the success channel is empty (`this: AsyncResult<never, E>`); the returned
-   * promise rejects on a `Defect` (rethrowing its cause).
-   */
-  getErr(this: AsyncResult$1<never, E>): Promise<E>;
-  /** Asynchronous {@link ResultMethods.getOr | getOr}. */
-  getOr<U>(fallback: U): Promise<T | U>;
-  /** Asynchronous {@link ResultMethods.getOrElse | getOrElse}. */
-  getOrElse<U>(f: (error: E) => U): Promise<T | U>;
-  /** Asynchronous {@link ResultMethods.getOrNull | getOrNull}. */
-  getOrNull(): Promise<T | null>;
-  /** Asynchronous {@link ResultMethods.getOrUndefined | getOrUndefined}. */
-  getOrUndefined(): Promise<T | undefined>;
-  /**
-   * Asynchronous {@link ResultMethods.getOrThrow | getOrThrow} — the returned
-   * promise **rejects** with the modeled error on `Err` (or the original cause
-   * on a `Defect`), rather than throwing synchronously. Gated the same way: it
-   * compiles only when the error channel is non-empty (`E` is not `never`).
-   */
-  getOrThrow(this: [E] extends [never] ? "unthrown: getOrThrow is unnecessary here — the Err channel is empty (E = never), so there is nothing to throw. Use get() instead." : AsyncResult$1<T, E>): Promise<T>;
-};
+export declare function validateAll<Rs extends readonly Result<unknown, unknown>[], E2>(results: readonly [...Rs], merge: (errors: NonEmpty<ErrOf<Rs[number]>>) => E2 & NotThenable<E2>): Result<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]>; }>, E2>;
 /**
- * The asynchronous counterpart of {@link Result}: an awaitable wrapper carrying
- * the {@link AsyncResultMethods} surface, collapsing to a `Result<T, E>` when
- * `await`-ed.
+ * Collect a **record** of {@link Result}s, accumulating every `Err` — the
+ * accumulating counterpart of {@link allFromDict}, and the named counterpart of
+ * {@link validateAll}.
  *
  * @remarks
- * **Combinator callbacks are synchronous.** A raw `Promise` may never enter an
- * `AsyncResult` method — that would be an un-qualified async boundary, and its
- * rejection would silently become a `Defect`, skipping the triage that
- * {@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 (`get`, …) return promises; the binds
- * (`flatMap`, `flatTap`, `flatMapErrCases`, `recoverDefect`) additionally accept an
- * `AsyncResult`. Its combinators are documented one per entry on
- * {@link AsyncResultMethods}.
+ * `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).
  *
- * To pattern-match an `AsyncResult`, `await` it first: `match(await ar)`.
+ * 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 T - the success value type.
- * @typeParam E - the modeled error type.
- */
-interface AsyncResult$1<out T, out E> extends Awaitable<Result$1<T, E>>, AsyncResultMethods<T, E> {}
-/**
- * Extract the success type `T` from a `Result` type — derive one type from
- * another instead of restating it (e.g. the payload a function returns).
+ * @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.
  *
- * @typeParam R - the `Result` type to inspect.
+ * @category Aggregate
  *
  * @example
  * ```ts
- * type R = Result<User, NotFound>;
- * type U = OkOf<R>; // User
- * type E = ErrOf<R>; // NotFound
- * ```
+ * import { validateAllFromDict, Ok, Err } from "unthrown";
  *
- * @category Types
+ * 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")
+ * ```
  */
-type OkOf<R> = R extends {
-  readonly tag: "Ok";
-  readonly value: infer T;
-} ? T : never;
+export declare function validateAllFromDict<R extends ResultRecord, E2>(results: R, merge: (entries: NonEmpty<DictErrEntry<R>>) => E2 & NotThenable<E2>): Result<{ [K in keyof R]: OkOf<R[K]>; }, E2>;
 /**
- * Extract the error type `E` from a `Result` type — the counterpart of
- * {@link OkOf}.
- *
- * @typeParam R - the `Result` type to inspect.
+ * The asynchronous counterpart of {@link validateAll}: collect a tuple/array of
+ * {@link AsyncResult}s, accumulating every `Err` into one merged error.
  *
- * @example
- * ```ts
- * type E = ErrOf<Result<User, NotFound>>; // NotFound
- * ```
+ * @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}.
  *
- * @category Types
- */
-type ErrOf<R> = R extends {
-  readonly tag: "Err";
-  readonly error: infer E;
-} ? E : never;
-/**
- * Extract the success type `T` from an {@link AsyncResult} type — the async
- * counterpart of {@link OkOf}.
+ * @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.
  *
- * @typeParam R - the `AsyncResult` type to inspect.
+ * @category Aggregate
  *
  * @example
  * ```ts
- * type T = AsyncOkOf<AsyncResult<User, NotFound>>; // User
- * ```
+ * import { validateAllAsync, OkAsync, ErrAsync } from "unthrown";
  *
- * @category Types
+ * const checked = validateAllAsync(
+ *   [OkAsync(1), ErrAsync("stock"), ErrAsync("credit")],
+ *   (errors) => errors.join(" and "),
+ * );
+ * // (await checked) => Err("stock and credit")
+ * ```
  */
-type AsyncOkOf<R> = R extends Awaitable<infer Res> ? OkOf<Res> : never;
+export declare function validateAllAsync<Rs extends readonly AsyncResult<unknown, unknown>[], E2>(results: readonly [...Rs], merge: (errors: NonEmpty<AsyncErrOf<Rs[number]>>) => E2 & NotThenable<E2>): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]>; }>, E2>;
 /**
- * Extract the error type `E` from an {@link AsyncResult} type — the async
- * counterpart of {@link ErrOf}.
+ * The asynchronous counterpart of {@link validateAllFromDict}: collect a record
+ * of {@link AsyncResult}s, accumulating every `Err` into one merged error.
  *
- * @typeParam R - the `AsyncResult` type to inspect.
+ * @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
- * type E = AsyncErrOf<AsyncResult<User, NotFound>>; // NotFound
- * ```
+ * import { validateAllFromDictAsync, OkAsync, ErrAsync } from "unthrown";
  *
- * @category Types
+ * const checked = validateAllFromDictAsync(
+ *   { stock: ErrAsync("none left"), credit: OkAsync(500) },
+ *   (entries) => entries.map(([key, error]) => `${key}: ${error}`).join("; "),
+ * );
+ * // (await checked) => Err("stock: none left")
+ * ```
  */
-type AsyncErrOf<R> = R extends Awaitable<infer Res> ? ErrOf<Res> : never;
+export declare function validateAllFromDictAsync<R extends AsyncResultRecord, E2>(results: R, merge: (entries: NonEmpty<AsyncDictErrEntry<R>>) => E2 & NotThenable<E2>): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]>; }, E2>;
 //#endregion
-//#region src/constructors.d.ts
+//#region src/facade.d.ts
 /**
- * Construct a successful `void` {@link Result} — `Result<void, never>` —
- * sparing you `Ok(undefined)` and typing the success channel `void`, not
- * `undefined`.
+ * Companion object grouping the **`Result`-producing** entry points under a
+ * 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.validateAll},
+ * {@link Result.validateAllFromDict}, {@link Result.isOk}, {@link Result.isErr},
+ * {@link Result.isDefect}, {@link Result.isResult}.
+ *
+ * @remarks
+ * Purely additive sugar — each member **is** the corresponding free function.
+ * The free functions remain the primary, tree-shakeable API; importing only
+ * `{ Ok }` never pulls this object in. The value `Result` and the type
+ * {@link Result} share one name (the companion-object pattern).
+ *
+ * The **async** entry points live on the sibling {@link AsyncResult} companion
+ * (`AsyncResult.fromPromise`, `AsyncResult.all`, …), grouped by what they
+ * return — a static lives in exactly one namespace.
+ *
+ * @category Facade
  *
  * @example
  * ```ts
- * import { Ok } from "unthrown";
- *
- * Ok(); // => a void success: Result<void, never>
+ * import { Result } from "unthrown";
+ * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).get(); // => 2
  * ```
- *
- * @category Constructors
  */
-declare function Ok(): Result$1<void, never>;
+export declare const Result: {
+  readonly Ok: typeof Ok;
+  readonly Err: typeof Err;
+  readonly Do: typeof Do;
+  readonly fromNullable: typeof fromNullable;
+  readonly fromThrowable: typeof fromThrowable;
+  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;
+  readonly isResult: typeof isResult;
+};
 /**
- * Construct a successful {@link Result}.
+ * The core type of the library: a computation that has either succeeded with a
+ * value of type `T` or failed with a *modeled* error of type `E`. Shares its
+ * name with the {@link Result | companion object} above (the value and type are
+ * one name); this is the type half.
  *
- * @typeParam T - the success value type.
- * @param value - the success value to wrap.
+ * @remarks
+ * A `Result` is a **discriminated union** of three variants, distinguished by a
+ * `tag` of `"Ok"` | `"Err"` | `"Defect"`:
  *
- * @example
- * ```ts
- * import { Ok } from "unthrown";
+ * - **`Ok`** — a success carrying a `value: T`.
+ * - **`Err`** — a modeled, anticipated failure carrying an `error: E`.
+ * - **`Defect`** — an *unmodeled* failure carrying an unknown `cause`. A Defect
+ *   never appears in `E`; it is the library's third, out-of-band channel.
  *
- * Ok(2).map((n) => n + 1); // => Ok(3)
- * Ok(42).get(); // => 42
- * ```
+ * Because it is a real union, you can match it natively (a `switch` on `tag`, or
+ * the built-in `match(...).with({ tag: "Ok" }, …).exhaustive()`), *and* it
+ * carries the full method surface for fluent chaining. Either way, the payload
+ * (`value`/`error`/`cause`) is only reachable after you narrow — so "check
+ * before you access" still holds.
+ *
+ * TypeDoc can't list a union's methods on this alias: its fluent combinators
+ * (`map`, `flatMap`, `match`, `get`, …) are documented one per entry on
+ * {@link ResultMethods} — the shared method surface every variant carries. For
+ * "which one do I reach for?", see the
+ * [Choosing a combinator](/reference/combinators) guide.
  *
- * @category Constructors
- */
-declare function Ok<T>(value: T): Result$1<T, never>;
-/**
- * Construct a failed {@link Result} carrying a **modeled** error.
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type (only anticipated domain failures).
  *
- * @typeParam E - the modeled error type.
- * @param error - the domain error to wrap.
+ * @category Facade
  *
  * @example
  * ```ts
- * import { Err } from "unthrown";
+ * import { Ok, Err, type Result } from "unthrown";
  *
- * Err("not_found").map((n) => n + 1); // => Err("not_found") (map skipped)
- * Err("not_found").getErr(); // => "not_found"
- * ```
+ * function half(n: number): Result<number, "odd"> {
+ *   return n % 2 === 0 ? Ok(n / 2) : Err("odd");
+ * }
  *
- * @category Constructors
+ * const message = half(10).match({
+ *   ok: (n) => `got ${n}`,
+ *   // every case of `E` named — here the one literal it holds
+ *   errCases: (matcher) => matcher.with("odd", () => "failed: odd"),
+ *   defect: (cause) => `bug: ${String(cause)}`,
+ * });
+ * ```
  */
-declare function Err<E>(error: E): Result$1<never, E>;
+export type Result<T, E> = OkView<T, E> | ErrView<E, T> | DefectView<T, E>;
 /**
- * Construct a successful `void` {@link AsyncResult} — `AsyncResult<void, never>`
- * — the pre-lifted form of the no-arg {@link Ok}, sparing you
- * `Ok(undefined).toAsync()`.
+ * Companion object grouping the **`AsyncResult`-producing** entry points under
+ * 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.validateAll}, {@link AsyncResult.validateAllFromDict}.
+ *
+ * @remarks
+ * The async sibling of {@link Result}. Statics are grouped by what they
+ * **return**, so the pre-lifted constructors, `fromExecutor`,
+ * `fromPromise`/`fromSafePromise`, and the async aggregates sit here rather
+ * than on {@link Result}; the namespace
+ * already conveys "async", so the members drop the `Async` suffix their free
+ * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is
+ * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;
+ * `AsyncResult.allFromDict` is
+ * `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.
+ *
+ * @category Facade
  *
  * @example
  * ```ts
- * import { OkAsync } from "unthrown";
- *
- * OkAsync(); // => a void success: AsyncResult<void, never>
+ * import { AsyncResult } from "unthrown";
+ * const user = await AsyncResult.fromPromise(
+ *   fetchUser(id),
+ *   (c, defect) => defect(c),
+ * );
+ * user.get(); // => the fetched user (on success)
  * ```
- *
- * @category Constructors
  */
-declare function OkAsync(): AsyncResult$1<void, never>;
+export declare const AsyncResult: {
+  readonly Ok: typeof OkAsync;
+  readonly Err: typeof ErrAsync;
+  readonly Do: typeof DoAsync;
+  readonly fromExecutor: typeof fromExecutor;
+  readonly fromPromise: typeof fromPromise;
+  readonly fromSafePromise: typeof fromSafePromise;
+  readonly all: typeof allAsync;
+  readonly allFromDict: typeof allFromDictAsync;
+  readonly validateAll: typeof validateAllAsync;
+  readonly validateAllFromDict: typeof validateAllFromDictAsync;
+};
 /**
- * Construct a successful {@link AsyncResult} from a pure value — the pre-lifted
- * form of {@link Ok}, sparing you `Ok(value).toAsync()`.
+ * The asynchronous counterpart of {@link Result}: an awaitable wrapper carrying
+ * the {@link AsyncResultMethods} surface, collapsing to a `Result<T, E>` when
+ * `await`-ed. Shares its name with the {@link AsyncResult | companion object}
+ * above (value and type are one name); this is the type half.
+ *
+ * @remarks
+ * **Combinator callbacks are synchronous.** A raw `Promise` may never enter an
+ * `AsyncResult` method — that would be an un-qualified async boundary, and its
+ * rejection would silently become a `Defect`, skipping the triage that
+ * {@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 (`get`, …) return promises; the binds
+ * (`flatMap`, `flatTap`, `flatMapErrCases`, `recoverDefect`) additionally accept an
+ * `AsyncResult`. Its combinators are documented one per entry — with their
+ * async signatures — on {@link AsyncResultMethods}. For "which one do I reach
+ * for?", see the [Choosing a combinator](/reference/combinators) guide.
  *
- * @remarks
- * Reach for this on the synchronous/early branch of an `AsyncResult`-returning
- * function, so both branches share one return type without a trailing
- * `.toAsync()`. Named with the `Async` suffix the async free functions carry
- * (`allAsync`, `allFromDictAsync`); the {@link AsyncResult} companion aliases it
- * as `AsyncResult.Ok` (the namespace already says "async", so the suffix drops).
+ * To pattern-match an `AsyncResult`, `await` it first: `match(await ar)`.
  *
  * @typeParam T - the success value type.
- * @param value - the success value to wrap.
+ * @typeParam E - the modeled error type.
  *
- * @example
- * ```ts
- * import { OkAsync, type AsyncResult } from "unthrown";
+ * @category Facade
+ */
+export interface AsyncResult<out T, out E> extends Awaitable<Result<T, E>>, AsyncResultMethods<T, E> {}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Flatten an intersection into a single object literal so accumulated `bind` /
+ * `let` scopes display cleanly (`{ a; b }` rather than `{ a } & { b }`).
  *
- * function loadItems(ids: string[]): AsyncResult<Item[], never> {
- *   if (ids.length === 0) return OkAsync([]); // no more Ok([]).toAsync()
- *   return itemRepository.load(ids);
- * }
- * ```
+ * @internal
+ */
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+/**
+ * The scope produced by a `bind` / `let` step: `T` with `K` added (as a readonly
+ * property of type `U`). `Omit<T, K>` first drops any existing `K`, so re-binding
+ * a name **overwrites** it — matching the runtime spread — rather than producing
+ * an unsound `T[K] & U` intersection.
  *
- * @category Constructors
+ * @internal
  */
-declare function OkAsync<T>(value: T): AsyncResult$1<T, never>;
+type Bound<T, K extends string, U> = Prettify<Omit<T, K> & { readonly [P in K]: U; }>;
 /**
- * Construct a failed {@link AsyncResult} carrying a **modeled** error — the
- * pre-lifted form of {@link Err}, sparing you `Err(error).toAsync()`.
+ * Compile-time rejection of a thenable callback result — the type-level
+ * enforcement of "combinator callbacks are synchronous" (see the
+ * {@link AsyncResult} remarks).
  *
  * @remarks
- * The error-channel mirror of {@link OkAsync}; see it for the naming and the
- * `AsyncResult.Err` companion alias.
- *
- * @typeParam E - the modeled error type.
- * @param error - the domain error to wrap.
- *
- * @example
- * ```ts
- * import { ErrAsync } from "unthrown";
+ * Resolves to `unknown` (a no-op in an intersection) for any non-thenable `R`,
+ * and to an explanatory string-literal type when `R` is a `PromiseLike` — so an
+ * `async` callback fails to compile with the explanation in the error. Without
+ * this, `async () => …` would be assignable to `() => void`, and its rejection
+ * would escape the pipeline as an unhandled rejection instead of a `Defect`.
+ * Lift async work with {@link fromPromise} and compose it with `flatMap`.
  *
- * ErrAsync("not_found"); // AsyncResult<never, string>
- * ```
+ * Spelled with `Extract`, not `[R] extends [PromiseLike<…>]`, so the ban also
+ * fires when only SOME arms of a union return are thenable — a *sometimes*-async
+ * callback (`flag ? 1 : work()`) is still an unawaited effect whose rejection
+ * the pipeline never sees. The tuple-wrapped form is false for a partial union
+ * and let exactly that through. This is the same reasoning `fromPromise`'s
+ * async-qualify guard already used.
  *
- * @category Constructors
+ * @typeParam R - the callback's inferred return type.
+ * @category Types
  */
-declare function ErrAsync<E>(error: E): AsyncResult$1<never, E>;
+type NotThenable<R> = [Extract<R, PromiseLike<unknown>>] extends [never] ? unknown : "unthrown: combinator callbacks are synchronous — lift async work with fromPromise and compose with flatMap";
 /**
- * Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.
- *
- * @returns `true` when `r` is `Ok`.
- *
- * @example
- * ```ts
- * import { isOk, Ok, Err, type Result } from "unthrown";
- *
- * isOk(Ok(1)); // => true
- * isOk(Err("boom")); // => false
+ * The built-in match builder over an error union `E`, as produced by
+ * `match(error)`. This is what an error combinator's callback receives — chain
+ * `.with(pattern, handler)` on it; the combinator itself calls `.exhaustive()`,
+ * so the callback returns the **un-terminated** builder.
  *
- * declare const r: Result<number, string>;
- * if (isOk(r)) r.value; // number, narrowed
- * ```
+ * @remarks
+ * Named via `ReturnType<typeof match<E>>` (i.e. `Matcher<E, E, never>`),
+ * keeping this alias stable however the builder evolves.
  *
- * @category Guards
+ * @typeParam E - the error union being matched.
+ * @category Types
  */
-declare function isOk<T, E>(r: Result$1<T, E>): r is OkView<T, E>;
+type ErrMatcher<E> = ReturnType<typeof match<E>>;
 /**
- * Type guard: narrow a {@link Result} to its `Err` variant, exposing `.error`.
- *
- * @returns `true` when `r` is `Err`.
- *
- * @example
- * ```ts
- * import { isErr, Ok, Err, type Result } from "unthrown";
+ * The shape an error-combinator callback must return: an **exhaustive**
+ * match builder. `exhaustive` is required to be *callable* — on a builder
+ * that hasn't covered every case the matcher types it as a branded diagnostic
+ * (not a function), so a non-exhaustive chain fails to satisfy this and errors
+ * at the call site. `run` carries the output type.
  *
- * isErr(Err("boom")); // => true
- * isErr(Ok(1)); // => false
+ * @typeParam O - the union of the branch return types (the builder's output).
+ * @internal
+ */
+type ExhaustiveMatch<O> = {
+  exhaustive: (...args: never[]) => unknown;
+  run: () => O;
+};
+/**
+ * The output of an `ExhaustiveMatch` — the union of its branch returns.
  *
- * declare const r: Result<number, string>;
- * if (isErr(r)) r.error; // string, narrowed
- * ```
+ * @internal
+ */
+type MatchOut<M> = M extends ExhaustiveMatch<infer O> ? O : never;
+/**
+ * The outgoing modeled-error type a transforming match produces: the builder's
+ * output with the `Defect` arm **subtracted** (`Exclude<O, Defect>`, the same
+ * inference as the boundary `qualify`, Thesis #3). A branch that returns
+ * `defect(cause)` therefore contributes nothing to the modeled channel.
  *
- * @category Guards
+ * @internal
  */
-declare function isErr<T, E>(r: Result$1<T, E>): r is ErrView<E, T>;
+type MatchErrOut<M> = Exclude<MatchOut<M>, Defect>;
 /**
- * Type guard: narrow a {@link Result} to its `Defect` variant, exposing `.cause`.
+ * The phantom rest-tuple guard that bans an **async branch** in the
+ * non-awaiting error transformers (`mapErrCases` / `recoverErrCases`): empty
+ * for a synchronous builder output, an impossible extra argument (labelled
+ * with the explanation) when any branch returns a thenable.
  *
  * @remarks
- * A `Defect` has no public constructor — it only arises at a boundary (e.g. a
- * callback throwing inside a combinator). This guard is how you detect one.
- *
- * @returns `true` when `r` is a `Defect`.
- *
- * @example
- * ```ts
- * import { isDefect, Ok } from "unthrown";
- *
- * // A throw inside a combinator is captured as a Defect:
- * const r = Ok(1).map(() => {
- *   throw new Error("boom");
- * });
- * isDefect(r); // => true
- * isDefect(Ok(1)); // => false
- *
- * if (isDefect(r)) r.cause; // unknown, narrowed
- * ```
+ * Those two run the matched branch without awaiting it, so an `async` branch
+ * put `Err(<Promise>)` / `Ok(<Promise>)` in the channel — a `Promise` in `E` is
+ * the un-triaged value Thesis #3 forbids — and its rejection floated
+ * unobserved.
+ *
+ * The first test, `[O] extends [Pass]`, is the **generic escape**: `Pass` is
+ * what the receiver's own channels already hold (`E` for `mapErrCases`,
+ * `T | E` for `recoverErrCases`), so re-emitting the error — the sanctioned
+ * `P._` use inside a helper generic in `E` — resolves to `[]` even while `E` is
+ * an unresolved type parameter. No `NotThenable`-style check can: TypeScript
+ * cannot decide "is not thenable" for an unresolved `E`, so `M &
+ * NotThenable<…>` (the `tapErrCases` spelling) rejected that helper outright.
+ * A thenable already in `E` is no new hole. Encoded as a trailing phantom
+ * (the `fromPromise` shape) rather than on the callback's return, which keeps
+ * the inference-bearing callback free of conditional types. A `this` gate
+ * would print the message more directly but breaks the verified `out T, out E`
+ * variance annotations (`Pass` mentions both). An `any` output (a mocked
+ * branch) is let through, as `U & NotThenable<U>` does.
  *
- * @category Guards
+ * @internal
  */
-declare function isDefect<T, E>(r: Result$1<T, E>): r is DefectView<T, E>;
-//#endregion
-//#region src/core.d.ts
+type SyncBranches<O, Pass> = [O] extends [Pass | Defect] ? [] : 0 extends 1 & O ? [] : [Extract<O, PromiseLike<unknown>>] extends [never] ? [] : [unthrown_errorMatcherBranchesAreSynchronous: "an async branch would put a Promise in the channel — lift async work with fromPromise and use flatMapErrCases"];
 /**
- * Thrown by a {@link Result}'s `get` / `getErr` when the assertion is
- * wrong on a *modeled* result — `get()` on an `Err`, or `getErr()` on an
- * `Ok`.
+ * The marker that keeps a bare `Promise` out of the async binds (`flatMap` /
+ * `flatTap` / `bind`) and the awaiting error combinators (`flatMapErrCases` /
+ * `flatTapErrCases`): every `AsyncResult` has a `flatMap`, a `Promise` has
+ * none, so a raw rejection cannot bypass qualification.
  *
  * @remarks
- * The offending value is exposed two ways: the typed {@link GetError.error}
- * property for programmatic access, and the standard `Error.cause` for the
- * runtime and devtools to chain — when `E` is an `Error` (e.g. a `TaggedError`)
- * its original stack is printed under "caused by".
+ * Structurally it is just `{ flatMap: unknown }`; the **name** is the
+ * diagnostic. An `async` callback fails with "Property 'flatMap' is missing in
+ * type 'Promise<…>' but required in type 'ReturnAnAsyncResultNotAPromise'",
+ * which says what to do — instead of the anonymous `{ flatMap: unknown }`, or
+ * (in the error combinators, which named `AsyncResult` itself) a list of 25
+ * missing methods. It always sits beside `Awaitable<Result<…>>`, so inference
+ * runs through the then-channel and stays junk-free (see
+ * {@link AsyncResultMethods.flatMap}).
  *
- * A `Defect` is never wrapped in a `GetError`: its original cause is
- * re-thrown (with its original stack) instead.
- *
- * `get()` and `getErr()` are type-gated (`this: Result<T, never>` /
- * `Result<never, E>`), so the wrong-variant branch that throws this is
- * unreachable through well-typed code — it remains only as a defensive guard
- * against unsound runtime misuse (e.g. an `as` cast past the gate).
+ * @internal
+ */
+type ReturnAnAsyncResultNotAPromise = {
+  flatMap: unknown;
+};
+/**
+ * The fluent method surface every {@link Result} variant carries — the
+ * combinators (`map`, `flatMap`, `mapErrCases`, `match`, `get`, …), documented one
+ * per entry below. Factored out so the three variants ({@link OkView},
+ * {@link ErrView}, {@link DefectView}) can each intersect it; {@link AsyncResult}
+ * mirrors this surface with async signatures.
  *
- * @typeParam E - the type of the {@link GetError.error} it carries.
+ * @remarks
+ * This type exists to **document** the surface and to power narrowing — not to be
+ * authored against. You obtain it by holding a `Result` (or `AsyncResult`), never
+ * by implementing your own `Result`-like; treat it as read-only reference.
  *
- * @category Errors
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @category Methods
  */
-declare class GetError<E = unknown> extends Error {
+type ResultMethods<out T, out E> = {
+  /**
+   * Transform the success value with `f`.
+   *
+   * Runs `f` only on `Ok`; `Err` and `Defect` pass through untouched. If `f`
+   * throws, the thrown value is captured as a `Defect`.
+   *
+   * An async callback is rejected at compile time ({@link NotThenable}).
+   *
+   * @typeParam U - the mapped success type.
+   * @param f - maps the current success value to a new one.
+   */
+  map<U>(f: (value: T) => U & NotThenable<U>): Result<U, E>;
+  /**
+   * Sequence a dependent, `Result`-returning step (monadic bind).
+   *
+   * Runs `f` only on `Ok`; `Err` and `Defect` pass through. The error channels
+   * combine, widening to `E | E2`. If `f` throws, the throw becomes a `Defect`.
+   *
+   * @typeParam U - the success type of the next step.
+   * @typeParam E2 - the error type the next step may introduce.
+   * @param f - produces the next `Result` from the current success value.
+   */
+  flatMap<U, E2>(f: (value: T) => Result<U, E2>): Result<U, E | E2>;
+  /**
+   * Run a side effect on the success value and pass the `Result` through
+   * unchanged.
+   *
+   * Runs only on `Ok`. If `f` throws, the throw becomes a `Defect`. An async
+   * callback is rejected at compile time ({@link NotThenable}).
+   *
+   * @remarks
+   * `f`'s return value is **ignored** — a `Result` returned by the effect
+   * compiles but is discarded, `Err` and all. If the effect can fail, sequence
+   * it instead of tapping it: a `Result`-returning effect goes in
+   * {@link ResultMethods.flatTap | flatTap}; an `AsyncResult`-returning effect
+   * cannot be sequenced from the sync surface — lift the chain with
+   * {@link ResultMethods.toAsync | toAsync} and use the async
+   * {@link AsyncResultMethods.flatTap | flatTap} (which accepts both).
+   *
+   * @param f - the side effect (its return value is ignored).
+   */
+  tap<R>(f: (value: T) => R & NotThenable<R>): Result<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<unknown, E2>): Result<T, E | E2>;
+  /**
+   * Do-notation: run `f` for a `Result` and **bind its value** under `name` in
+   * an accumulating object scope.
+   *
+   * @remarks
+   * Begin a chain with {@link Do} (an empty object scope) and grow it step by
+   * step. `f` receives the scope accumulated so far and returns a `Result`; on
+   * `Ok` the value is added as `{ ...scope, [name]: value }`, on `Err`/`Defect`
+   * the chain short-circuits. Errors union (`E | E2`). A throw becomes a
+   * `Defect` — as does calling `bind` on a non-object or non-plain scope (e.g.
+   * `Ok(5).bind`, or a class instance whose getters the merge would drop), which
+   * is misuse: the scope is always a plain object inside a real `Do()` chain.
+   * (`let` is the pure-value counterpart.)
+   *
+   * @typeParam K - the key the bound value is stored under.
+   * @typeParam U - the bound value type.
+   * @typeParam E2 - the error type `f` may introduce.
+   * @param name - the scope key.
+   * @param f - produces a `Result` from the accumulated scope.
+   */
+  bind<K extends string, U, E2>(name: K, f: (scope: T) => Result<U, E2>): Result<Bound<T, K, U>, E | E2>;
+  /**
+   * Do-notation: run `f` for a **plain value** and bind it under `name` in the
+   * accumulating object scope. The pure-value counterpart of {@link ResultMethods.bind | bind}.
+   *
+   * @remarks
+   * `f` receives the scope and returns a value (not a `Result`); it is added as
+   * `{ ...scope, [name]: value }`. Runs only on `Ok`; `Err`/`Defect` pass
+   * through. A throw becomes a `Defect`. An async callback is rejected at
+   * compile time ({@link NotThenable}).
+   *
+   * @typeParam K - the key the value is stored under.
+   * @typeParam U - the value type.
+   * @param name - the scope key.
+   * @param f - computes a value from the accumulated scope.
+   */
+  let<K extends string, U>(name: K, f: (scope: T) => U & NotThenable<U>): Result<Bound<T, K, U>, E>;
+  /**
+   * Replace the success value with a constant `value`.
+   *
+   * Runs only on `Ok`; `Err` and `Defect` pass through.
+   *
+   * @typeParam U - the replacement value type.
+   */
+  as<U>(value: U): Result<U, E>;
+  /**
+   * Drop the success value, collapsing the success type to `void`.
+   *
+   * The named form of `map(() => undefined)`. Runs only on `Ok` (the value is
+   * replaced with `undefined`); `Err` and `Defect` pass through. Unlike
+   * `as(undefined)` — which produces `Result<undefined, E>` — the success type
+   * is `void`: the value's story ends here.
+   */
+  discard(): Result<void, E>;
+  /**
+   * Validate the success value — keep the `Ok` when `predicate` holds,
+   * otherwise fail into the **modeled** channel with `Err(onFail(value))`.
+   *
+   * @remarks
+   * The named form of `flatMap((v) => (p(v) ? Ok(v) : Err(e)))`. With a
+   * **type-guard** predicate (`(v): v is U`) the success type is **refined** to
+   * `U` on the way through (this overload). Runs only on `Ok` — a passing value
+   * flows through as the *same* `Ok`; `Err` and `Defect` pass through
+   * untouched. A throw in `predicate` or `onFail` becomes a `Defect`.
+   *
+   * Both callbacks are synchronous: an async `onFail` is rejected at compile
+   * time ({@link NotThenable}), and an async predicate does not type-check
+   * either — its `Promise<boolean>` is not a `boolean` (and, being truthy,
+   * would have silently always passed).
+   *
+   * @typeParam U - the refined success type (type-guard form).
+   * @typeParam E2 - the error type `onFail` produces.
+   * @param predicate - the check; a type guard refines `T` to `U`.
+   * @param onFail - maps the failing value to the modeled error.
+   *
+   * @example
+   * ```ts
+   * // boolean form: gate a value
+   * Ok(-1).ensure((n) => n > 0, (n) => `negative: ${n}`); // Err("negative: -1")
+   *
+   * // type-guard form: refine the success type
+   * declare const r: Result<string | number, "e">;
+   * const s = r.ensure(
+   *   (v): v is string => typeof v === "string",
+   *   () => "not_a_string" as const,
+   * ); // Result<string, "e" | "not_a_string">
+   * ```
+   */
+  ensure<U extends T, E2>(predicate: (value: T) => value is U, onFail: (value: T) => E2 & NotThenable<E2>): Result<U, E | E2>;
+  /**
+   * Boolean form of {@link ResultMethods.ensure | ensure} — validates without
+   * refining, keeping the success type `T`.
+   */
+  ensure<E2>(predicate: (value: T) => boolean, onFail: (value: T) => E2 & NotThenable<E2>): Result<T, E | E2>;
+  /**
+   * Transform the modeled error by **matching it exhaustively**.
+   *
+   * @remarks
+   * The callback receives `match(error)` (an {@link ErrMatcher}) and the
+   * injected `defect` helper. Chain `.with(pattern, handler)` and **return the
+   * un-terminated builder** — `mapErrCases` calls `.exhaustive()` itself, so a
+   * missing case is a compile error at the call site (there is no `.exhaustive()`
+   * to forget, and no way to slip in `.otherwise()`). The outgoing error type is
+   * the union of the branch returns with the `Defect` arm subtracted
+   * (`Exclude<O, Defect>`) — a branch returning `defect(cause)` converts that case
+   * to a `Defect` and drops it from `E`. Runs only on `Err`; `Ok` and `Defect`
+   * pass through. A branch that throws also becomes a `Defect`. Branches are
+   * **synchronous**: an `async` branch is a compile error (its `Promise` would
+   * land in `E` un-triaged), and a thenable slipped past the types becomes a
+   * `Defect`.
+   *
+   * **Name every case.** Match on anything the matcher supports — `_tag`,
+   * `code`, structural shape, guards — and group the cases that share a handler
+   * with `.with(a, b, handler)`. `.with(P._, …)` is the wildcard **escape
+   * hatch**, not the default: it makes any match exhaustive, so it also absorbs
+   * every case `E` grows later. Two uses are sanctioned — a helper generic in
+   * `E`, where no arm list can prove exhaustiveness against an unresolved type
+   * parameter, and an `E` that is a single type rather than a union of cases
+   * (see {@link P} for both). `@unthrown/oxlint`'s `no-catch-all-pattern` (in
+   * its `recommended` preset) flags the rest.
+   *
+   * @typeParam M - the exhaustive builder the callback returns.
+   * @param f - builds the match over the error (returns the un-terminated builder).
+   * @param _asyncBranchBanned_liftWithFromPromiseThenFlatMapErrCases - compile-time
+   * only; never pass it. Empty for synchronous branches; an **async** branch
+   * demands this impossible argument, so the call fails to compile (its name is
+   * the fix).
+   */
+  mapErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M, ..._asyncBranchBanned_liftWithFromPromiseThenFlatMapErrCases: SyncBranches<MatchOut<M>, E>): Result<T, MatchErrOut<M>>;
+  /**
+   * Sequence from an `Err` by producing another `Result` — the error-channel
+   * mirror of {@link ResultMethods.flatMap | flatMap}, **matching the error
+   * exhaustively** ({@link ErrMatcher}; the combinator calls `.exhaustive()`).
+   *
+   * Each branch returns a `Result`; the outgoing channels are the unions of the
+   * branch-returned `Result`s' channels. A branch may return `defect(cause)`.
+   * Runs only on `Err`; `Ok` and `Defect` pass through.
+   *
+   * @typeParam M - the exhaustive builder the callback returns.
+   * @param f - builds the match; each branch produces a fallback `Result`.
+   */
+  flatMapErrCases<M extends ExhaustiveMatch<Result<unknown, unknown> | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): Result<T | OkOf<MatchOut<M>>, ErrOf<MatchOut<M>>>;
+  /**
+   * Recover from an `Err` by producing a success value, emptying the error
+   * channel — **matching the error exhaustively** ({@link ErrMatcher}). Pairs
+   * with {@link ResultMethods.recoverDefect | recoverDefect}.
+   *
+   * @remarks
+   * The result type is `Result<T | U, never>`, but `never` describes only the
+   * **error** channel — a `Defect` can still be present at runtime. A branch may
+   * return `defect(cause)` (which stays a `Defect`, not a recovery). Runs only on
+   * `Err`; `Ok` and `Defect` pass through. Branches are **synchronous**: an
+   * `async` branch is a compile error, and a thenable slipped past the types
+   * becomes a `Defect`.
+   *
+   * @typeParam M - the exhaustive builder the callback returns.
+   * @param f - builds the match; each branch produces a success value.
+   * @param _asyncBranchBanned_liftWithFromPromiseThenFlatMapErrCases - compile-time
+   * only; never pass it. Empty for synchronous branches; an **async** branch
+   * demands this impossible argument, so the call fails to compile (its name is
+   * the fix).
+   */
+  recoverErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M, ..._asyncBranchBanned_liftWithFromPromiseThenFlatMapErrCases: SyncBranches<MatchOut<M>, T | E>): Result<T | MatchErrOut<M>, never>;
+  /**
+   * Run a side effect on the error — **matched exhaustively** ({@link ErrMatcher})
+   * — and pass the `Result` through unchanged.
+   *
+   * @remarks
+   * The callback builds a match whose branches run side effects; their return
+   * values are ignored and the original `Err` flows through. Exhaustive like the
+   * transformers, and like them it wants every case named — `.with(P._, …)`
+   * remains the wildcard escape hatch. If a branch throws, the
+   * result is a `Defect` whose cause is an `AggregateError` of `[thrown, original
+   * failure]` — observing a failure never destroys it. An **async branch is
+   * rejected at compile time** ({@link NotThenable} on the builder output):
+   * because the branch results are discarded, a returned `Promise` would float
+   * unobserved and its rejection would vanish. The one branch return that is
+   * **not** discarded is the injected `defect(cause)` marker: it is the
+   * lint-clean, expression-position form of a `throw`, so it follows the throw
+   * rule above (an `AggregateError` of `[the branch's cause, original
+   * failure]`), never a silent no-op. A failable
+   * `Result`-returning effect belongs in
+   * {@link ResultMethods.flatTapErrCases | flatTapErrCases}.
+   *
+   * @param f - builds the match; branch returns are ignored, bar `defect(cause)`.
+   */
+  tapErrCases<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): Result<T, E>;
+  /**
+   * Run a **failable** side effect on the error, keeping the original error but
+   * threading the effect's own error — **matched exhaustively**
+   * ({@link ErrMatcher}).
+   *
+   * @remarks
+   * The error-channel mirror of {@link ResultMethods.flatTap | flatTap}: each
+   * branch returns a `Result` whose **success value is discarded** — on the
+   * effect's `Ok` the original `Err` flows through, while an `Err`/`Defect` from a
+   * branch short-circuits and threads its error. Note the asymmetry with a
+   * *throw*: a branch that **returns** a Defect-state `Result` **replaces** the
+   * original `Err` (Defect-dominance, the short-circuit rule — it is not
+   * aggregated), whereas a branch that **throws** produces a `Defect`
+   * aggregating `[thrown, original failure]` (observing a failure by throwing
+   * never destroys it). A branch returning the injected `defect(cause)` marker —
+   * reachable under a `returnType` pin — follows the *throw* rule, since it is
+   * the lint-clean, expression-position form of one.
+   *
+   * @typeParam M - the exhaustive builder the callback returns.
+   * @param f - builds the match; each branch is a failable effect (its `Ok` is ignored).
+   */
+  flatTapErrCases<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result<unknown, E2>>): Result<T, E | E2>;
+  /**
+   * Recover from a `Defect` — the **only** combinator that can touch one.
+   *
+   * @remarks
+   * Runs `f` only when a `Defect` is present, re-entering the modeled world by
+   * returning a `Result` (an `Ok` or a fresh `Err`). `Ok` and `Err` pass
+   * through. Recovering a Defect should be rare: usually you let it bubble to
+   * the edge. If `f` throws, the throw becomes a new `Defect`.
+   *
+   * @typeParam U - a success type the recovery may produce.
+   * @typeParam E2 - an error type the recovery may produce.
+   * @param f - maps the Defect's unknown cause to a recovering `Result`.
+   */
+  recoverDefect<U, E2>(f: (cause: unknown) => Result<U, E2>): Result<T | U, E | E2>;
+  /**
+   * Run a side effect on a present `Defect`'s cause (e.g. logging) and pass the
+   * `Defect` through unchanged. If `f` throws, the result is a `Defect` whose
+   * cause is an `AggregateError` of `[thrown, original failure]` — observing a
+   * failure never destroys it. An async callback is rejected at compile time
+   * ({@link NotThenable}).
+   *
+   * @param f - the side effect over the unknown cause.
+   */
+  tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): Result<T, E>;
+  /**
+   * Run a side effect on **any failure** — `Err` or `Defect` — and pass the
+   * `Result` through unchanged. The one cross-channel observer, for the shared
+   * "it went KO" concern (logging, metrics, rollback) that would otherwise be
+   * duplicated across {@link ResultMethods.tapErrCases | tapErrCases} and
+   * {@link ResultMethods.tapDefect | tapDefect}.
+   *
+   * @remarks
+   * `f` receives the narrowed **failure variant** ({@link FailureView}), not a
+   * payload — the payload union `E | unknown` would collapse to `unknown` and
+   * lose `E`'s typing. Branch on `failure.tag` to reach the typed payload
+   * (`"Err"` → `failure.error: E`, `"Defect"` → `failure.cause: unknown`), or
+   * treat it opaquely for a shared logger. Runs on `Err` and `Defect`; `Ok`
+   * passes through. It **observes without consuming**: the failure flows on
+   * unchanged — to also recover, use
+   * {@link ResultMethods.recoverErrCases | recoverErrCases} /
+   * {@link ResultMethods.recoverDefect | recoverDefect} (deliberately separate
+   * acts) or {@link ResultMethods.match | match} at the edge. If `f` throws, the
+   * result is a `Defect` whose cause is an `AggregateError` of `[thrown,
+   * original failure]` — observing a failure never destroys it. An async
+   * callback is rejected at compile time ({@link NotThenable}).
+   *
+   * @param f - the side effect over the failure variant (its return value is ignored).
+   */
+  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): Result<T, E>;
+  /**
+   * Exhaustively fold all three runtime states into a single value.
+   *
+   * @remarks
+   * Exactly one handler runs. Together with the throw-to-Defect guarantee, this
+   * is typically the single place a pipeline is handled at the edge — mapping
+   * `Ok`/`Err`/`Defect` to (for example) 2xx / 4xx / 5xx with no `try`/`catch`.
+   *
+   * The `errCases` handler does not take a single blanket callback: it receives
+   * `match(error)` (an {@link ErrMatcher}) and **matches the error exhaustively**,
+   * exactly like the error combinators — which is why the key carries the same
+   * `…Cases` suffix. Chain `.with(pattern, handler)` and **return the
+   * un-terminated builder** — `match` calls `.exhaustive()` itself, so a missing
+   * case is a compile error at the call site (no `.exhaustive()` to forget).
+   * Folding at the edge names every case too — `.with(P._, …)` is the wildcard
+   * escape hatch, not the default. Unlike the combinators the branches
+   * receive **no `defect` helper** — `match` is total elimination to a value,
+   * with no `Defect` output channel; the `defect` case handles a `Result` that
+   * already carries one. (A `Result` is also a discriminated union — for richer
+   * whole-`Result` matching, `match(result).with(…)`.)
+   *
+   * @typeParam ROk - the `ok` handler return type.
+   * @typeParam RDefect - the `defect` handler return type.
+   * @typeParam M - the exhaustive builder the `errCases` handler returns.
+   * @param cases - the `ok`/`defect` handlers plus the `errCases` matcher builder.
+   */
+  match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {
+    ok: (value: T) => ROk;
+    errCases: (matcher: ErrMatcher<E>) => M;
+    defect: (cause: unknown) => RDefect;
+  }): ROk | RDefect | MatchOut<M>;
+  /**
+   * Extract the success value.
+   *
+   * @remarks
+   * Compiles only when the error channel is empty (`E = never`) — eliminate
+   * modeled errors first (`match` / `recoverErrCases` / `flatMapErrCases`), or reach for the
+   * `getOr` / `getOrElse` / `getOrNull` / `getOrUndefined` family (which
+   * recover an `Err`). The gate is a `this` type that becomes an explanatory
+   * string when `E` is not `never`, so the compile error names the fix.
+   *
+   * `E = never` empties only the **modeled** error channel — a `Defect` can
+   * still be present, and `get()` **rethrows its original cause** (it
+   * _panics_); `Result<T, never>` does not mean `get()` cannot throw.
+   *
+   * @returns the `Ok` value.
+   */
+  get(this: [E] extends [never] ? Result<T, never> : "unthrown: get() needs an empty error channel (E = never) — handle the Err first with recoverErrCases / match / flatMapErrCases, or use getOr / getOrElse / getOrNull / getOrUndefined"): T;
   /**
-   * The offending value: the `Err` error for `get()`, or the `Ok` value for
-   * `getErr()`.
+   * Extract the modeled error.
+   *
+   * @remarks
+   * Compiles only when the success channel is empty (`T = never`) — eliminate
+   * the success case first. `T = never` is rarely the case in practice (a
+   * `Result` you hold usually still has a success type), so to inspect an
+   * error prefer an `isErr()` guard or, in tests, `@unthrown/vitest`'s
+   * `toBeErrWith`. A `Defect` still **rethrows its original cause** (a defect is
+   * a bug, not an absent value), so this does not mean `getErr()` can't throw.
+   *
+   * @returns the `Err` value.
    */
-  readonly error: E;
-  constructor(error: E);
-}
-/**
- * Type guard: is `x` a {@link Result} (any of `Ok` / `Err` / `Defect`)?
- *
- * @remarks
- * Unlike {@link isOk} / {@link isErr} / {@link isDefect}, which narrow a value
- * already known to be a `Result`, this narrows from `unknown` — useful at an
- * untyped boundary. It checks the value carries the `Result` prototype
- * (`instanceof` first, falling back to the `Symbol.for("unthrown.Result")`
- * 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`.
- *
- * @returns `true` when `x` is a `Result` produced by this library.
- *
- * @example
- * ```ts
- * import { isResult, Ok, P } from "unthrown";
- *
- * isResult(Ok(1)); // => true
- * isResult({ tag: "Ok" }); // => false (look-alike, wrong prototype)
- * isResult(Ok(1).toAsync()); // => false (an AsyncResult is not a Result)
- *
- * const x: unknown = Ok(1);
- * if (isResult(x))
- *   // `E` is `unknown` here — an untyped boundary has no cases to enumerate,
- *   // so the `P._` escape hatch is the only arm that can terminate the match:
- *   // oxlint-disable-next-line unthrown/no-catch-all-pattern -- untyped boundary: `E` is `unknown`
- *   x.match({
- *     ok: () => 1,
- *     errCases: (m) => m.with(P._, () => 0),
- *     defect: () => -1,
- *   });
- * ```
- *
- * @category Guards
- */
-declare function isResult(x: unknown): x is Result$1<unknown, unknown>;
-//#endregion
-//#region src/do.d.ts
+  getErr(this: [T] extends [never] ? Result<never, E> : "unthrown: getErr() needs an empty success channel (T = never) — narrow with isErr() first, or fold with match"): E;
+  /**
+   * The success value, or `fallback` on `Err`.
+   *
+   * @typeParam U - the fallback type (may differ from `T`; the return widens to `T | U`).
+   * @param fallback - returned when the result is an `Err` (may be a different type; the return widens to `T | U`).
+   * @throws Re-throws on a `Defect` — a Defect is a bug, not an absent value, so
+   * it is never silently replaced.
+   */
+  getOr<U>(fallback: U): T | U;
+  /**
+   * The success value, or `f(error)` on `Err`.
+   *
+   * @typeParam U - the fallback type (may differ from `T`; the return widens to `T | U`).
+   * @param f - lazily computes the fallback from the error (may return a different type; the return widens to `T | U`).
+   * @throws Re-throws on a `Defect`.
+   */
+  getOrElse<U>(f: (error: E) => U): T | U;
+  /**
+   * The success value, or `null` on `Err`.
+   *
+   * @throws Re-throws on a `Defect`.
+   */
+  getOrNull(): T | null;
+  /**
+   * The success value, or `undefined` on `Err`.
+   *
+   * @throws Re-throws on a `Defect`.
+   */
+  getOrUndefined(): T | undefined;
+  /**
+   * The success value, or **throw** the modeled error on `Err`.
+   *
+   * @remarks
+   * A deliberate escape hatch off the errors-as-values model — it **throws the
+   * `Err` value as-is** at the call site, so a caller of the enclosing function
+   * sees a throw rather than a channel. Its home is **tests and scripts**,
+   * where "this `Result` had better be `Ok`" is the assertion and a throw is
+   * the correct failure mode.
+   *
+   * In production code, fold the error channel instead:
+   * {@link ResultMethods.recoverErrCases | recoverErrCases} empties `E`, so
+   * {@link ResultMethods.get | get} compiles and a case routed to the injected
+   * `defect(...)` panics with its original cause — with every case still named.
+   * {@link ResultMethods.match | match} and
+   * {@link ResultMethods.flatMapErrCases | flatMapErrCases} are the other two
+   * ways to keep the error a value. `@unthrown/oxlint`'s opt-in
+   * `no-get-or-throw` rule enforces this, exempting test files through an
+   * oxlint `overrides` entry.
+   *
+   * Type-gated as the **complement** of {@link ResultMethods.get | get}: it
+   * compiles only when the error channel is **non-empty** (`E` is not `never`) —
+   * there must be a modeled error for it to throw. On a `Result<T, never>` there
+   * is nothing to throw, so `getOrThrow` does not compile; use `get()` (which
+   * gates the other way). Together they partition extraction by the error
+   * channel's state, with no overlap.
+   *
+   * @returns the `Ok` value.
+   * @throws the modeled `error` on `Err`; re-throws the original `cause` on a
+   * `Defect` (a panic, like the rest of the `getOr…` family).
+   */
+  getOrThrow(this: [E] extends [never] ? "unthrown: getOrThrow is unnecessary here — the Err channel is empty (E = never), so there is nothing to throw. Use get() instead." : Result<T, E>): T;
+  /** 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>;
+};
 /**
- * Start a do-notation chain with an empty object scope, grown step by step with
- * `bind` (for `Result`-returning steps) and `let` (for pure values).
- *
- * @remarks
- * Capitalised because `do` is a reserved word. Each step receives the scope
- * accumulated so far; the error types union across `bind`s, and a throw in any
- * step becomes a `Defect`. To go asynchronous, lift the chain with `toAsync()`
- * (then a `bind` may return an `AsyncResult`).
- *
- * @example
- * ```ts
- * import { Do, Ok } from "unthrown";
- *
- * const result = Do()
- *   .bind("user", () => findUser(id)) // Result<User, NotFound>
- *   .bind("org", ({ user }) => findOrg(user.orgId)) // Result<Org, NotFound>
- *   .let("label", ({ user, org }) => `${user.name} @ ${org.name}`)
- *   .map(({ user, org, label }) => render(user, org, label));
- * // Result<View, NotFound>
- * ```
+ * The `Ok` variant of a {@link Result}: a success carrying a `value`. This is
+ * what a successful `isOk` guard narrows to, making `.value` reachable. It also
+ * carries the shared fluent surface ({@link ResultMethods}).
  *
  * @example
  * ```ts
- * import { Do, Ok, Err } from "unthrown";
- *
- * // Ok path — the scope accumulates:
- * Do()
- *   .bind("a", () => Ok(2))
- *   .let("b", ({ a }) => a * 10)
- *   .map(({ a, b }) => a + b); // => Ok(22)
- *
- * // Err path — the first Err short-circuits the rest:
- * Do()
- *   .bind("a", () => Err("boom"))
- *   .let("b", ({ a }) => a); // => Err("boom")
+ * if (r.isOk()) r.value; // r: OkView<T, E> here — .value is a T
  * ```
  *
- * @category Do-notation
+ * @category Types
  */
-declare function Do(): Result$1<{}, never>;
+interface OkView<out T, out E = never> extends ResultMethods<T, E> {
+  readonly tag: "Ok";
+  readonly value: T;
+}
 /**
- * Start an **asynchronous** do-notation chain with an empty object scope — the
- * pre-lifted form of {@link Do}, sparing you `Do().toAsync()`.
+ * The `Err` variant of a {@link Result}: a modeled failure carrying an `error`.
+ * This is what a successful `isErr` guard narrows to, exposing `.error`. It also
+ * carries the shared fluent surface ({@link ResultMethods}).
  *
  * @remarks
- * From here a `bind` may return a `Result` **or** an `AsyncResult`; the scope
- * accumulates exactly as in a sync {@link Do} chain, and a throw in any step
- * becomes a `Defect`. Named with the `Async` suffix the async free functions
- * carry (`OkAsync`, `allAsync`); the {@link AsyncResult} companion aliases it as
- * `AsyncResult.Do` (the namespace already says "async", so the suffix drops).
+ * **Note the parameter order: `ErrView<E, T>` puts the error type _first_** — the
+ * reverse of the `<T, E>` order used by {@link OkView}, {@link DefectView}, and
+ * {@link Result} — because `Result<T, E>` narrows to `ErrView<E, T>` (the error is
+ * the payload the guard makes reachable). You rarely write it by hand (a failed
+ * `isErr()` narrows to it for you); if you do, mind the flip — `ErrView<MyError,
+ * MyValue>`, not `ErrView<MyValue, MyError>`.
  *
  * @example
  * ```ts
- * import { DoAsync, Ok } from "unthrown";
- *
- * const result = await DoAsync()
- *   .bind("user", () => findUser(id)) // AsyncResult<User, NotFound>
- *   .bind("plan", ({ user }) => Ok(user.plan)) // a sync Result is accepted too
- *   .let("label", ({ user, plan }) => `${user.name} on ${plan}`);
- * // Result<{ user: User; plan: Plan; label: string }, NotFound>
+ * if (r.isErr()) r.error; // r: ErrView<E, T> here — .error is an E
  * ```
  *
- * @category Do-notation
- */
-declare function DoAsync(): AsyncResult$1<{}, never>;
-//#endregion
-//#region src/interop.d.ts
-/**
- * Bridge a nullable value into a {@link Result}: absence becomes a **modeled**
- * `Err`. The sanctioned alternative to an `Option` type.
- *
- * @remarks
- * `null` and `undefined` map to `Err(onAbsent())`; any other value (including
- * falsy ones like `0`, `""`, `false`) maps to `Ok`.
- *
- * @typeParam T - the (nullable) value type.
- * @typeParam E - the error produced when the value is absent.
- * @param value - the possibly-absent value.
- * @param onAbsent - lazily produces the error for the absent case.
- *
- * @category Interop
- *
- * @example
- * ```ts
- * import { fromNullable } from "unthrown";
- *
- * const map = new Map([["a", 1]]);
- * fromNullable(map.get("a"), () => "absent").getOr(0); // => 1
- * fromNullable(map.get("z"), () => "absent"); // => Err("absent")
- * fromNullable(0, () => "absent").getOr(-1); // => 0 (falsy but present)
- * ```
+ * @category Types
  */
-declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () => E): Result$1<NonNullable<T>, E>;
-/**
- * Wrap a throwing synchronous function so it returns a {@link Result} instead of
- * throwing.
- *
- * @remarks
- * `qualify` **must** triage every thrown cause into a modeled error `E` or a
- * `Defect` (via the injected `defect` helper, its second argument) — there is no
- * path that leaves `unknown` in `E`. A throw inside `qualify` itself is treated
- * as a `Defect`. `qualify` is **synchronous**: an `async` qualify is rejected at
- * compile time ({@link NotThenable}) — its `Promise` would land in `E` un-triaged
- * — and a thenable slipped past the types at runtime becomes a `Defect` (never
- * an `Err(Promise)`), its orphaned rejection silenced.
- *
- * `fn` is **synchronous** too. An `async` `fn` rejects *after* this boundary has
- * already returned, so its rejection could never reach `qualify`: it becomes a
- * `Defect` (never `Ok(<Promise>)`) and the orphaned rejection is silenced rather
- * than left to float. Reach for {@link fromPromise} to wrap async work.
- *
- * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
- * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
- * `qualify` that returns *only* `defect(cause)` yields `E = never` (a Defect is
- * out-of-band and must not pollute the error channel); reach for
- * {@link fromSafeThrowable} when every throw is a Defect.
- *
- * @typeParam A - the wrapped function's argument tuple.
- * @typeParam T - the wrapped function's return 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 a modeled `E`, or marks it
- * unmodeled by returning `defect(cause)` (the helper passed as its second arg).
- * @returns a function with the same arguments returning `Result<T, E>`.
- *
- * @category Interop
+interface ErrView<out E, out T = never> extends ResultMethods<T, E> {
+  readonly tag: "Err";
+  readonly error: E;
+}
+/**
+ * The `Defect` variant of a {@link Result}: an unmodeled failure carrying a
+ * `cause`. This is what a successful `isDefect` guard narrows to, exposing
+ * `.cause`. It also carries the shared fluent surface ({@link ResultMethods}).
  *
  * @example
  * ```ts
- * import { fromThrowable } from "unthrown";
- *
- * // Model the parse failure as an `Err`, everything unexpected as a `Defect`.
- * const parse = fromThrowable(
- *   (text: string) => JSON.parse(text) as unknown,
- *   (cause, defect) =>
- *     cause instanceof SyntaxError ? ("invalid_json" as const) : defect(cause),
- * );
- *
- * parse('{"ok":true}').getOr(null); // => { ok: true }
- * parse("nope"); // => Err("invalid_json")
+ * if (r.isDefect()) r.cause; // r: DefectView<T, E> here — .cause is `unknown`
  * ```
+ *
+ * @category Types
  */
-declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T, qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R & NotThenable<R>): (...args: A) => Result$1<T, Exclude<R, Defect>>;
+interface DefectView<out T = never, out E = never> extends ResultMethods<T, E> {
+  readonly tag: "Defect";
+  readonly cause: unknown;
+}
 /**
- * Wrap a throwing synchronous function asserted **not** to fail in any modeled
- * way: any throw becomes a `Defect`.
+ * A failure variant of a {@link Result}: an {@link ErrView} **or** a
+ * {@link DefectView}. This is what a `tapFailure` callback receives — the
+ * discriminated variant rather than a payload, because the payload union
+ * `E | unknown` would collapse to `unknown` and lose `E`'s typing. Branch on
+ * `tag` to narrow (`"Err"` → `.error: E`, `"Defect"` → `.cause: unknown`).
  *
  * @remarks
- * The synchronous counterpart of {@link fromSafePromise}. Use it only when a
- * throw genuinely indicates a bug rather than an anticipated outcome — the
- * error channel is `never`, so there is nothing to triage; there is no
- * `qualify`. When some throws *are* anticipated, reach for
- * {@link fromThrowable} and triage them.
- *
- * `fn` is **synchronous**: an `async` `fn` becomes a `Defect` (never
- * `Ok(<Promise>)`), with its orphaned rejection silenced rather than left to
- * float. Reach for {@link fromSafePromise} to wrap async work.
- *
- * @typeParam A - the wrapped function's argument tuple.
- * @typeParam T - the wrapped function's return type.
- * @param fn - the throwing function to wrap.
- * @returns a function with the same arguments returning `Result<T, never>`.
- *
- * @category Interop
+ * Like {@link ErrView}, the error type comes **first** (`FailureView<E, T>`) —
+ * the error is the payload you are usually here for, and a shared observer can
+ * spell just `FailureView<MyError>`.
  *
  * @example
  * ```ts
- * import { fromSafeThrowable } from "unthrown";
- *
- * // A decode failure here is a bug (the row came from our own schema), so
- * // every throw is a defect — no throwaway `(cause, defect) => defect(cause)`.
- * const decode = fromSafeThrowable((row: Row) => userSchema.parse(row));
- *
- * decode(row); // => Result<User, never> — a throw becomes a Defect
+ * const logKo = (f: FailureView<ApiError>) =>
+ *   f.tag === "Err" ? logger.warn(f.error) : logger.error(f.cause);
+ * result.tapFailure(logKo);
  * ```
+ *
+ * @typeParam E - the modeled error type.
+ * @typeParam T - the success value type (phantom here; a failure carries none).
+ * @category Types
  */
-declare function fromSafeThrowable<A extends unknown[], T>(fn: (...args: A) => T): (...args: A) => Result$1<T, never>;
+type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
 /**
- * Wrap a `Promise` (or a thunk producing one) as an {@link AsyncResult}, forcing
- * every rejection to be triaged.
+ * A success-only thenable: awaitable, but deliberately **not** a full
+ * `PromiseLike`.
  *
  * @remarks
- * `qualify` **must** map each rejection cause into a modeled error `E` or a
- * `Defect` (via the injected `defect` helper, its second argument). The returned
- * `AsyncResult`'s internal promise never rejects; `await`-ing it always yields a
- * `Result`. A throw inside `qualify` is itself a `Defect`. `qualify` is
- * **synchronous**: an `async` qualify is rejected at compile time
- * ({@link NotThenable}), and a thenable slipped past the types at runtime
- * becomes a `Defect` (never an `Err(Promise)`), its orphaned rejection silenced.
- *
- * 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 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 a modeled `E`, or marks it
- * unmodeled by returning `defect(cause)` (the helper passed as its second arg).
- * @param _guard - compile-time only; never pass it. The phantom rest-tuple that
- * enforces "qualify is synchronous": an `async` qualify makes this demand an
- * impossible extra argument (whose type spells out the error), while a
- * synchronous one leaves it empty. Encoded here — not on `qualify`'s return
- * type — so `T`'s inference from `promise` is undisturbed.
+ * An {@link AsyncResult}'s internal promise never rejects, so `await`-ing one
+ * always yields a {@link Result} and never throws — there is no rejection
+ * channel to model, and none is advertised. At runtime it is still a thenable
+ * (the only way `await` can collapse it), and `Promise.all` / `Promise.resolve`
+ * will still adopt it — harmlessly, since it settles to a `Result` and never
+ * rejects. What the narrowing prevents is treating it as a full promise:
+ * `.catch()` / `.finally()` do not type-check, because there is no rejection to
+ * handle.
  *
- * @category Interop
+ * @typeParam T - the value `await` resolves to.
  *
- * @example
- * ```ts
- * import { fromPromise } from "unthrown";
+ * @category Types
+ */
+type Awaitable<out T> = {
+  then<R = T>(onfulfilled?: ((value: T) => R | PromiseLike<R>) | null): PromiseLike<R>;
+};
+/**
+ * The async method surface every {@link AsyncResult} carries — the combinators
+ * (`map`, `flatMap`, `mapErrCases`, `match`, `get`, …) with their asynchronous
+ * signatures, documented one per entry below. The async mirror of
+ * {@link ResultMethods}: each entry links its synchronous counterpart and states
+ * only the async delta.
  *
- * // A rejection with a NotFoundError becomes a modeled `Err`; anything else a Defect.
- * const user = await fromPromise(fetchUser(id), (cause, defect) =>
- *   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
- * );
+ * @remarks
+ * Like {@link ResultMethods}, this type exists to **document** the surface — not
+ * to be authored against; you obtain it by holding an `AsyncResult`. Its
+ * combinator callbacks are **synchronous** (a raw `Promise` may never enter — see
+ * the {@link AsyncResult} remarks); async work re-enters via {@link fromPromise}
+ * and composes with `flatMap`. Systematic differences from the sync surface: the
+ * binds return an `AsyncResult` (and additionally accept one), and the
+ * eliminators return a `Promise`.
  *
- * if (user.isOk()) user.value; // => the fetched user
- * // when fetchUser rejects with NotFoundError: user is Err("not_found")
- * ```
+ * @typeParam T - the success value type.
+ * @typeParam E - the modeled error type.
+ * @category Methods
  */
-declare function fromPromise<T, R>(promise: Promise<T> | (() => Promise<T>), qualify: (cause: unknown, defect: (cause: unknown) => Defect) => R, ..._guard: [Extract<R, PromiseLike<unknown>>] extends [never] ? [] : ["unthrown: qualify must be synchronous — its Promise would land in E un-triaged"]): AsyncResult$1<T, Exclude<R, Defect>>;
+type AsyncResultMethods<out T, out E> = {
+  /**
+   * Asynchronous {@link ResultMethods.map | map}: transforms the success value
+   * with `f`. `f` is synchronous; a throw becomes a `Defect`. An async callback
+   * is rejected at compile time ({@link NotThenable}).
+   */
+  map<U>(f: (value: T) => U & NotThenable<U>): AsyncResult<U, E>;
+  /**
+   * Asynchronous {@link ResultMethods.flatMap | flatMap}. Unlike the sync form,
+   * `f` may return a `Result` **or** an `AsyncResult` (never a raw `Promise`); a
+   * throw becomes a `Defect`.
+   *
+   * @remarks
+   * The async branch of `f`'s return type is spelled `Awaitable<Result<U, E2>> &
+   * { flatMap: unknown }` rather than `AsyncResult<U, E2>`: this is what you get
+   * by returning an `AsyncResult` (it satisfies both), but inference runs through
+   * the `Awaitable` then-channel so `U`/`E2` stay precise instead of collapsing
+   * to `unknown`, while the `{ flatMap: unknown }` marker still rejects a bare
+   * `Promise` (it has no `flatMap`). Just return a `Result` or an `AsyncResult`.
+   */
+  flatMap<U, E2>(f: (value: T) => Result<U, E2> | (Awaitable<Result<U, E2>> & ReturnAnAsyncResultNotAPromise)): AsyncResult<U, E | E2>;
+  /**
+   * Asynchronous {@link ResultMethods.tap | tap}. `f` is synchronous; a throw
+   * becomes a `Defect`. An async callback is rejected at compile time
+   * ({@link NotThenable}) — and so is a returned `AsyncResult` (it is
+   * awaitable). Beware the near-miss: _calling_ an `AsyncResult`-returning
+   * effect inside the callback without returning it compiles and leaves the
+   * effect floating — fire-and-forget, never awaited, its `Err`/`Defect`
+   * unobserved. If the effect returns a `Result`/`AsyncResult`, use
+   * {@link AsyncResultMethods.flatTap | flatTap}.
+   */
+  tap<R>(f: (value: T) => R & NotThenable<R>): AsyncResult<T, E>;
+  /**
+   * Asynchronous {@link ResultMethods.flatTap | 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<unknown, E2> | (Awaitable<Result<unknown, E2>> & ReturnAnAsyncResultNotAPromise)): AsyncResult<T, E | E2>;
+  /**
+   * Asynchronous {@link ResultMethods.bind | bind} (do-notation). `f` may return
+   * a `Result` **or** an `AsyncResult`; its value is bound under `name` in the
+   * accumulating scope.
+   */
+  bind<K extends string, U, E2>(name: K, f: (scope: T) => Result<U, E2> | (Awaitable<Result<U, E2>> & ReturnAnAsyncResultNotAPromise)): AsyncResult<Bound<T, K, U>, E | E2>;
+  /**
+   * Asynchronous {@link ResultMethods.let | let} (do-notation). `f` returns a
+   * plain value, bound under `name`. An async callback is rejected at compile
+   * time ({@link NotThenable}).
+   */
+  let<K extends string, U>(name: K, f: (scope: T) => U & NotThenable<U>): AsyncResult<Bound<T, K, U>, E>;
+  /** Asynchronous {@link ResultMethods.as | as}: replaces the value with `value`. */
+  as<U>(value: U): AsyncResult<U, E>;
+  /** Asynchronous {@link ResultMethods.discard | discard}: drops the value, collapsing the success type to `void`. */
+  discard(): AsyncResult<void, E>;
+  /**
+   * Asynchronous {@link ResultMethods.ensure | ensure}: validate the success
+   * value — and, with a type-guard predicate (this overload), **refine** it —
+   * failing into the modeled channel with `Err(onFail(value))`. Both callbacks
+   * are synchronous (an async `onFail` is rejected at compile time,
+   * {@link NotThenable}); a throw in either becomes a `Defect`.
+   */
+  ensure<U extends T, E2>(predicate: (value: T) => value is U, onFail: (value: T) => E2 & NotThenable<E2>): AsyncResult<U, E | E2>;
+  /** Boolean form of the asynchronous {@link ResultMethods.ensure | ensure} — validates without refining, keeping `T`. */
+  ensure<E2>(predicate: (value: T) => boolean, onFail: (value: T) => E2 & NotThenable<E2>): AsyncResult<T, E | E2>;
+  /**
+   * Asynchronous {@link ResultMethods.mapErrCases | mapErrCases} — the same exhaustive
+   * {@link ErrMatcher} form; the combinator calls `.exhaustive()`. Branches are
+   * synchronous — an `async` branch is a compile error, as on the sync surface.
+   */
+  mapErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M, ..._asyncBranchBanned_liftWithFromPromiseThenFlatMapErrCases: SyncBranches<MatchOut<M>, E>): AsyncResult<T, MatchErrOut<M>>;
+  /**
+   * Asynchronous {@link ResultMethods.flatMapErrCases | flatMapErrCases} — the same
+   * exhaustive {@link ErrMatcher} form. Unlike the sync form, a branch may
+   * return a `Result` **or** an `AsyncResult`.
+   */
+  flatMapErrCases<M extends ExhaustiveMatch<Result<unknown, unknown> | (Awaitable<Result<unknown, unknown>> & ReturnAnAsyncResultNotAPromise) | Defect>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M): AsyncResult<T | OkOf<MatchOut<M>> | AsyncOkOf<MatchOut<M>>, ErrOf<MatchOut<M>> | AsyncErrOf<MatchOut<M>>>;
+  /**
+   * Asynchronous {@link ResultMethods.recoverErrCases | recoverErrCases} — the same
+   * exhaustive {@link ErrMatcher} form. Branches are synchronous; a throw
+   * becomes a `Defect`.
+   */
+  recoverErrCases<M extends ExhaustiveMatch<unknown>>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => M, ..._asyncBranchBanned_liftWithFromPromiseThenFlatMapErrCases: SyncBranches<MatchOut<M>, T | E>): AsyncResult<T | MatchErrOut<M>, never>;
+  /**
+   * Asynchronous {@link ResultMethods.tapErrCases | tapErrCases}. `f` is synchronous; if it
+   * throws — or a branch returns the injected `defect(cause)` marker, the
+   * expression-position form of a throw — the result is a `Defect` whose cause
+   * is an `AggregateError` of `[thrown, original failure]` — observing a failure
+   * never destroys it. An
+   * async branch is rejected at compile time ({@link NotThenable} on the
+   * builder output) — other branch results are discarded, so a rejected
+   * `Promise` would float unobserved. The
+   * {@link AsyncResultMethods.tap | tap} fire-and-forget caveat applies here
+   * too — a failable effect belongs in
+   * {@link AsyncResultMethods.flatTapErrCases | flatTapErrCases}.
+   */
+  tapErrCases<R>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<R & NotThenable<R>>): AsyncResult<T, E>;
+  /**
+   * Asynchronous {@link ResultMethods.flatTapErrCases | flatTapErrCases} — the
+   * error-channel mirror of `flatTap`. `f` may return a `Result` **or** an
+   * `AsyncResult`; its `Ok` value is discarded, an `Err`/`Defect` from `f`
+   * threads through, and if `f` throws — or a branch returns the injected
+   * `defect(cause)` marker, the expression-position form of a throw — the result
+   * is a `Defect` whose cause is an `AggregateError` of `[thrown, original
+   * failure]` — observing a failure never destroys it.
+   */
+  flatTapErrCases<E2>(f: (matcher: ErrMatcher<E>, defect: (cause: unknown) => Defect) => ExhaustiveMatch<Result<unknown, E2> | (Awaitable<Result<unknown, E2>> & ReturnAnAsyncResultNotAPromise)>): AsyncResult<T, E | E2>;
+  /**
+   * Asynchronous {@link ResultMethods.recoverDefect | recoverDefect}. `f` may
+   * return a `Result` or an `AsyncResult`.
+   */
+  recoverDefect<U, E2>(f: (cause: unknown) => Result<U, E2> | AsyncResult<U, E2>): AsyncResult<T | U, E | E2>;
+  /**
+   * Asynchronous {@link ResultMethods.tapDefect | tapDefect}. If `f` throws, the
+   * result is a `Defect` whose cause is an `AggregateError` of `[thrown,
+   * original failure]` — observing a failure never destroys it. An async
+   * callback is rejected at compile time ({@link NotThenable}).
+   */
+  tapDefect<R>(f: (cause: unknown) => R & NotThenable<R>): AsyncResult<T, E>;
+  /**
+   * Asynchronous {@link ResultMethods.tapFailure | tapFailure} — the
+   * cross-channel observer. `f` receives the narrowed failure variant
+   * ({@link FailureView}); if it throws, the result is a `Defect` whose cause
+   * is an `AggregateError` of `[thrown, original failure]` — observing a
+   * failure never destroys it. An async callback is rejected at compile time
+   * ({@link NotThenable}).
+   */
+  tapFailure<R>(f: (failure: FailureView<E, T>) => R & NotThenable<R>): AsyncResult<T, E>;
+  /**
+   * Asynchronous {@link ResultMethods.match | match}. Handlers are synchronous
+   * (the `errCases` handler returns an exhaustive {@link ErrMatcher} builder, no
+   * `defect` helper); resolves to a `Promise` of the folded value.
+   */
+  match<ROk, RDefect, M extends ExhaustiveMatch<unknown>>(cases: {
+    ok: (value: T) => ROk;
+    errCases: (matcher: ErrMatcher<E>) => M;
+    defect: (cause: unknown) => RDefect;
+  }): Promise<ROk | RDefect | MatchOut<M>>;
+  /**
+   * Asynchronous {@link ResultMethods.get | get}. Compiles only when the
+   * error channel is empty (`this: AsyncResult<T, never>`); the returned promise
+   * rejects on a `Defect` (rethrowing its cause).
+   */
+  get(this: [E] extends [never] ? AsyncResult<T, never> : "unthrown: get() needs an empty error channel (E = never) — handle the Err first with recoverErrCases / match / flatMapErrCases, or use getOr / getOrElse / getOrNull / getOrUndefined"): Promise<T>;
+  /**
+   * Asynchronous {@link ResultMethods.getErr | getErr}. Compiles only when
+   * the success channel is empty (`this: AsyncResult<never, E>`); the returned
+   * promise rejects on a `Defect` (rethrowing its cause).
+   */
+  getErr(this: [T] extends [never] ? AsyncResult<never, E> : "unthrown: getErr() needs an empty success channel (T = never) — narrow with isErr() first, or fold with match"): Promise<E>;
+  /** Asynchronous {@link ResultMethods.getOr | getOr}. */
+  getOr<U>(fallback: U): Promise<T | U>;
+  /** Asynchronous {@link ResultMethods.getOrElse | getOrElse}. */
+  getOrElse<U>(f: (error: E) => U): Promise<T | U>;
+  /** Asynchronous {@link ResultMethods.getOrNull | getOrNull}. */
+  getOrNull(): Promise<T | null>;
+  /** Asynchronous {@link ResultMethods.getOrUndefined | getOrUndefined}. */
+  getOrUndefined(): Promise<T | undefined>;
+  /**
+   * Asynchronous {@link ResultMethods.getOrThrow | getOrThrow} — the returned
+   * promise **rejects** with the modeled error on `Err` (or the original cause
+   * on a `Defect`), rather than throwing synchronously. Gated the same way: it
+   * compiles only when the error channel is non-empty (`E` is not `never`).
+   */
+  getOrThrow(this: [E] extends [never] ? "unthrown: getOrThrow is unnecessary here — the Err channel is empty (E = never), so there is nothing to throw. Use get() instead." : AsyncResult<T, E>): Promise<T>;
+};
 /**
- * Wrap a `Promise` asserted **not** to fail in any modeled way: any rejection
- * becomes a `Defect`.
- *
- * @remarks
- * Use this only when a rejection genuinely indicates a bug rather than an
- * anticipated outcome — the error channel is `never`, so there is nothing to
- * triage. (`await`-ing still yields a `Result`; it never throws.) The
- * synchronous counterpart is {@link fromSafeThrowable}.
- *
- * @typeParam T - the resolved value type.
- * @param promise - the promise, or a thunk returning one.
+ * Extract the success type `T` from a `Result` type — derive one type from
+ * another instead of restating it (e.g. the payload a function returns).
  *
- * @category Interop
+ * @typeParam R - the `Result` type to inspect.
  *
  * @example
  * ```ts
- * import { fromSafePromise } from "unthrown";
- *
- * (await fromSafePromise(Promise.resolve(3))).get(); // => 3
- * // a rejection becomes a Defect (never a modeled Err):
- * await fromSafePromise(Promise.reject(new Error("boom"))); // => Defect(Error("boom"))
+ * type R = Result<User, NotFound>;
+ * type U = OkOf<R>; // User
+ * type E = ErrOf<R>; // NotFound
  * ```
- */
-declare function fromSafePromise<T>(promise: Promise<T> | (() => Promise<T>)): AsyncResult$1<T, never>;
-/**
- * The settler a {@link fromExecutor} executor receives. Settles the pending
- * `AsyncResult` **once** — later calls are no-ops, exactly as `resolve` is on a
- * `Promise`.
- *
- * @typeParam T - the success type.
- * @typeParam E - the modeled error type.
  *
  * @category Types
  */
-type Settle<T, E> = (result: Result$1<T, E> | Defect) => void;
+type OkOf<R> = R extends {
+  readonly tag: "Ok";
+  readonly value: infer T;
+} ? T : never;
 /**
- * Build an {@link AsyncResult} from a callback-style API — this library's
- * answer to `new Promise((resolve, reject) => …)`.
- *
- * @remarks
- * The settler takes a **`Result`**, not a value-or-reason pair: the caller names
- * the variant, so no `unknown` can enter `E` and there is no `qualify` to pass.
- * For a failure that is *not* modeled, settle the injected `defect` helper's
- * marker — the same injection `qualify` receives, and the only way to reach the
- * defect channel from inside an asynchronous callback (a `throw` there runs in
- * its own turn, long after the executor body returned).
- *
- * `T` and `E` cannot be inferred from the body, since `settle` is a parameter.
- * Supply them explicitly, or let them flow from an annotated target. Absent
- * either, both default to `never` (Thesis #3: no path may produce `unknown` in
- * `E`) — so an unannotated call is a compile error at the `settle(...)` call
- * site, not a silently-`unknown` channel.
- *
- * An executor that never settles yields an `AsyncResult` that never resolves —
- * the one hazard {@link fromPromise} does not have, and identical to
- * `new Promise`.
- *
- * @typeParam T - the success type.
- * @typeParam E - the modeled error type.
- * @param executor - runs immediately; receives the settler and the `defect` helper.
+ * Extract the error type `E` from a `Result` type — the counterpart of
+ * {@link OkOf}.
  *
- * @category Interop
+ * @typeParam R - the `Result` type to inspect.
  *
  * @example
  * ```ts
- * import { fromExecutor, Err, Ok } from "unthrown";
- *
- * const listen = (port: number) =>
- *   fromExecutor<Server, PortInUse>((settle, defect) => {
- *     server.once("error", (cause) =>
- *       isAddrInUse(cause) ? settle(Err(new PortInUse(port))) : settle(defect(cause)),
- *     );
- *     server.listen(port, () => settle(Ok(server)));
- *   });
+ * type E = ErrOf<Result<User, NotFound>>; // NotFound
  * ```
- */
-declare function fromExecutor<T = never, E = never>(executor: (settle: Settle<T, E>, defect: (cause: unknown) => Defect) => void): AsyncResult$1<T, E>;
-/**
- * The success channel of {@link all} / {@link allAsync}: a **positional tuple**
- * for a fixed-length input (including the empty tuple), or a homogeneous
- * **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 `[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
+ * @category Types
  */
-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}. */
-type AsyncResultRecord = Record<string, AsyncResult$1<unknown, unknown>>;
+type ErrOf<R> = R extends {
+  readonly tag: "Err";
+  readonly error: infer E;
+} ? E : never;
 /**
- * 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`. 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}. To report **every** `Err` instead of only the first,
- * use {@link validateAll}.
+ * Extract the success type `T` from an {@link AsyncResult} type — the async
+ * counterpart of {@link OkOf}.
  *
- * @category Aggregate
+ * @typeParam R - the `AsyncResult` type to inspect.
  *
  * @example
  * ```ts
- * import { all, Ok, Err } from "unthrown";
- *
- * all([Ok(1), Ok("a"), Ok(true)]).get(); // => [1, "a", true] (typed [number, string, boolean])
- * all([Ok(1), Err("e"), Ok(3)]); // => Err("e") (short-circuits on the first Err)
+ * type T = AsyncOkOf<AsyncResult<User, NotFound>>; // User
  * ```
- */
-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 — for that, reach for
- * {@link validateAllFromDict}, which accumulates every `Err` and folds them into
- * one modeled error.
- *
- * @category Aggregate
- *
- * @example
- * ```ts
- * import { allFromDict, Ok, Err } from "unthrown";
- *
- * allFromDict({ id: Ok(1), name: Ok("ada") }).get(); // => { id: 1, name: "ada" }
- * allFromDict({ id: Ok(1), name: Err("missing") }); // => Err("missing")
- * ```
+ * @category Types
  */
-declare function allFromDict<R extends ResultRecord>(results: R): Result$1<{ [K in keyof R]: OkOf<R[K]>; }, ErrOf<R[keyof R]>>;
+type AsyncOkOf<R> = R extends Awaitable<infer Res> ? OkOf<Res> : never;
 /**
- * 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};
- * to report **every** `Err`, use {@link validateAllAsync}.
+ * Extract the error type `E` from an {@link AsyncResult} type — the async
+ * counterpart of {@link ErrOf}.
  *
- * @category Aggregate
+ * @typeParam R - the `AsyncResult` type to inspect.
  *
  * @example
  * ```ts
- * import { allAsync, fromSafePromise } from "unthrown";
- *
- * const both = allAsync([
- *   fromSafePromise(Promise.resolve(1)),
- *   fromSafePromise(Promise.resolve(2)),
- * ]);
- * (await both).get(); // => [1, 2]
+ * type E = AsyncErrOf<AsyncResult<User, NotFound>>; // NotFound
  * ```
- */
-declare function allAsync<Rs extends readonly AsyncResult$1<unknown, unknown>[]>(results: readonly [...Rs]): AsyncResult$1<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. To report **every** `Err`, use
- * {@link validateAllFromDictAsync}.
- *
- * @category Aggregate
- *
- * @example
- * ```ts
- * import { allFromDictAsync, fromSafePromise } from "unthrown";
  *
- * const both = allFromDictAsync({
- *   a: fromSafePromise(Promise.resolve(1)),
- *   b: fromSafePromise(Promise.resolve("x")),
- * });
- * (await both).get(); // => { a: 1, b: "x" }
- * ```
+ * @category Types
  */
-declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): AsyncResult$1<{ [K in keyof R]: AsyncOkOf<R[K]>; }, AsyncErrOf<R[keyof R]>>;
+type AsyncErrOf<R> = R extends Awaitable<infer Res> ? ErrOf<Res> : never;
+//#endregion
+//#region src/constructors.d.ts
 /**
- * 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.
+ * Construct a successful `void` {@link Result} — `Result<void, never>` —
+ * sparing you `Ok(undefined)` and typing the success channel `void`, not
+ * `undefined`.
  *
- * 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}.
+ * @example
+ * ```ts
+ * import { Ok } from "unthrown";
  *
- * @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.
+ * Ok(); // => a void success: Result<void, never>
+ * ```
  *
- * @category Aggregate
+ * @category Constructors
+ */
+export declare function Ok(): Result<void, never>;
+/**
+ * Construct a successful {@link Result}.
+ *
+ * @typeParam T - the success value type.
+ * @param value - the success value to wrap.
  *
  * @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")
+ * import { Ok } from "unthrown";
  *
- * // 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>
+ * Ok(2).map((n) => n + 1); // => Ok(3)
+ * Ok(42).get(); // => 42
  * ```
+ *
+ * @category Constructors
  */
-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>;
+export declare function Ok<T>(value: T): Result<T, never>;
 /**
- * Collect a **record** of {@link Result}s, accumulating every `Err` — the
- * accumulating counterpart of {@link allFromDict}, and the named counterpart of
- * {@link validateAll}.
+ * Construct a failed {@link Result} carrying a **modeled** error.
  *
- * @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.
+ * @typeParam E - the modeled error type.
+ * @param error - the domain error to wrap.
  *
- * 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.
+ * @example
+ * ```ts
+ * import { Err } from "unthrown";
  *
- * @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.
+ * Err("not_found").map((n) => n + 1); // => Err("not_found") (map skipped)
+ * Err("not_found").getErr(); // => "not_found"
+ * ```
  *
- * @category Aggregate
+ * @category Constructors
+ */
+export declare function Err<E>(error: E): Result<never, E>;
+/**
+ * Construct a successful `void` {@link AsyncResult} — `AsyncResult<void, never>`
+ * — the pre-lifted form of the no-arg {@link Ok}, sparing you
+ * `Ok(undefined).toAsync()`.
  *
  * @example
  * ```ts
- * import { validateAllFromDict, Ok, Err } from "unthrown";
+ * import { OkAsync } 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")
+ * OkAsync(); // => a void success: AsyncResult<void, never>
  * ```
+ *
+ * @category Constructors
  */
-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>;
+export declare function OkAsync(): AsyncResult<void, never>;
 /**
- * The asynchronous counterpart of {@link validateAll}: collect a tuple/array of
- * {@link AsyncResult}s, accumulating every `Err` into one merged error.
+ * Construct a successful {@link AsyncResult} from a pure value — the pre-lifted
+ * form of {@link Ok}, sparing you `Ok(value).toAsync()`.
  *
  * @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.
+ * Reach for this on the synchronous/early branch of an `AsyncResult`-returning
+ * function, so both branches share one return type without a trailing
+ * `.toAsync()`. Named with the `Async` suffix the async free functions carry
+ * (`allAsync`, `allFromDictAsync`); the {@link AsyncResult} companion aliases it
+ * as `AsyncResult.Ok` (the namespace already says "async", so the suffix drops).
  *
- * @category Aggregate
+ * @typeParam T - the success value type.
+ * @param value - the success value to wrap.
  *
  * @example
  * ```ts
- * import { validateAllAsync, OkAsync, ErrAsync } from "unthrown";
+ * import { OkAsync, type AsyncResult } from "unthrown";
  *
- * const checked = validateAllAsync(
- *   [OkAsync(1), ErrAsync("stock"), ErrAsync("credit")],
- *   (errors) => errors.join(" and "),
- * );
- * // (await checked) => Err("stock and credit")
+ * function loadItems(ids: string[]): AsyncResult<Item[], never> {
+ *   if (ids.length === 0) return OkAsync([]); // no more Ok([]).toAsync()
+ *   return itemRepository.load(ids);
+ * }
  * ```
+ *
+ * @category Constructors
  */
-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>;
+export declare function OkAsync<T>(value: T): AsyncResult<T, never>;
 /**
- * The asynchronous counterpart of {@link validateAllFromDict}: collect a record
- * of {@link AsyncResult}s, accumulating every `Err` into one merged error.
+ * Construct a failed {@link AsyncResult} carrying a **modeled** error — the
+ * pre-lifted form of {@link Err}, sparing you `Err(error).toAsync()`.
  *
  * @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.
+ * The error-channel mirror of {@link OkAsync}; see it for the naming and the
+ * `AsyncResult.Err` companion alias.
  *
- * @category Aggregate
+ * @typeParam E - the modeled error type.
+ * @param error - the domain error to wrap.
  *
  * @example
  * ```ts
- * import { validateAllFromDictAsync, OkAsync, ErrAsync } from "unthrown";
+ * import { 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")
+ * ErrAsync("not_found"); // AsyncResult<never, string>
  * ```
+ *
+ * @category Constructors
  */
-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
+export declare function ErrAsync<E>(error: E): AsyncResult<never, E>;
 /**
- * Companion object grouping the **`Result`-producing** entry points under a
- * 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.validateAll},
- * {@link Result.validateAllFromDict}, {@link Result.isOk}, {@link Result.isErr},
- * {@link Result.isDefect}, {@link Result.isResult}.
- *
- * @remarks
- * Purely additive sugar — each member **is** the corresponding free function.
- * The free functions remain the primary, tree-shakeable API; importing only
- * `{ Ok }` never pulls this object in. The value `Result` and the type
- * {@link Result} share one name (the companion-object pattern).
- *
- * The **async** entry points live on the sibling {@link AsyncResult} companion
- * (`AsyncResult.fromPromise`, `AsyncResult.all`, …), grouped by what they
- * return — a static lives in exactly one namespace.
+ * Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.
  *
- * @category Facade
+ * @returns `true` when `r` is `Ok`.
  *
  * @example
  * ```ts
- * import { Result } from "unthrown";
- * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).get(); // => 2
+ * import { isOk, Ok, Err, type Result } from "unthrown";
+ *
+ * isOk(Ok(1)); // => true
+ * isOk(Err("boom")); // => false
+ *
+ * declare const r: Result<number, string>;
+ * if (isOk(r)) r.value; // number, narrowed
  * ```
+ *
+ * @category Guards
  */
-declare const Result: {
-  readonly Ok: typeof Ok;
-  readonly Err: typeof Err;
-  readonly Do: typeof Do;
-  readonly fromNullable: typeof fromNullable;
-  readonly fromThrowable: typeof fromThrowable;
-  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;
-  readonly isResult: typeof isResult;
-};
+export declare function isOk<T, E>(r: Result<T, E>): r is OkView<T, E>;
 /**
- * `Result<T, E>` — the core discriminated union. Shares its name with the
- * {@link Result | companion object} above (the value and type are one name); this
- * is the type half.
+ * Type guard: narrow a {@link Result} to its `Err` variant, exposing `.error`.
  *
- * @remarks
- * A `Result` is a discriminated union, so TypeDoc can't list its methods on this
- * alias. Its fluent combinators (`map`, `flatMap`, `match`, `get`, …) are
- * documented one per entry on {@link ResultMethods} — the shared method surface
- * every variant carries. For "which one do I reach for?", see the
- * [Choosing a combinator](/reference/combinators) guide.
+ * @returns `true` when `r` is `Err`.
  *
- * @category Facade
+ * @example
+ * ```ts
+ * import { isErr, Ok, Err, type Result } from "unthrown";
+ *
+ * isErr(Err("boom")); // => true
+ * isErr(Ok(1)); // => false
+ *
+ * declare const r: Result<number, string>;
+ * if (isErr(r)) r.error; // string, narrowed
+ * ```
+ *
+ * @category Guards
  */
-type Result<T, E> = Result$1<T, E>;
+export declare function isErr<T, E>(r: Result<T, E>): r is ErrView<E, T>;
 /**
- * Companion object grouping the **`AsyncResult`-producing** entry points under
- * 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.validateAll}, {@link AsyncResult.validateAllFromDict}.
+ * Type guard: narrow a {@link Result} to its `Defect` variant, exposing `.cause`.
  *
  * @remarks
- * The async sibling of {@link Result}. Statics are grouped by what they
- * **return**, so the pre-lifted constructors, `fromExecutor`,
- * `fromPromise`/`fromSafePromise`, and the async aggregates sit here rather
- * than on {@link Result}; the namespace
- * already conveys "async", so the members drop the `Async` suffix their free
- * functions carry (`AsyncResult.Ok` is `OkAsync`; `AsyncResult.Err` is
- * `ErrAsync`; `AsyncResult.Do` is `DoAsync`; `AsyncResult.all` is `allAsync`;
- * `AsyncResult.allFromDict` is
- * `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.
+ * A `Defect` has no public constructor — it only arises at a boundary (e.g. a
+ * callback throwing inside a combinator). This guard is how you detect one.
  *
- * @category Facade
+ * @returns `true` when `r` is a `Defect`.
  *
  * @example
  * ```ts
- * import { AsyncResult } from "unthrown";
- * const user = await AsyncResult.fromPromise(
- *   fetchUser(id),
- *   (c, defect) => defect(c),
- * );
- * user.get(); // => the fetched user (on success)
- * ```
- */
-declare const AsyncResult: {
-  readonly Ok: typeof OkAsync;
-  readonly Err: typeof ErrAsync;
-  readonly Do: typeof DoAsync;
-  readonly fromExecutor: typeof fromExecutor;
-  readonly fromPromise: typeof fromPromise;
-  readonly fromSafePromise: typeof fromSafePromise;
-  readonly all: typeof allAsync;
-  readonly allFromDict: typeof allFromDictAsync;
-  readonly validateAll: typeof validateAllAsync;
-  readonly validateAllFromDict: typeof validateAllFromDictAsync;
-};
-/**
- * `AsyncResult<T, E>` — the async counterpart of {@link Result}. Shares its name
- * with the {@link AsyncResult | companion object} above (value and type are one
- * name); this is the type half.
+ * import { isDefect, Ok } from "unthrown";
  *
- * @remarks
- * `AsyncResult` carries the async fluent surface; its combinators (`map`,
- * `flatMap`, `match`, `get`, …) are documented one per entry — with their
- * async signatures — on {@link AsyncResultMethods}. For "which one do I reach
- * for?", see the [Choosing a combinator](/reference/combinators) guide.
+ * // A throw inside a combinator is captured as a Defect:
+ * const r = Ok(1).map(() => {
+ *   throw new Error("boom");
+ * });
+ * isDefect(r); // => true
+ * isDefect(Ok(1)); // => false
  *
- * @category Facade
+ * if (isDefect(r)) r.cause; // unknown, narrowed
+ * ```
+ *
+ * @category Guards
  */
-type AsyncResult<T, E> = AsyncResult$1<T, E>;
+export declare function isDefect<T, E>(r: Result<T, E>): r is DefectView<T, E>;
 //#endregion
 //#region src/tagged.d.ts
 type Props = Record<string, unknown>;
@@ -2277,8 +2421,8 @@ type TaggedErrorConstructor<Tag extends string> = {
  * new HttpError({ status: 500 }).status; // => 500
  * ```
  */
-declare function TaggedError<Tag extends string>(tag: Tag, options?: {
+export 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, validateAll, validateAllAsync, validateAllFromDict, validateAllFromDictAsync };
+export type { AsyncErrOf, AsyncOkOf, AsyncResultMethods, Awaitable, DefectView, ErrMatcher, ErrOf, ErrView, FailureView, Matcher, NotThenable, OkOf, OkView, PatternMatcher, ResultMethods, Settle, TaggedErrorConstructor, TaggedErrorInstance, UniversalPattern };