unthrown 5.0.0-beta.7 → 5.0.0-beta.9

package/README.md

@@ -11,7 +11,7 @@ pnpm add unthrown
 ```
 
 No peer dependencies — the exhaustive error matcher is built-in and exported as
-`match` / `P` / `tag`.
+`match` / `P`.
 
 ```ts
 import { fromPromise, P, TaggedError } from "unthrown";
@@ -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(P.tag("NotFound"), () => 404),
   defect: () => 500,
 });
 ```
@@ -35,7 +36,7 @@ const status = await user.match({
   observable only via `match` / `recoverDefect`.
 - **Qualification at every boundary** — `fromPromise` / `fromThrowable` force you
   to triage each failure into a modeled error or a defect.
-- **Tagged errors** — `TaggedError(tag)` + `tag(t)`, folded exhaustively through
+- **Tagged errors** — `TaggedError(tag)` + `P.tag(t)`, folded exhaustively through
   `match`'s built-in error matcher.
 - **Zero runtime dependencies** (the matcher is built-in), ESM-first, dual
   CJS/ESM.

package/dist/index.cjs

@@ -48,7 +48,7 @@ function isPlainObject(x) {
 /**
 * Runtime test: does `pattern` match `value`? A branded `P.*` pattern applies
 * its predicate; a **plain-object** pattern (an object literal, e.g. the
-* `{ _tag }` produced by `tag()`) matches when every key matches recursively
+* `{ _tag }` produced by `P.tag()`) matches when every key matches recursively
 * (extra keys on the value are ignored — matching is structural); anything
 * else — primitives, but also class instances, arrays, and foreign pattern
 * objects (e.g. a real ts-pattern matcher, whose keys are symbols) — is
@@ -117,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
 */
@@ -133,9 +135,25 @@ 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.tag<const Tag extends string>(value: Tag): { _tag: Tag }` — the
+*   `{ _tag: t }` object pattern, matching any value whose `_tag` equals `t` (a
+*   `TaggedError`, or any `_tag`-discriminated member) and narrowing the
+*   branch's parameter to that variant, payload included. The workhorse of the
+*   error channel: `matcher.with(P.tag("NotFound"), (e) => …)`. It composes like
+*   any other pattern — in a grouped arm
+*   (`.with(P.tag("A"), P.tag("B"), handler)`) and inside `P.union`.
 * - `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).
@@ -148,6 +166,7 @@ const universal = pattern(() => true);
 const P = Object.freeze({
 	_: universal,
 	any: universal,
+	tag: (value) => ({ _tag: value }),
 	instanceOf: (cls) => pattern((value) => value instanceof cls),
 	when: (guard) => pattern(guard),
 	union: (...patterns) => pattern((value) => patterns.some((sub) => matches(sub, value))),
@@ -507,7 +526,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)
@@ -515,6 +534,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 });
 * ```
 *
@@ -1507,10 +1529,14 @@ const AsyncResult = {
 * so a payload `cause` (e.g. a wrapped driver error) is a legitimate,
 * *narrowing* structured field.
 *
-* `_tag` is the discriminant matched by {@link tag} in the error combinators
-* (`result.mapErrCases((matcher) => matcher.with(tag("NotFound"), …))`) and in
-* `match`; `Error.name` is the human-facing label in stack traces and logs. By
-* default they coincide, but
+* The matching half of the convention is `P.tag(t)` — the pattern constructor on
+* the `P` namespace, which builds the `{ _tag: t }` pattern this factory's `_tag`
+* is selected by (there is no standalone `tag` export).
+*
+* `_tag` is the discriminant matched by `P.tag` in the error combinators
+* (`result.mapErrCases((matcher) => matcher.with(P.tag("NotFound"), …))`) and in
+* `match`'s `errCases` handler; `Error.name` is the human-facing label in stack
+* traces and logs. By default they coincide, but
 * they can be **decoupled** with `options.name` — so a tag can be namespaced for
 * collision-safety (`"@my-lib/RetryableError"`) without that slash-prefixed
 * string leaking into `Error.name`:
@@ -1569,29 +1595,6 @@ function TaggedError(tag, options) {
 	}
 	return TaggedErrorBase;
 }
