unthrown 5.0.0-beta.6 → 5.0.0-beta.8

package/README.md

@@ -14,7 +14,7 @@ No peer dependencies — the exhaustive error matcher is built-in and exported a
 `match` / `P` / `tag`.
 
 ```ts
-import { fromPromise, P, TaggedError } from "unthrown";
+import { fromPromise, tag, TaggedError } from "unthrown";
 
 class NotFound extends TaggedError("NotFound") {} // our modeled domain failure
 class NotFoundError extends Error {} // what `fetchUser` rejects with on a 404
@@ -25,7 +25,8 @@ const user = fromPromise(fetchUser(id), (cause, defect) =>
 
 const status = await user.match({
   ok: () => 200,
-  errCases: (matcher) => matcher.with(P._, () => 404), // `errCases` takes the exhaustive matcher
+  // `errCases` takes the exhaustive matcher — every case of E named:
+  errCases: (matcher) => matcher.with(tag("NotFound"), () => 404),
   defect: () => 500,
 });
 ```

package/dist/index.cjs

@@ -93,6 +93,13 @@ var MatcherImpl = class {
 		}
 		return this;
 	}
+	/**
+	* Type-level only — pinning the output type has no runtime meaning, so the
+	* builder is returned unchanged (as ts-pattern does).
+	*/
+	returnType() {
+		return this;
+	}
 	exhaustive() {
 		if (this.#matched) return this.#result;
 		throw new NonExhaustiveError(this.#value);
@@ -110,8 +117,10 @@ Object.freeze(MatcherImpl.prototype);
 * @remarks
 * This is unthrown's own matcher (the former ts-pattern re-export): the same
 * call-site shape, with exhaustiveness computed by plain `Exclude` over the
-* builder's `Remaining` parameter. A `P._` catch-all is provably exhaustive
-* even over an unresolved generic input.
+* builder's `Remaining` parameter. Name every case of the input union; the
+* `P._` catch-all is the escape hatch, and is provably exhaustive even over an
+* unresolved generic input — one of the two cases it is irreplaceable for (see
+* {@link P}).
 *
 * @category Constructors
 */
@@ -126,9 +135,18 @@ const universal = pattern(() => true);
 /**
 * The pattern namespace (unthrown's own; the former ts-pattern `P`):
 *
-* - `P._` / `P.any` — the universal catch-all. Matches anything, and (because
-*   its phantom type is `unknown`) makes the builder provably exhaustive even
-*   when the matched input is an unresolved type parameter.
+* - `P._` / `P.any` — the universal catch-all, and an **escape hatch** rather
+*   than the default: matching the error channel means naming its cases, so
+*   reach for this only where they cannot be named. Matches anything, and
+*   (because its phantom type is `unknown`) makes the builder provably
+*   exhaustive even when the matched input is an unresolved type parameter.
+*   Two situations are legitimate: 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**, not a union of cases (a validator's issues
+*   array, say), where one arm _is_ the enumeration. `@unthrown/oxlint`'s
+*   `no-catch-all-pattern` (in its `recommended` preset) flags every other use;
+*   keep the deliberate ones behind a targeted `oxlint-disable` saying which of
+*   the two it is.
 * - `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).
@@ -334,7 +352,8 @@ var Res = class {
 	tapErrCases(f) {
 		if (this.tag !== "Err") return this;
 		try {
-			runMatch(f, this.error);
+			const out = runMatch(f, this.error);
+			if (isDefectMarker(out)) return observerThrowToDefect(out.cause, this.error);
 			return this;
 		} catch (cause) {
 			return observerThrowToDefect(cause, this.error);
@@ -344,6 +363,7 @@ var Res = class {
 		if (this.tag !== "Err") return this;
 		try {
 			const r = runMatch(f, this.error);
+			if (isDefectMarker(r)) return observerThrowToDefect(r.cause, this.error);
 			if (!isResult(r)) return nonResultCallbackDefect();
 			return r.tag === "Ok" ? this : passThrough(r);
 		} catch (cause) {
@@ -498,7 +518,7 @@ function defectRes(cause) {
 *
 * @example
 * ```ts
-* import { isResult, Ok } from "unthrown";
+* import { isResult, Ok, P } from "unthrown";
 *
 * isResult(Ok(1)); // => true
 * isResult({ tag: "Ok" }); // => false (look-alike, wrong prototype)
@@ -506,6 +526,9 @@ function defectRes(cause) {
 *
 * 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 });
 * ```
 *
@@ -559,16 +582,21 @@ function runMatch(f, error) {
 	return f(match(error), defect).run();
 }
 /**
-* A throw inside a *failure observer* (`tapErrCases` / `tapDefect` / `flatTapErrCases`)
-* must not destroy the failure being observed — that is the exact place (e.g. a
-* failing error-logger) where losing the underlying failure hurts most. The
-* resulting Defect aggregates both: `errors[0]` is the observer's throw,
-* `errors[1]` the original failure.
+* A throw inside a *failure observer* (`tapErrCases` / `tapDefect` /
+* `tapFailure` / `flatTapErrCases`) must not destroy the failure being observed
+* — that is the exact place (e.g. a failing error-logger) where losing the
+* underlying failure hurts most. The resulting Defect aggregates both:
+* `errors[0]` is the observer's own failure, `errors[1]` the original failure.
+*
+* An observer branch returning the injected `defect(cause)` marker
+* (`tapErrCases` / `flatTapErrCases`) takes the same route: it is the
+* lint-clean, expression-position form of a `throw` (Thesis #5), so it must not
+* behave differently from one.
 *
 * @internal
 */
 function observerThrowToDefect(thrown, original) {
-	return defectRes(new AggregateError([thrown, original], "unthrown: a failure-observer callback threw; errors[0] is the callback's throw, errors[1] the original failure"));
+	return defectRes(new AggregateError([thrown, original], "unthrown: a failure-observer callback failed; errors[0] is the callback's failure (a throw, or a deliberate defect), errors[1] the original failure"));
 }
 /**
 * Validate that a `bind`/`let` scope is a real (non-null) object before merging a
@@ -738,7 +766,8 @@ var AsyncRes = class AsyncRes {
 		return new AsyncRes(this.#promise.then((r) => {
 			if (r.tag !== "Err") return r;
 			try {
-				runMatch(f, r.error);
+				const out = runMatch(f, r.error);
+				if (isDefectMarker(out)) return observerThrowToDefect(out.cause, r.error);
 				return r;
 			} catch (cause) {
 				return observerThrowToDefect(cause, r.error);
@@ -749,7 +778,9 @@ var AsyncRes = class AsyncRes {
 		return new AsyncRes(this.#promise.then(async (r) => {
 			if (r.tag !== "Err") return passThrough(r);
 			try {
-				const inner = await runMatch(f, r.error);
+				const out = runMatch(f, r.error);
+				if (isDefectMarker(out)) return observerThrowToDefect(out.cause, r.error);
+				const inner = await out;
 				if (!isResult(inner)) return nonResultCallbackDefect();
 				return inner.tag === "Ok" ? passThrough(r) : passThrough(inner);
 			} catch (cause) {

package/dist/index.d.cts

@@ -1,3 +1,24 @@
+//#region src/defect.d.ts
+declare const DEFECT: unique symbol;
+/**
+ * The opaque marker a `qualify` function returns to triage a cause as
+ * **unexpected**.
+ *
+ * @remarks
+ * `qualify` (passed to {@link fromPromise} / {@link fromThrowable}) returns
+ * `E | Defect`: either a modeled domain error, or a `Defect` produced by the
+ * injected `defect` helper to say "this failure is not modeled". A `Defect` is
+ * opaque — it carries the original cause for the boundary to convert into the
+ * third runtime state of a `Result`. It is **not** a public value; the only way
+ * to mint one is the `defect` helper the boundary passes to `qualify`.
+ *
+ * @internal
+ */
+type Defect = {
+  readonly [DEFECT]: true;
+  readonly cause: unknown;
+};
+//#endregion
 //#region src/matcher.d.ts
 /**
  * Cross-copy brand for `P.*` pattern objects: `Symbol.for` yields the same
@@ -52,6 +73,47 @@ type MatchedOf<Pt> = Pt extends PatternMatcher<infer M> ? M : Pt extends object
 type NonExhaustive<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.
+ *
+ * @internal
+ */
+declare const UNSET: unique symbol;
+/** @internal */
+type Unset = typeof UNSET;
+/**
+ * A branch handler's return position: free inference (`O2`) while the builder
+ * is unpinned — today's behaviour, unchanged — or the declared type once
+ * `.returnType<R>()` has pinned it.
+ *
+ * `Defect` stays legal under a pin: the injected `defect` helper is the
+ * sanctioned deliberate `Err`→`Defect` form (Thesis #5), and `Defect` is not a
+ * nameable public type, so `returnType<R | Defect>()` cannot be spelled. The
+ * marker is subtracted from the output by {@link PinnedOut} — the same net
+ * result as the unpinned `Exclude<O, Defect>`, decided up front.
+ *
+ * @internal
+ */
+type BranchReturn<Declared, O2> = [Declared] extends [Unset] ? O2 : Declared | Defect;
+/**
+ * The builder's output: the accumulated union of branch returns while
+ * unpinned, or the declared type once pinned.
+ *
+ * @internal
+ */
+type PinnedOut<Declared, O> = [Declared] extends [Unset] ? O : Declared;
+/**
+ * The diagnostic type of `.returnType` on a builder that already has an output
+ * to contradict — an arm has contributed a return type, or it is already
+ * pinned: not callable, so the mistake is caught where it is written.
+ *
+ * @internal
+ */
+type PinTooLate = {
+  readonly "unthrown: `.returnType<R>()` must come before any arm produces an output, and only once": true;
+};
 /**
  * The match builder over an input union `E`. `Remaining` tracks the cases not
  * yet covered by a `.with(…)` arm; `O` accumulates the branch output union.
@@ -63,16 +125,22 @@ type NonExhaustive<Remaining> = {
  * @typeParam O - the union of branch return types so far.
  * @category Types
  */
-type Matcher<E, Remaining, O> = {
+type Matcher<E, Remaining, O, Declared = Unset> = {
   /**
-   * The catch-all arm: `.with(P._, handler)` / `.with(P.any, handler)`. A
-   * **state transition**, not a computation — it returns `Matcher<E, never, …>`
-   * with the remaining cases literally `never`, so the builder is provably
-   * exhaustive even when `E` is an unresolved type parameter (a lazily-deferred
-   * `Exclude<E, unknown>` would not resolve there). This is what lets a
-   * boundary helper generic in `E` terminate with the catch-all (issue #145).
+   * The catch-all arm: `.with(P._, handler)` / `.with(P.any, handler)` — the
+   * wildcard **escape hatch**, not the way to handle a concrete error union
+   * (name those cases; `@unthrown/oxlint`'s `no-catch-all-pattern`, in its
+   * `recommended` preset, flags the wildcard).
+   *
+   * It is a **state transition**, not a computation — it returns
+   * `Matcher<E, never, …>` with the remaining cases literally `never`, so the
+   * builder is provably exhaustive even when `E` is an unresolved type
+   * parameter (a lazily-deferred `Exclude<E, unknown>` would not resolve
+   * there). That is what makes it irreplaceable for a helper generic in `E`:
+   * it can terminate a match no arm list could (issue #145) — one of the two
+   * sanctioned uses (see {@link P}).
    */
-  with<O2>(pattern: UniversalPattern, handler: (value: Remaining) => O2): Matcher<E, never, O | O2>;
+  with<O2>(pattern: UniversalPattern, handler: (value: Remaining) => BranchReturn<Declared, O2>): Matcher<E, never, O | O2, Declared>;
   /**
    * Add an arm: one or more patterns sharing a single handler (grouped
    * patterns — `matcher.with(tag("A"), tag("B"), handler)`). The handler
@@ -80,20 +148,48 @@ type Matcher<E, Remaining, O> = {
    * `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]>>) => O2]): Matcher<E, Exclude<Remaining, MatchedOf<Pts[number]>>, O | O2>;
+  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>;
+  /**
+   * 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
+   * union of whatever the branches happened to return.
+   *
+   * @remarks
+   * Reach for it when the output is **decided by a signature rather than by
+   * the branches** — most sharply in code generic in `E`, where the fold's type
+   * has to be declared. It also stops a drifting branch from silently widening
+   * the outgoing type, reports the mismatch **on the offending branch**, and
+   * gives branch returns a contextual type (so object literals need no
+   * annotation).
+   *
+   * A branch may still return the injected `defect` helper's marker; the defect
+   * channel is not part of the declared output.
+   *
+   * Callable **before any arm has produced an output**, and only once
+   * (mirroring ts-pattern's up-front pin): once there is an inferred output for
+   * the pin to contradict — or the builder is already pinned — this is typed as
+   * a non-callable diagnostic. In practice that means calling it directly after
+   * `match(…)`; the gate is about output rather than position, so an earlier arm
+   * whose handler returns `never` (it always throws) contributes nothing and
+   * does not close it — sound, since a `never` branch can contradict no declared
+   * type. A no-op at runtime.
+   *
+   * @typeParam R - the declared output type of every branch.
+   */
+  returnType: [O] extends [never] ? [Declared] extends [Unset] ? <R>() => Matcher<E, Remaining, never, R> : PinTooLate : PinTooLate;
   /**
    * Terminate the match. Typed callable only when every case is covered
    * (`Remaining` is `never`); otherwise it is a branded diagnostic object
    * naming the remaining cases, and the builder fails the `ExhaustiveMatch`
    * constraint at the combinator call site.
    */
-  exhaustive: [Remaining] extends [never] ? () => O : NonExhaustive<Remaining>;
+  exhaustive: [Remaining] extends [never] ? () => PinnedOut<Declared, O> : NonExhaustive<Remaining>;
   /**
    * Execute the match (the combinators call this; it runs `.exhaustive()`).
    * A value with no matching arm throws {@link NonExhaustiveError} —
    * unreachable for well-typed callers.
    */
-  run(): O;
+  run(): PinnedOut<Declared, O>;
 };
 /**
  * Thrown by `.run()` / `.exhaustive()` when no arm matched the value. For
@@ -118,8 +214,10 @@ declare class NonExhaustiveError extends Error {
  * @remarks
  * This is unthrown's own matcher (the former ts-pattern re-export): the same
  * call-site shape, with exhaustiveness computed by plain `Exclude` over the
- * builder's `Remaining` parameter. A `P._` catch-all is provably exhaustive
- * even over an unresolved generic input.
+ * builder's `Remaining` parameter. Name every case of the input union; the
+ * `P._` catch-all is the escape hatch, and is provably exhaustive even over an
+ * unresolved generic input — one of the two cases it is irreplaceable for (see
+ * {@link P}).
  *
  * @category Constructors
  */
@@ -127,9 +225,18 @@ declare function match<const E>(value: E): Matcher<E, E, never>;
 /**
  * The pattern namespace (unthrown's own; the former ts-pattern `P`):
  *
- * - `P._` / `P.any` — the universal catch-all. Matches anything, and (because
- *   its phantom type is `unknown`) makes the builder provably exhaustive even
- *   when the matched input is an unresolved type parameter.
+ * - `P._` / `P.any` — the universal catch-all, and an **escape hatch** rather
+ *   than the default: matching the error channel means naming its cases, so
+ *   reach for this only where they cannot be named. Matches anything, and
+ *   (because its phantom type is `unknown`) makes the builder provably
+ *   exhaustive even when the matched input is an unresolved type parameter.
+ *   Two situations are legitimate: 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**, not a union of cases (a validator's issues
+ *   array, say), where one arm _is_ the enumeration. `@unthrown/oxlint`'s
+ *   `no-catch-all-pattern` (in its `recommended` preset) flags every other use;
+ *   keep the deliberate ones behind a targeted `oxlint-disable` saying which of
+ *   the two it is.
  * - `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).
@@ -149,27 +256,6 @@ declare const P: Readonly<{
   number: PatternMatcher<number>;
 }>;
 //#endregion
-//#region src/defect.d.ts
-declare const DEFECT: unique symbol;
-/**
- * The opaque marker a `qualify` function returns to triage a cause as
- * **unexpected**.
- *
- * @remarks
- * `qualify` (passed to {@link fromPromise} / {@link fromThrowable}) returns
- * `E | Defect`: either a modeled domain error, or a `Defect` produced by the
- * injected `defect` helper to say "this failure is not modeled". A `Defect` is
- * opaque — it carries the original cause for the boundary to convert into the
- * third runtime state of a `Result`. It is **not** a public value; the only way
- * to mint one is the `defect` helper the boundary passes to `qualify`.
- *
- * @internal
- */
-type Defect = {
-  readonly [DEFECT]: true;
-  readonly cause: unknown;
-};
-//#endregion
 //#region src/types.d.ts
 /**
  * Flatten an intersection into a single object literal so accumulated `bind` /
@@ -430,9 +516,15 @@ type ResultMethods<out T, out E> = {
    * 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`.
    *
-   * `.with(P._, …)` is the deliberate uniform/catch-all (it makes the match
-   * exhaustive). Match on anything the matcher supports — `_tag`, `code`,
-   * structural shape, guards, or grouped patterns `.with(a, b, handler)`.
+   * **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).
@@ -473,16 +565,21 @@ type ResultMethods<out T, out E> = {
    * @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 (use `.with(P._, …)` for a catch-all). If a branch throws, 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. A failable
+   * 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.
+   * @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>;
   /**
@@ -495,10 +592,13 @@ type ResultMethods<out T, out E> = {
    * 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` **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).
+   * *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).
@@ -566,8 +666,9 @@ type ResultMethods<out T, out E> = {
    * 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). Use
-   * `.with(P._, …)` for a uniform catch-all. Unlike the combinators the branches
+   * 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
@@ -780,7 +881,7 @@ type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
  *
  * @example
  * ```ts
- * import { Ok, Err, P, type Result } from "unthrown";
+ * import { Ok, Err, type Result } from "unthrown";
  *
  * function half(n: number): Result<number, "odd"> {
  *   return n % 2 === 0 ? Ok(n / 2) : Err("odd");
@@ -788,7 +889,8 @@ type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
  *
  * const message = half(10).match({
  *   ok: (n) => `got ${n}`,
- *   errCases: (matcher) => matcher.with(P._, (e) => `failed: ${e}`),
+ *   // every case of `E` named — here the one literal it holds
+ *   errCases: (matcher) => matcher.with("odd", () => "failed: odd"),
  *   defect: (cause) => `bug: ${String(cause)}`,
  * });
  * ```
@@ -925,11 +1027,13 @@ type AsyncResultMethods<out T, out E> = {
   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, the result is a `Defect` whose cause is an `AggregateError` of
-   * `[thrown, original failure]` — observing a failure never destroys it. An
+   * 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) — branch results are discarded, so a rejected `Promise`
-   * would float unobserved. 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}.
@@ -939,9 +1043,10 @@ type AsyncResultMethods<out T, out 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, the result is a `Defect` whose cause is
-   * an `AggregateError` of `[thrown, original failure]` — observing a failure
-   * never destroys it.
+   * 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>;
   /**
@@ -1317,7 +1422,7 @@ declare class GetError<E = unknown> extends Error {
  *
  * @example
  * ```ts
- * import { isResult, Ok } from "unthrown";
+ * import { isResult, Ok, P } from "unthrown";
  *
  * isResult(Ok(1)); // => true
  * isResult({ tag: "Ok" }); // => false (look-alike, wrong prototype)
@@ -1325,6 +1430,9 @@ declare class GetError<E = unknown> extends Error {
  *
  * 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 });
  * ```
  *

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/matcher.ts","../src/defect.ts","../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/defect.ts","../src/matcher.ts","../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}