-/**
-* A matcher pattern matching any value whose `_tag` equals `value` — a
-* {@link TaggedError}, or any discriminated member. Equivalent to the object
-* pattern `{ _tag: value }`, but reads better inside an error-matching
-* combinator and narrows to the matching variant, payload included.
-*
-* @typeParam Tag - the string literal tag to match.
-* @param value - the `_tag` to match.
-*
-* @category Tagged errors
-*
-* @example
-* ```ts
-* result.mapErrCases((matcher) =>
-*   matcher
-*     .with(tag("NotFound"), () => new NotFoundException())
-*     .with(tag("Conflict"), (e) => new ConflictException(e.key)),
-* );
-* ```
-*/
-function tag(value) {
-	return { _tag: value };
-}
 //#endregion
 exports.AsyncResult = AsyncResult;
 exports.Do = Do;
@@ -1619,4 +1622,3 @@ exports.isErr = isErr;
 exports.isOk = isOk;
 exports.isResult = isResult;
 exports.match = match;
-exports.tag = tag;

package/dist/index.d.cts

@@ -127,17 +127,23 @@ type PinTooLate = {
  */
 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) => 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
+   * patterns — `matcher.with(P.tag("A"), P.tag("B"), handler)`). The handler
    * receives the input narrowed to what the patterns match (computed against
    * `Remaining`, so cases already handled by earlier arms are excluded); the
    * matched cases are subtracted from `Remaining`.
@@ -208,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
  */
@@ -217,9 +225,25 @@ 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.tag<const Tag extends string>(value: Tag): { _tag: Tag }` — the
+ *   `{ _tag: t }` object pattern, matching any value whose `_tag` equals `t` (a
+ *   `TaggedError`, or any `_tag`-discriminated member) and narrowing the
+ *   branch's parameter to that variant, payload included. The workhorse of the
+ *   error channel: `matcher.with(P.tag("NotFound"), (e) => …)`. It composes like
+ *   any other pattern — in a grouped arm
+ *   (`.with(P.tag("A"), P.tag("B"), handler)`) and inside `P.union`.
  * - `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).
@@ -232,6 +256,9 @@ declare function match<const E>(value: E): Matcher<E, E, never>;
 declare const P: Readonly<{
   _: UniversalPattern;
   any: UniversalPattern;
+  tag: <const Tag extends string>(value: Tag) => {
+    _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>;
   union: <const Pts extends readonly [unknown, ...unknown[]]>(...patterns: Pts) => PatternMatcher<MatchedOf<Pts[number]>>;
@@ -499,9 +526,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).
@@ -542,7 +575,8 @@ 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):
@@ -642,8 +676,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
@@ -856,7 +891,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");
@@ -864,7 +899,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)}`,
  * });
  * ```
@@ -1396,7 +1432,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)
@@ -1404,6 +1440,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 });
  * ```
  *
@@ -1934,10 +1973,14 @@ type TaggedErrorConstructor<Tag extends string> = {
  * so a payload `cause` (e.g. a wrapped driver error) is a legitimate,
  * *narrowing* structured field.
  *
- * `_tag` is the discriminant matched by {@link tag} in the error combinators
- * (`result.mapErrCases((matcher) => matcher.with(tag("NotFound"), …))`) and in
- * `match`; `Error.name` is the human-facing label in stack traces and logs. By
- * default they coincide, but
+ * The matching half of the convention is `P.tag(t)` — the pattern constructor on
+ * the `P` namespace, which builds the `{ _tag: t }` pattern this factory's `_tag`
+ * is selected by (there is no standalone `tag` export).
+ *
+ * `_tag` is the discriminant matched by `P.tag` in the error combinators
+ * (`result.mapErrCases((matcher) => matcher.with(P.tag("NotFound"), …))`) and in
+ * `match`'s `errCases` handler; `Error.name` is the human-facing label in stack
+ * traces and logs. By default they coincide, but
  * they can be **decoupled** with `options.name` — so a tag can be namespaced for
  * collision-safety (`"@my-lib/RetryableError"`) without that slash-prefixed
  * string leaking into `Error.name`:
@@ -1974,29 +2017,6 @@ type TaggedErrorConstructor<Tag extends string> = {
 declare function TaggedError<Tag extends string>(tag: Tag, options?: {
   readonly name?: string;
 }): TaggedErrorConstructor<Tag>;
-/**
- * A matcher pattern matching any value whose `_tag` equals `value` — a
- * {@link TaggedError}, or any discriminated member. Equivalent to the object
- * pattern `{ _tag: value }`, but reads better inside an error-matching
- * combinator and narrows to the matching variant, payload included.
- *
- * @typeParam Tag - the string literal tag to match.
- * @param value - the `_tag` to match.
- *
- * @category Tagged errors
- *
- * @example
- * ```ts
- * result.mapErrCases((matcher) =>
- *   matcher
- *     .with(tag("NotFound"), () => new NotFoundException())
- *     .with(tag("Conflict"), (e) => new ConflictException(e.key)),
- * );
- * ```
- */
-declare function tag<const Tag extends string>(value: Tag): {
-  _tag: 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, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match, tag };
+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, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"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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"}
+{"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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"}

package/dist/index.d.mts

@@ -127,17 +127,23 @@ type PinTooLate = {
  */
 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) => 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
+   * patterns — `matcher.with(P.tag("A"), P.tag("B"), handler)`). The handler
    * receives the input narrowed to what the patterns match (computed against
    * `Remaining`, so cases already handled by earlier arms are excluded); the
    * matched cases are subtracted from `Remaining`.
@@ -208,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
  */
@@ -217,9 +225,25 @@ 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.tag<const Tag extends string>(value: Tag): { _tag: Tag }` — the
+ *   `{ _tag: t }` object pattern, matching any value whose `_tag` equals `t` (a
+ *   `TaggedError`, or any `_tag`-discriminated member) and narrowing the
+ *   branch's parameter to that variant, payload included. The workhorse of the
+ *   error channel: `matcher.with(P.tag("NotFound"), (e) => …)`. It composes like
+ *   any other pattern — in a grouped arm
+ *   (`.with(P.tag("A"), P.tag("B"), handler)`) and inside `P.union`.
  * - `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).
@@ -232,6 +256,9 @@ declare function match<const E>(value: E): Matcher<E, E, never>;
 declare const P: Readonly<{
   _: UniversalPattern;
   any: UniversalPattern;
+  tag: <const Tag extends string>(value: Tag) => {
+    _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>;
   union: <const Pts extends readonly [unknown, ...unknown[]]>(...patterns: Pts) => PatternMatcher<MatchedOf<Pts[number]>>;
@@ -499,9 +526,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).
@@ -542,7 +575,8 @@ 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):
@@ -642,8 +676,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
@@ -856,7 +891,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");
@@ -864,7 +899,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)}`,
  * });
  * ```
@@ -1396,7 +1432,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)
@@ -1404,6 +1440,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 });
  * ```
  *
@@ -1934,10 +1973,14 @@ type TaggedErrorConstructor<Tag extends string> = {
  * so a payload `cause` (e.g. a wrapped driver error) is a legitimate,
  * *narrowing* structured field.
  *
- * `_tag` is the discriminant matched by {@link tag} in the error combinators
- * (`result.mapErrCases((matcher) => matcher.with(tag("NotFound"), …))`) and in
- * `match`; `Error.name` is the human-facing label in stack traces and logs. By
- * default they coincide, but
+ * The matching half of the convention is `P.tag(t)` — the pattern constructor on
+ * the `P` namespace, which builds the `{ _tag: t }` pattern this factory's `_tag`
+ * is selected by (there is no standalone `tag` export).
+ *
+ * `_tag` is the discriminant matched by `P.tag` in the error combinators
+ * (`result.mapErrCases((matcher) => matcher.with(P.tag("NotFound"), …))`) and in
+ * `match`'s `errCases` handler; `Error.name` is the human-facing label in stack
+ * traces and logs. By default they coincide, but
  * they can be **decoupled** with `options.name` — so a tag can be namespaced for
  * collision-safety (`"@my-lib/RetryableError"`) without that slash-prefixed
  * string leaking into `Error.name`:
@@ -1974,29 +2017,6 @@ type TaggedErrorConstructor<Tag extends string> = {
 declare function TaggedError<Tag extends string>(tag: Tag, options?: {
   readonly name?: string;
 }): TaggedErrorConstructor<Tag>;
-/**
- * A matcher pattern matching any value whose `_tag` equals `value` — a
- * {@link TaggedError}, or any discriminated member. Equivalent to the object
- * pattern `{ _tag: value }`, but reads better inside an error-matching
- * combinator and narrows to the matching variant, payload included.
- *
- * @typeParam Tag - the string literal tag to match.
- * @param value - the `_tag` to match.
- *
- * @category Tagged errors
- *
- * @example
- * ```ts
- * result.mapErrCases((matcher) =>
- *   matcher
- *     .with(tag("NotFound"), () => new NotFoundException())
- *     .with(tag("Conflict"), (e) => new ConflictException(e.key)),
- * );
- * ```
- */
-declare function tag<const Tag extends string>(value: Tag): {
-  _tag: 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, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match, tag };
+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, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match };
 //# sourceMappingURL=index.d.mts.map