🔀 Merge feature/tagged-union-matcher into main

A handler's `expectTypeOf(shape)` only proved the type the compiler inferred;
nothing observed the argument `dispatch` passed. Passing `String(shape)` at the
call site therefore kept the whole suite green while breaking every key whose
property name differs from its value (`true`, `null`, `1`).

Pair each handler expectation with a runtime assertion: `assert.equal` where a
handler runs for one shape, the disjunction over the set a `_` fallback accepts
where it runs for several. Where the exact value matters the fallback returns
its shape verbatim and the call site asserts it; a widening pattern absorbs the
remainder type into the return union, so the claim stays strict-free. The
mutation above now fails 10 of the 33 tests.

Rule: CONTRIBUTING.md, rationale: development/testing.md § Handler arguments.

.oxlintrc.json

@@ -34,7 +34,9 @@
                 "no-unused-expressions": "off",
                 "no-empty-file": "off",
                 "import/no-nodejs-modules": "off",
-                "eslint/no-magic-numbers": "off"
+                "eslint/no-magic-numbers": "off",
+                "unicorn/no-null": "off",
+                "typescript/no-floating-promises": "off"
             }
         },
         {

AGENTS.md

@@ -25,10 +25,11 @@ first-action facts. Do not restate evolving prose here — it will drift.
 Don't silence the type system to force a green run. As an agent these are forbidden:
 
 - `// @ts-nocheck`, `// @ts-ignore`, `// @ts-expect-error`
-- `// oxlint-disable` / `// oxlint-disable-next-line` — the sole exception is the fixed file-level `typescript/no-floating-promises` header at the top of a `*.test.ts` file, spelled exactly as [CONTRIBUTING.md § Rules the tools don't enforce](./CONTRIBUTING.md#rules-the-tools-dont-enforce) prescribes
+- `// oxlint-disable` / `// oxlint-disable-next-line`
+- editing `.oxlintrc.json` to silence a finding (e.g. turning `typescript/no-floating-promises` off)
 - `as` casts used to push an expression through (type-aware oxlint already flags unsafe assertions)
 
-Fix the root cause with the type system instead — narrowing, generics, `satisfies`, conditional / mapped types, utility types (`NonNullable`, `Exclude`, …). TypeScript can express it; that's the intended tool. The `oxlint-disable`-location rule in [CONTRIBUTING.md § Rules the tools don't enforce](./CONTRIBUTING.md#rules-the-tools-dont-enforce) is a **human** last-resort convention (so a reviewer can spot a deliberate suppression) — it is not permission for you to add one, except the one fixed `*.test.ts` file-level header named there. If the types genuinely cannot express something, stop and surface the conflict (commit message / handover) rather than suppress it.
+Fix the root cause with the type system instead — narrowing, generics, `satisfies`, conditional / mapped types, utility types (`NonNullable`, `Exclude`, …). TypeScript can express it; that's the intended tool. Suppressions — a source `oxlint-disable` **or** a `.oxlintrc.json` entry — are a **human** last resort, not a tool for you. If the types genuinely cannot express something, stop and surface the conflict (commit message / handover) rather than suppress it.
 
 The same applies to the checks themselves: **never `git commit --no-verify`** (or otherwise skip a pre-commit / pre-push hook). The checks are fast and offline, so a redundant run is fine — bypassing a hook to get green is the identical anti-pattern. If a commit already skipped a hook, redo it through one: `git reset --soft HEAD~1 && git commit -C <skipped-sha>`.
 
@@ -42,7 +43,9 @@ Never start a long-lived / blocking process such as `npm run watch`. It runs unt
 
 ### Working on tasks
 
-- **Task with subtasks** (a task that has indented children): create the branch with `npm run create:branch -- <prefix>/<desc>`, inferring the prefix from the task content (`feature/…` / `fix/…` / `chore/…`) — do not hand-write `git switch -c`, the command enforces the clean-tree / current-`main` / green-baseline precondition. Work on each subtask with commits, then present a concise handover for the user to review. Use this fixed shape:
+Every task — with or without subtasks — goes through the complete branching model:
+
+- Create the branch with `npm run create:branch -- <prefix>/<desc>`, inferring the prefix from the task content (`feature/…` / `fix/…` / `chore/…`) — do not hand-write `git switch -c`, the command enforces the clean-tree / current-`main` / green-baseline precondition. Work with commits (each subtask gets one or more), then present a concise handover for the user to review. Use this fixed shape:
 
     ```md
     ## Handover — <branch>
@@ -54,9 +57,7 @@ Never start a long-lived / blocking process such as `npm run watch`. It runs unt
 
     Once the user has no further objections, merge back: `npm run create:finish` (on the branch — it merges `--no-ff`, runs `npm run verify`, and deletes the branch). The branching model is documented in [CONTRIBUTING.md § Branching model](./CONTRIBUTING.md#branching-model).
 
-- **Leaf task** (no indented children): implement on the current branch and commit.
+Follow [CONTRIBUTING.md § Testing discipline (type-driven)](./CONTRIBUTING.md#testing-discipline-type-driven) throughout.
-
-In both cases, follow [CONTRIBUTING.md § Testing discipline (type-driven)](./CONTRIBUTING.md#testing-discipline-type-driven). Each subtask gets one or more commits.
 
 ## Read these
 

CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+- add `getTaggedUnionMatcher` / `getTaggedUnionMatcherW` for discriminated unions
+
+## [0.5.0] - 2026-09-21
+
+- reject a fallback when the handler map already covers the universe
+- allow boolean, null and undefined in the matcher universe
+
+## [0.4.0] - 2026-09-20
+
+- move the `_` fallback out of handlers
+
 ## [0.3.0] - 2026-09-18
 
 - condensed primitive matcher factories down to 2 from formerly 4
@@ -59,7 +70,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - basic setup
 
-[Unreleased]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.3.0...main
+[Unreleased]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.5.0...main
+[0.5.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.4.0...0.5.0
+[0.4.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.3.0...0.4.0
 [0.3.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.2.0...0.3.0
 [0.2.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.1.8...0.2.0
 [0.1.8]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.1.7...0.1.8

CONTRIBUTING.md

@@ -66,7 +66,10 @@ before the implementation. The loop is **type → red → green → refactor**:
 4. **Refactor** — with the type system and the tests as the safety net, then
    `npm run verify` as the definition-of-done gate.
 
-Every test pairs an `expectTypeOf(...)` with an `assert.*`; keep them together.
+Every test pairs an `expectTypeOf(...)` with an `assert.*`; keep them together
+— including the expectations inside handler bodies, which pair with an
+assertion on the value dispatch passed, not only the type it inferred (see
+[development/testing.md § Handler arguments](./development/testing.md#handler-arguments)).
 The autocomplete tests (`src/util/__tests__/lsp-completion.test.ts` for the
 helper, `src/primitive.test.ts` for the matcher's popup) are the
 exception —
@@ -155,12 +158,9 @@ reaches for by default:
   [Script prefix convention](#script-prefix-convention).
 - **`oxlint-disable` directives live in source, not `.oxlintrc.json`.** The
   trade-off must sit next to the code it silences. This is a _human_ last-resort
-  convention; agents must not add these — see
+  convention; agents must not add one, nor edit `.oxlintrc.json` to silence a
-  [AGENTS.md § Never do](./AGENTS.md#never-do). The sole agent exception is the
+  finding (e.g. `typescript/no-floating-promises`) — see
-  fixed file-level header at the top of a `*.test.ts` file, spelled exactly:
+  [AGENTS.md § Never do](./AGENTS.md#never-do). (why:
-  `/* oxlint-disable typescript/no-floating-promises -- expectTypeOf() is a sync
-type-assertion library that the type-aware linter misidentifies as a promise
-*/` — any other suppression stays human-last-resort. (why:
   [development/tooling.md](./development/tooling.md#oxlint-disable-directives-live-next-to-the-code))
 - **Don't put slow / network / whole-project scans in `check` or pre-commit.**
   Advisory scans are not correctness gates; they belong under `maintain:`. (why:

README.md

@@ -9,7 +9,7 @@ ordinary objects whose `matches` method is a TypeScript type guard, so narrowing
 composes the way any other guard does. It is deliberately not a regex engine and
 not a macro: there is no transpiler and no DSL to learn, and the type-level
 contract is the feature — see [development/library.md](./development/library.md)
-for the design decisions and the known limitations.
+for the design decisions and [Caveats](#caveats) for the limits.
 
 ## Requirements
 
@@ -23,6 +23,18 @@ for the design decisions and the known limitations.
 
 Yet to be implemented
 
+## Caveats
+
+- **A value and its stringification collide.** Object keys stringify, so a
+  universe that mixes a member with the string it stringifies to — `1 | "1"`,
+  `true | "true"`, `null | "null"` — collapses to a single handler key and both
+  members are routed to it. Use one form or the other.
+- **`symbol` and `bigint` are not supported.** A `symbol` brand is a
+  compile-time phantom with nothing to match at runtime, and a `bigint` is not a
+  valid property key; neither satisfies the matcher's universe constraint.
+- **`NaN` and `-0` cannot be matched specifically.** They have no literal type,
+  so both stay part of `number`.
+
 ## License
 
 MIT © 2025 tmu. See [LICENSE](./LICENSE).

backlog.tasks

@@ -37,23 +37,35 @@ Testing:
     ✔ Rewrite `src/util/__tests__/lsp-completion.ts` onto `createMessageConnection` and typed requests @done
     ✔ Update `development/testing.md § Autocomplete` for the new client @done
     ✔ Run `npm run verify` and check the task off @done
+☐ Test a literal union widened with `(string & {})` — `"red" | "green" | "yellow" | (string & {})` @medium
+    → autocomplete should still offer the literals; arbitrary strings stay assignable and fall through to the fallback
 
 Matcher:
 ✔ Clean up: adopt the 3-overload matcher (`src/prototype-ac2.ts`) and delete the prototypes @high @done
     → `getMatcher` / `getMatcherW`, each with overloads `ExhaustiveLoose` → `Fallback` → `Handlers` (order is load-bearing)
     → fold into `src/primitive.ts` / the public API; drop `src/prototype*.ts`
-☐ `_` should receive only the unhandled `T` keys, not all of `T` @medium
+✔ `_` should receive only the unhandled `T` keys, not all of `T` @medium @done
-    → today `_: (shape: T) => R`; desired `_: (shape: Exclude<T, handledKeys>) => R`
+    → the fallback is now a second argument: `(handlers, (s) => …)`, `s: Exclude<T, keyof handlers>`
-☐ An exhaustive pattern that also carries `_` must be a compile error @medium
+✔ A fallback for an already-exhaustive handler map must be a compile error @medium @done
-    → `{ a, b, _ }` for `T = "a" | "b"` is accepted today; the redundant `_` should be rejected
+    → rejected by an F-bounded constraint on `Handled` (checked *after* inference); a conditional in the fallback parameter is evaluated too early and breaks contextual typing
+✔ Implement matcher with similar API like matcher from primitive.ts @high @done
+    → `getTaggedUnionMatcher` / `getTaggedUnionMatcherW`, curried on the discriminant key
+    → fallback is the second argument; `_` removed
+☐ Rename `primitive` to `primitive-union` and `getMatcher` to `getPrimitiveMatcher` @medium
+    → `src/primitive.ts` / `src/primitive.test.ts` → `primitive-union.*`
+    → `getMatcherW` → `getPrimitiveMatcherW` for symmetry with the tagged-union pair
+    → update `src/index.ts`, `development/library.md` and any README references
 
 Bugs:
 ✔ TS 7 LSP server logs `context canceled` on stderr at shutdown @done
     → `handleExit` returns `io.EOF`, cancelling the background context while `Session.updateWatches` is still in flight; the bare error is flushed to stderr and the server exits 1
     → close stdin after `shutdown` instead of sending `exit`; the server exits cleanly (code 0, no output), kill kept as a fallback
 Enhancements:
-☐ Allow boolean literals in primitive union patterns (e.g. `true: () => "yes"`) @medium
+✔ Allow boolean literals in primitive union patterns (e.g. `true: () => "yes"`) @medium @done
-☐ Are there other primitive types that should be supported in union patterns? (e.g. `bigint`, `symbol`) @medium
+    ✔ Are there other primitive types that should be supported in union patterns? (e.g. `bigint`, `symbol`) @medium @done
+        → added boolean, null and undefined; rejected `symbol` (compile-time brand, nothing at runtime) and `bigint` (not a property key)
+☐ Allow boolean, null and undefined discriminant values in tagged-union patterns @medium
+    → needs the primitive matcher's `PatternKey` / `PatternParam` projection; see development/library.md § Tagged-union matcher
 
 Documentation:
 ☐ Bring README.md back to its previous form — synopsis and examples restored, in the correct place

development/library.md

@@ -3,91 +3,184 @@
 The type-level design of the public API and the limitations it carries. The
 user-facing reference is [README § API](../README.md#api).
 
-The matcher below is implemented in `src/primitive.ts` and re-exported from
+The matchers are implemented in `src/primitive.ts` (`getMatcher` /
-`src/index.ts` as `getMatcher` / `getMatcherW`; the rest of the library is
+`getMatcherW`) and `src/tagged-union.ts` (`getTaggedUnionMatcher` /
-placeholder code.
+`getTaggedUnionMatcherW`), re-exported from `src/index.ts`; the rest of the
+library is placeholder code.
 
 ## Matcher shape
 
 #### Decision (2026-09)
 
-A matcher is built by a factory and applied to a pattern:
+A factory takes the universe and returns a builder; the builder takes a handler
+map and an optional fallback:
 
 ```ts
 const matcher = getMatcher<"a" | "b">()({ a: (s) => …, b: (s) => … });
+const fallback = getMatcher<"a" | "b" | "c">()({ a: (s) => … }, (s) => …);
 ```
 
-Whether the pattern is exhaustive or has a fallback is decided **at the call
+Exhaustive or fallback is decided **at the call site**, by whether the second
-site**, by whether it carries `_` — F#'s `| _ ->`. Only the return-strictness
+argument is present. The fallback's parameter is the remainder
-axis remains, so there are two factories:
+`Exclude<T, keyof Handled>`. Only the return-strictness axis remains, so there
+are two factories:
 
-- `getMatcher` — one common `R`, the best common return type of every handler;
+- `getMatcher` — one common `R`; the fallback must fit it;
-- `getMatcherW` — the union of every handler's return type.
+- `getMatcherW` — the union `PatternReturns<Handled> | R`.
 
-Both are three overloads whose order is load-bearing:
+Each factory is two overloads whose order is load-bearing:
 
-1. `ExhaustiveLoose<R, T>` = `{ [K in T]: UnaryFn<K, R> } & { _?: UnaryFn<T, R> }`
+1. `Handlers<T, R>` — the exhaustive form, and the contextual type of the
-2. `Fallback<R, T>` = `Partial<…> & { _: UnaryFn<T, R> }`
+   handler-map popup;
-3. `Handlers<R, T>` — the pure exhaustive shape
+2. `Handled extends Exact<Partial<Handlers<T, R>>, Handled>` intersected with
+   `MustBePartial<T, Handled>`, plus `Fallback<T, Handled, R>` — a partial
+   handler map plus the fallback, rejected when the map already covers `T`.
 
 #### Why
 
-- **Autocomplete reads the first overload, the error reads the last.**
+- **The fallback is an argument, not a property.** TypeScript fixes a property's
-  TypeScript takes the first overload signature as the contextual type for the
+  contextual type before it infers its sibling keys, so `_: (s) => …` in the
-  object-literal popup, and the last for `No overload matches this call`. So
+  handler map can only see all of `T`, never `Exclude<T, keyof Handled>`. A later
-  `ExhaustiveLoose` first yields the popup `_?, a, b` (T-keys required, `_`
+  argument is contextually typed from inference on an earlier one, so the split
-  optional) while `Handlers` last yields `Property 'b' is missing`. The two can be
+  is what makes the remainder expressible.
-  tuned independently.
+- **The redundant-fallback guard is an F-bounded constraint.** A map that
-- Two factories, not four: the fallback is a pattern _shape_, not a separate API.
+  already covers `T` plus a fallback is rejected by folding
-- The widened return union is derived from the pattern's handler types, so it
+  `MustBePartial<T, Handled>` into `Handled`'s own constraint. The guard is
-  needs no fourth signature.
+  checked _after_ `Handled` is inferred, so the contextual pass that types the
+  handler callbacks survives. The obvious conditional
+  `Exclude<T, keyof Handled> extends never ? …` in the fallback's parameter
+  type is evaluated while `Handled` is still its constraint and rejects every
+  partial map whose callbacks are context-sensitive.
+- **Overload order keeps both messages.** #1 supplies the contextual type
+  (`a, b, c`); #2 accepts a partial map once a fallback is present, so its popup
+  is optional (`a?, b?, c?`). A gap without a fallback is reported against #1.
+- **`R` needs an inference site.** `R` inside the `Exact<…>` constraint is not
+  one, so `handlers: Handled & Partial<Handlers<T, R>>` re-adds it; without that
+  `R` collapses to `unknown` when the handler params are inferred.
+- **`Exact` restores the excess-property check.** TypeScript skips it for a
+  generic constraint, so without `Exact` the handler map accepts keys outside
+  `T`.
+- Two factories, not four: the fallback is an argument, not a separate API.
 
 #### Rejected
 
-- **Four factories** (exhaustive and fallback each split by return handling).
+- **Single-object `_`** (the former shape). `_` sees only all of `T`; the
-  The exhaustive/fallback axis is expressible as one pattern type; four
+  remainder is not expressible there, and an exhaustive map plus `_` was
-  signatures duplicate it.
+  accepted.
-- **Union merge** — one type `Exhaustive<R,T> | (Partial<…> & { _: … })`,
+- **Curried handlers-first** — `(handlers)(fallback)`. Rejected: two calls for
-  explicit `<T>()`. Type-safe and completable, but TypeScript reports the
+  the common case. It is not needed for the redundant-fallback guard, which the
-  near-miss union member, so a missing key reads `Property '_' is missing`
+  F-bounded constraint already provides (see Why).
-  instead of naming the key. Arm order does not change the report; the overload
+- **`this` / HKT self-reference.** `this` is post-construction (method bodies,
-  split does.
+  return positions); a parameter's contextual type is pre-construction.
-- **Overload merge with only the exhaustive arm last.** Fixes the missing-key
+  `keyof this` in an interface method is the interface, not the literal.
-  message, but a wrong `_` parameter is then reported against the exhaustive
+- **Variance / `const` type parameters / `NoInfer` / `unique symbol` brands /
-  arm, and `Parameters<typeof factory>` sees only one arm.
+  defaulted type-param guards.** None change inference or evaluation order;
-- **Inferred universe** — `match(pattern)` with `T` taken from the keys
+  `in`/`out` on the handler map broke contextual typing outright. `NoInfer`
-  (exhaustive) or from `_`'s annotated parameter (fallback), via `NoInfer<T>` and
+  specifically leaks into the emitted `.d.ts`, raising the consumer floor to
-  `_?: never`, split by overloads (a plain union merges inference; measured
+  TypeScript 5.4 (README promises `>= 5.0`).
-  `T = "_" | "a"`). No explicit `<T>`, and pipe-friendly. Rejected because: with
+- **Union merge**, **overload merge with only the exhaustive arm last**,
-  no declared universe the exhaustive popup offers only `_`; an unannotated `_`
+  **inferred universe**, **conditional `RequireKeys`**, **cases-first curried** —
-  widens `T` to `string | number`; and `NoInfer` leaks into the emitted `.d.ts`,
+  decided against while the API was single-object; their reasons (reported
-  raising the consumer floor to TypeScript 5.4 (README promises `>= 5.0`).
+  near-miss member, no `_` in the exhaustive popup, `NoInfer`/floor, `keyof P`
-- **Conditional `RequireKeys`** — parameter
+  counts optional keys, not pipe-friendly) hold where they still apply.
-  `P & ("_" extends keyof P ? unknown : Handlers<R, T>)`. Gives the good
-  missing-key message, but `keyof P` counts _optional_ keys: a widened value
-  whose declared type has `_?:` bypasses the completeness check. Demanding a
-  required `_` instead rejects that case but breaks `P` inference — `P` falls back
-  to its constraint and partial literals then demand every key. Typos also need a
-  `NoExtra` guard, whose message degrades to `not assignable to never`.
-- **Cases-first curried** — `match(["a", "b"])({ a: …, b: … })`. Completion works
-  for exhaustive patterns, and the array is a single source of truth for the
-  runtime list and the union. Rejected as not pipe-friendly; it needs a runtime
-  array; and the single-call form `match(cases, pattern)` cannot infer `R` (the
-  mapped key type `K[number]` stays deferred, so `R` widens to `unknown`).
 
 #### Known issue
 
-- The `_` handler receives **all** of `T`, not the unhandled subset
+- `PatternReturns` must be
-  (`Exclude<T, handledKeys>`).
-- An exhaustive pattern that also carries `_` is accepted; the redundant `_`
-  should be a compile error.
-- The widened overloads carry a completeness guard
-  `keyof P extends T | "_" ? unknown : never`, because TypeScript does not apply
-  the excess-property check to a generic constraint: a generic parameter accepts
-  extra keys, a parameter typed as a concrete object type does not.
-  `PatternReturns` must be
   `ReturnType<Extract<ValueOf<P>, (...args: never[]) => unknown>>` so it survives
   the closed, partly-optional `P` constraints.
 - `Parameters<typeof factory>[0]` resolves only the **last** overload, so it is
   not a sound "rejected" oracle for a factory. Factory-negative tests use
   `@ts-expect-error` call sites (the test file only — the general ban stands).
+
+## Shared internals
+
+#### Decision (2026-09)
+
+`src/matcher-shared.ts` holds the four universe-agnostic pieces both matchers
+use: `UnaryFn`, `PatternReturns`, `RedundantFallback`, `HandlerMap`.
+
+#### Why
+
+- `RedundantFallback`'s property name is the diagnostic, so one definition
+  keeps the two matchers' message from drifting; the other three appear verbatim
+  in both public signatures.
+
+#### Rejected
+
+- **A generic `Matcher<Universe>` over the interface pair, `Handlers`,
+  `Fallback` and `MustBePartial`.** Each is built from its own universe
+  (`PatternKey`/`PatternParam` vs `Tags`/`MapTaggedUnion`); abstracting over the
+  F-bounded `Handled` constraint that makes the remainder work risks the
+  contextual typing it exists to preserve.
+
+## Tagged-union matcher
+
+#### Decision (2026-09)
+
+`getTaggedUnionMatcher` / `getTaggedUnionMatcherW` mirror the primitive pair
+with one extra curried step for the discriminant key:
+
+```ts
+type Shape =
+    | { kind: "circle"; radius: number }
+    | { kind: "square"; side: number };
+
+const area = getTaggedUnionMatcher<Shape>()("kind")({
+    circle: (s) => Math.PI * s.radius ** 2,
+    square: (s) => s.side ** 2,
+});
+const fallback = getTaggedUnionMatcher<Shape>()("kind")(
+    { circle: (s) => … },
+    (s) => …, // s: { kind: "square"; side: number }
+);
+```
+
+The key is a separate call because `K` is inferred from its literal argument and
+`T` is fixed by the first factory; one call could not infer both.
+`Discriminated<T>` restricts the key to properties whose values are tags.
+
+#### Why
+
+- **Same fallback/remainder machinery as the primitive matcher.** `HandledMembers`
+  maps the handled tags to their members and `Exclude<T, …>` is the fallback's
+  parameter; the redundant-fallback guard is the same F-bounded constraint. Only
+  the "universe" changes — `T`'s members instead of primitive values.
+- **`T extends object`, not `Record<PropertyKey, unknown>`.** An `interface` has
+  no implicit index signature, so the `Record` constraint would reject
+  interface-based unions. The runtime reads the tag off `object` with one
+  assertion, the tagged twin of the primitive dispatch's `shape as string | number`.
+- **`MapTaggedUnion` distributes with `Extract`.** A duplicated tag yields a
+  union of members instead of dropping one.
+
+#### Known issue
+
+- Tags are `string | number` only. A `boolean` / `null` / `undefined`
+  discriminant (`{ ok: true } | { ok: false }`) is rejected by `Discriminated`,
+  because those values are not property keys; supporting them needs the
+  primitive matcher's `PatternKey` / `PatternParam` projection.
+- A member's tag must be unique across the union; two members with the same tag
+  collapse to a union under one handler.
+
+## Primitive universe
+
+#### Decision (2026-09)
+
+The universe (`Matchable`) is `string | number | boolean | null | undefined`,
+with `boolean` admitted as `true | false`.
+
+`boolean`/`null`/`undefined` are not property keys, so handler-map keys are a
+projection (`PatternKey`: each member stringified) and `PatternParam` inverts
+it, so callbacks receive the real member (`true`, not `"true"`). The popup
+offers `true`, `false`, `null`, `undefined` by name (verified over LSP).
+
+#### Why
+
+- Runtime dispatch indexes with the raw `shape`; `handlers[true]` coerces to
+  `"true"` at runtime exactly as `String` would. The `shape as string | number`
+  assertion only placates `TS2538` and buys the number fast path (an explicit
+  `String()` defeats V8's numeric-key path: measured ~2× on number-keyed
+  dispatch).
+- `symbol`/`bigint`/`NaN`/`-0` are rejected, and a member colliding with its
+  stringification is unguarded: user-facing, stated once in
+  [README § Caveats](../README.md#caveats).

development/testing.md

@@ -37,6 +37,40 @@ in
 build step, and the runner relies on the `.ts` import-extension convention (see
 [tooling.md](./tooling.md#source-imports-use-ts-extensions)).
 
+## Handler arguments
+
+#### Decision (2026-09)
+
+A handler's `expectTypeOf(shape)` is always paired with an assertion on the
+argument `dispatch` actually passed: `assert.equal` where the handler runs for
+one shape, `assert.ok(s === … || s === …)` over the set a `_` fallback accepts
+(`assert` is imported as `strict`, so each comparison is `Object.is`). Where a
+test should also prove that the _exact_ value reached the handler unchanged,
+the fallback returns the shape verbatim and the call site asserts it.
+
+#### Why
+
+- The parameter's type is what the compiler inferred from the pattern; the
+  argument is what the runtime passed. Only the second can drift, and the keys
+  whose property name differs from their value (`true`, `null`, `1`) are
+  exactly where it can — see [library.md](./library.md).
+- `String(shape)` at the call site keeps every type expectation and every
+  return-value assertion green; the argument assertions fail (10 of the 33
+  tests). Without them the suite never looks at the passed argument.
+- Returning the shape verbatim costs a widening pattern nothing: the remainder
+  type joins the union of handler returns in place of a marker literal, so the
+  test still shows the widening it is named for.
+
+#### Rejected
+
+- A recorded `unknown[]` of every fallback call compared with `deepEqual`:
+  strong, but it couples the assertion to call order, and the sink sits three
+  blocks away from the value it observes.
+- `typeof` checks: they cannot separate `2` from its key text `"2"`, which is
+  the drift a fallback with a numeric remainder can hit.
+- One expected value asserted inline in a fallback: its argument is a _set_ of
+  shapes, so only the disjunction holds on every call.
+
 ## AAA ordering
 
 The rule is in
@@ -167,8 +201,8 @@ the CLI is for manual inspection.
 
 ## Known issues
 
-- The type-aware linter misidentifies `expectTypeOf()` as a floating promise, so
+- The type-aware linter misidentifies `expectTypeOf()` as a floating promise.
-  test files that use it (`src/primitive.test.ts`) carry a file-level
+  It is a known false positive, so `typescript/no-floating-promises` is off for
-  `oxlint-disable typescript/no-floating-promises` with an explanatory comment.
+  `**/*.test.ts` in the `.oxlintrc.json` override rather than repeated as a
-  It is a known false positive, not a rule worth disabling project-wide (see
+  file-level header (see
   [tooling.md § oxlint-disable directives live next to the code](./tooling.md#oxlint-disable-directives-live-next-to-the-code)).

development/tooling.md

@@ -106,26 +106,34 @@ Type-aware oxlint is enabled via `options.typeAware: true` in `.oxlintrc.json`
 
 #### Decision (2026-09)
 
-A type-aware rule that false-positives is silenced with a source-level
+A type-aware rule that false-positives **at one site** is silenced with a
-`oxlint-disable` directive (see `src/primitive.ts`,
+source-level `oxlint-disable` directive (see `src/primitive.ts`). A rule that is
-`src/primitive.test.ts`), not by turning the rule off in `.oxlintrc.json`.
+wrong for a whole **file class** is turned off in a `.oxlintrc.json` `overrides`
+entry instead — e.g. `typescript/no-floating-promises` (synchronous
+`expectTypeOf` reads as an unhandled promise) and `unicorn/no-null` (intentional
+`null` inputs) for `**/*.test.ts`. The same exemption is not repeated as a
+file-level header in every affected file.
 
 #### Why
 
-- The disable sits next to the code it silences, visible to anyone reading the
+- A one-site disable sits next to the code it silences, visible to anyone
-  source.
+  reading the source, and the rule stays on everywhere else.
-- The rule stays on everywhere else, so only the mis-firing line is exempted.
+- A file-class rule is a property of the file class, not of one line; the
+  override states it once, where the rest of the file-class config lives.
 
 #### Rejected
 
-- A project-wide disable in `.oxlintrc.json` for a false positive: it hides the
+- A project-wide disable in `.oxlintrc.json` for a one-site false positive: it
-  exemption from the reader of the affected code and switches the rule off
+  hides the exemption from the reader of the affected code and switches the rule
-  repo-wide for a one-site problem.
+  off repo-wide for a one-site problem.
+- A repeated file-level `oxlint-disable` header for a file-class false positive:
+  the copies drift and scatter one config decision across the tree.
 
 #### Known issue
 
-- A source-level disable is a _human_ last resort. AI agents must not add one;
+- Both placements are _human_ last resorts. AI agents must neither add a source
-  they fix the type at its root (see [AGENTS.md § Never do](../AGENTS.md#never-do)).
+  disable nor edit `.oxlintrc.json`; they fix the type at its root (see
+  [AGENTS.md § Never do](../AGENTS.md#never-do)).
 
 ### Unwanted stylistic rules are turned off in the config
 

package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "tiny-pattern-ts",
-    "version": "0.3.0",
+    "version": "0.5.0",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "tiny-pattern-ts",
-            "version": "0.3.0",
+            "version": "0.5.0",
             "license": "MIT",
             "dependencies": {
                 "type-fest": "^5.9.0"

package.json

@@ -1,6 +1,6 @@
 {
     "name": "tiny-pattern-ts",
-    "version": "0.3.0",
+    "version": "0.5.0",
     "description": "Pattern matching for TypeScript/ESM environments (F#-style, not regex)",
     "keywords": [
         "adt",

src/index.ts

@@ -1 +1,5 @@
 export { getMatcher, getMatcherW } from "./primitive.ts";
+export {
+    getTaggedUnionMatcher,
+    getTaggedUnionMatcherW,
+} from "./tagged-union.ts";

src/matcher-shared.ts

@@ -0,0 +1,28 @@
+import type { ValueOf } from "type-fest";
+
+// The primitive and tagged-union matchers differ in their universe, but the
+// handler/fallback plumbing is identical; these are the shared pieces. The
+// boundary is deliberate: `Handlers`, `Fallback` and `MustBePartial` stay with
+// each matcher because they are built from its universe. See development/library.md.
+
+// A handler: one universe member in, one return value out.
+export type UnaryFn<T, R> = (shape: T) => R;
+
+// `Extract` drops optional handlers (`undefined`) so `PatternReturns` also works
+// when `P`'s constraint has optional keys.
+export type PatternReturns<P> = ReturnType<
+    Extract<ValueOf<P>, (...args: never[]) => unknown>
+>;
+
+// The diagnostic raised when a fallback is supplied for an already-exhaustive
+// handler map. Each matcher's `MustBePartial` folds it into `Handled`'s
+// constraint so the guard is checked after inference.
+export interface RedundantFallback {
+    readonly "every case is already handled, so the fallback is redundant": never;
+}
+
+// The runtime dispatch map the handler maps and fallback erase to.
+export type HandlerMap = Record<
+    string | number,
+    UnaryFn<never, unknown> | undefined
+>;

src/primitive.test.ts

@@ -1,4 +1,3 @@
-/* oxlint-disable typescript/no-floating-promises -- expectTypeOf() is a sync type-assertion library that the type-aware linter misidentifies as a promise */
 import { strict as assert } from "node:assert";
 import path from "node:path";
 import { test } from "node:test";
@@ -22,12 +21,14 @@ test("getMatcher: exhaustive pattern infers one common return type", () => {
 
     // Act
     const matcher = factory({
-        a: (s): number => {
+        a: (s) => {
             expectTypeOf(s).toEqualTypeOf<"a">();
+            assert.equal(s, "a");
             return 1;
         },
-        b: (s): 1 | 2 => {
+        b: (s) => {
             expectTypeOf(s).toEqualTypeOf<"b">();
+            assert.equal(s, "b");
             return 2;
         },
     });
@@ -49,10 +50,13 @@ test("getMatcher: dispatches on numeric literal keys", () => {
     const matcher = factory({
         1: (n) => {
             expectTypeOf(n).toEqualTypeOf<1>();
+            // A numeric key must not reach its handler as the string `"1"`.
+            assert.equal(n, 1);
             return n + 1;
         },
         2: (n) => {
             expectTypeOf(n).toEqualTypeOf<2>();
+            assert.equal(n, 2);
             return n * 10;
         },
     });
@@ -69,20 +73,24 @@ test("getMatcher: dispatches on mixed string and numeric keys", () => {
 
     // Act
     const matcher = factory({
-        a: (s): number => {
+        a: (s) => {
             expectTypeOf(s).toEqualTypeOf<"a">();
+            assert.equal(s, "a");
             return 1;
         },
-        b: (s): 1 | 2 => {
+        b: (s) => {
             expectTypeOf(s).toEqualTypeOf<"b">();
+            assert.equal(s, "b");
             return 2;
         },
-        1: (n): number => {
+        1: (n) => {
             expectTypeOf(n).toEqualTypeOf<1>();
+            assert.equal(n, 1);
             return 10;
         },
-        2: (n): number => {
+        2: (n) => {
             expectTypeOf(n).toEqualTypeOf<2>();
+            assert.equal(n, 2);
             return 20;
         },
     });
@@ -95,26 +103,80 @@ test("getMatcher: dispatches on mixed string and numeric keys", () => {
     assert.equal(matcher(2), 20);
 });
 
+test("getMatcher: dispatches on boolean literals", () => {
+    // Arrange
+    const factory = getMatcher<boolean>();
+
+    // Act
+    const matcher = factory({
+        true: (s) => {
+            expectTypeOf(s).toEqualTypeOf<true>();
+            // The `true` key is a property name; the handler must still be
+            // called with the boolean `true`, not the string `"true"`.
+            assert.equal(s, true);
+            return 1;
+        },
+        false: (s) => {
+            expectTypeOf(s).toEqualTypeOf<false>();
+            assert.equal(s, false);
+            return 2;
+        },
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<(shape: boolean) => number>();
+    assert.equal(matcher(true), 1);
+    assert.equal(matcher(false), 2);
+});
+
+test("getMatcher: dispatches on null and undefined", () => {
+    // Arrange
+    const factory = getMatcher<null | undefined>();
+
+    // Act
+    const matcher = factory({
+        null: (s) => {
+            expectTypeOf(s).toEqualTypeOf<null>();
+            assert.equal(s, null);
+            return "null";
+        },
+        undefined: (s) => {
+            expectTypeOf(s).toEqualTypeOf<undefined>();
+            assert.equal(s, undefined);
+            return "undefined";
+        },
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<(shape: null | undefined) => string>();
+    assert.equal(matcher(null), "null");
+    assert.equal(matcher(undefined), "undefined");
+});
+
 // ============================================================================
 // API: getMatcher — ❌ Exhaustive (fallback) / ✔️ ReturnsStrict
 // ============================================================================
 
-test("getMatcher: a `_` fallback makes the universe keys optional", () => {
+test("getMatcher: a `_` fallback receives the unhandled keys", () => {
     // Arrange
     const factory = getMatcher<"a" | "b" | "c">();
 
     // Act
-    const matcher = factory({
+    const matcher = factory(
-        a: (s): 1 | 2 => {
+        {
-            expectTypeOf(s).toEqualTypeOf<"a">();
+            a: (s) => {
-            return 1;
+                expectTypeOf(s).toEqualTypeOf<"a">();
+                assert.equal(s, "a");
+                return 1 as const;
+            },
         },
-        _: (s): 1 | 2 => {
+        (s) => {
-            // The fallback sees the whole union, not a single literal.
+            // The fallback sees only the keys `a` did not handle.
-            expectTypeOf(s).toEqualTypeOf<"a" | "b" | "c">();
+            expectTypeOf(s).toEqualTypeOf<"b" | "c">();
-            return 2;
+            assert.ok(s === "b" || s === "c");
+            return 2 as const;
         },
-    });
+    );
 
     // Assert
     expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b" | "c") => 1 | 2>();
@@ -125,47 +187,32 @@ test("getMatcher: a `_` fallback makes the universe keys optional", () => {
     assert.equal(matcher("c"), 2);
 });
 
-test("getMatcher: a `_` fallback also accepts an exhaustive pattern", () => {
-    // Arrange
-    const factory = getMatcher<"a" | "b">();
-
-    // Act
-    const matcher = factory({
-        a: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"a">();
-            return "A";
-        },
-        b: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"b">();
-            return "B";
-        },
-    });
-
-    // Assert
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b") => string>();
-    assert.equal(matcher("a"), "A");
-    assert.equal(matcher("b"), "B");
-});
-
 test("getMatcher: a `_` fallback routes mixed string and numeric gaps", () => {
     // Arrange
     const factory = getMatcher<"a" | "b" | 1 | 2>();
 
     // Act
-    const matcher = factory({
+    const matcher = factory(
-        a: (s): string => {
+        {
-            expectTypeOf(s).toEqualTypeOf<"a">();
+            a: (s) => {
-            return "A";
+                expectTypeOf(s).toEqualTypeOf<"a">();
+                assert.equal(s, "a");
+                return "A";
+            },
+            1: (n) => {
+                expectTypeOf(n).toEqualTypeOf<1>();
+                assert.equal(n, 1);
+                return "one";
+            },
         },
-        1: (n): string => {
+        (s) => {
-            expectTypeOf(n).toEqualTypeOf<1>();
+            expectTypeOf(s).toEqualTypeOf<"b" | 2>();
-            return "one";
+            // The gap mixes a string and a number, so the number must reach the
-        },
+            // fallback as `2`, never as its key text `"2"`.
-        _: (s): string => {
+            assert.ok(s === "b" || s === 2);
-            expectTypeOf(s).toEqualTypeOf<"a" | "b" | 1 | 2>();
             return "fallback";
         },
-    });
+    );
 
     // Assert
     expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b" | 1 | 2) => string>();
@@ -175,6 +222,44 @@ test("getMatcher: a `_` fallback routes mixed string and numeric gaps", () => {
     assert.equal(matcher(2), "fallback");
 });
 
+test("getMatcher: a `_` fallback receives unhandled boolean and nullish keys", () => {
+    // Arrange
+    const factory = getMatcher<"a" | true | false | null | undefined>();
+
+    // Act
+    const matcher = factory(
+        {
+            a: (s) => {
+                expectTypeOf(s).toEqualTypeOf<"a">();
+                assert.equal(s, "a");
+                return 1 as const;
+            },
+            null: (s) => {
+                expectTypeOf(s).toEqualTypeOf<null>();
+                assert.equal(s, null);
+                return 2 as const;
+            },
+        },
+        (s) => {
+            // `true` and `false` are keyed as `"true"`/`"false"` but the
+            // fallback still sees them as booleans.
+            expectTypeOf(s).toEqualTypeOf<true | false | undefined>();
+            assert.ok(s === true || s === false || s === undefined);
+            return 3 as const;
+        },
+    );
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<
+        (shape: "a" | true | false | null | undefined) => 1 | 2 | 3
+    >();
+    assert.equal(matcher("a"), 1);
+    assert.equal(matcher(true), 3);
+    assert.equal(matcher(false), 3);
+    assert.equal(matcher(null), 2);
+    assert.equal(matcher(undefined), 3);
+});
+
 // ============================================================================
 // API: getMatcherW — ✔️ Exhaustive / ❌ ReturnsStrict
 // ============================================================================
@@ -187,10 +272,12 @@ test("getMatcherW: exhaustive pattern widens to the union of handler returns", (
     const matcher = factory({
         x: (s) => {
             expectTypeOf(s).toEqualTypeOf<"x">();
+            assert.equal(s, "x");
             return 1 as const;
         },
         y: (s) => {
             expectTypeOf(s).toEqualTypeOf<"y">();
+            assert.equal(s, "y");
             return "two" as const;
         },
     });
@@ -212,18 +299,22 @@ test("getMatcherW: dispatches on mixed string and numeric keys", () => {
     const matcher = factory({
         a: (s) => {
             expectTypeOf(s).toEqualTypeOf<"a">();
+            assert.equal(s, "a");
             return "A" as const;
         },
         b: (s) => {
             expectTypeOf(s).toEqualTypeOf<"b">();
+            assert.equal(s, "b");
             return "B" as const;
         },
         1: (n) => {
             expectTypeOf(n).toEqualTypeOf<1>();
+            assert.equal(n, 1);
             return 10 as const;
         },
         2: (n) => {
             expectTypeOf(n).toEqualTypeOf<2>();
+            assert.equal(n, 2);
             return 20 as const;
         },
     });
@@ -238,6 +329,44 @@ test("getMatcherW: dispatches on mixed string and numeric keys", () => {
     assert.equal(matcher(2), 20);
 });
 
+test("getMatcherW: exhaustive boolean and nullish widen to the union", () => {
+    // Arrange
+    const factory = getMatcherW<boolean | null | undefined>();
+
+    // Act
+    const matcher = factory({
+        true: (s) => {
+            expectTypeOf(s).toEqualTypeOf<true>();
+            assert.equal(s, true);
+            return "yes" as const;
+        },
+        false: (s) => {
+            expectTypeOf(s).toEqualTypeOf<false>();
+            assert.equal(s, false);
+            return "no" as const;
+        },
+        null: (s) => {
+            expectTypeOf(s).toEqualTypeOf<null>();
+            assert.equal(s, null);
+            return 0 as const;
+        },
+        undefined: (s) => {
+            expectTypeOf(s).toEqualTypeOf<undefined>();
+            assert.equal(s, undefined);
+            return 1 as const;
+        },
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<
+        (shape: boolean | null | undefined) => "yes" | "no" | 0 | 1
+    >();
+    assert.equal(matcher(true), "yes");
+    assert.equal(matcher(false), "no");
+    assert.equal(matcher(null), 0);
+    assert.equal(matcher(undefined), 1);
+});
+
 // ============================================================================
 // API: getMatcherW — ❌ Exhaustive (fallback) / ❌ ReturnsStrict
 // ============================================================================
@@ -247,27 +376,32 @@ test("getMatcherW: a `_` fallback widens gaps into the union", () => {
     const factory = getMatcherW<"x" | "y" | "z">();
 
     // Act
-    const matcher = factory({
+    const matcher = factory(
-        x: (s) => {
+        {
-            expectTypeOf(s).toEqualTypeOf<"x">();
+            x: (s) => {
-            return 1 as const;
+                expectTypeOf(s).toEqualTypeOf<"x">();
+                assert.equal(s, "x");
+                return 1 as const;
+            },
         },
-        _: (s) => {
+        (s) => {
-            // The fallback sees the whole union, not a single literal.
+            // The fallback sees only the keys `x` did not handle.
-            expectTypeOf(s).toEqualTypeOf<"x" | "y" | "z">();
+            expectTypeOf(s).toEqualTypeOf<"y" | "z">();
-            return "fallback" as const;
+            // Returning the shape verbatim lets the `Assert` block check the
+            // exact value dispatch passed.
+            return s;
         },
-    });
+    );
 
     // Assert
     expectTypeOf(matcher).toEqualTypeOf<
-        (shape: "x" | "y" | "z") => 1 | "fallback"
+        (shape: "x" | "y" | "z") => 1 | "y" | "z"
     >();
     // ❌ a value outside T must not be accepted by the matcher
     expectTypeOf<"w">().not.toExtend<Parameters<typeof matcher>[0]>();
     assert.equal(matcher("x"), 1);
-    assert.equal(matcher("y"), "fallback");
+    assert.equal(matcher("y"), "y");
-    assert.equal(matcher("z"), "fallback");
+    assert.equal(matcher("z"), "z");
 });
 
 test("getMatcherW: a `_` fallback widens mixed string and numeric returns", () => {
@@ -275,52 +409,38 @@ test("getMatcherW: a `_` fallback widens mixed string and numeric returns", () =
     const factory = getMatcherW<"a" | "b" | 1 | 2>();
 
     // Act
-    const matcher = factory({
+    const matcher = factory(
-        a: (s) => {
+        {
-            expectTypeOf(s).toEqualTypeOf<"a">();
+            a: (s) => {
-            return "A" as const;
+                expectTypeOf(s).toEqualTypeOf<"a">();
+                assert.equal(s, "a");
+                return "A" as const;
+            },
+            1: (n) => {
+                expectTypeOf(n).toEqualTypeOf<1>();
+                assert.equal(n, 1);
+                return 10 as const;
+            },
         },
-        1: (n) => {
+        (s) => {
-            expectTypeOf(n).toEqualTypeOf<1>();
+            expectTypeOf(s).toEqualTypeOf<"b" | 2>();
-            return 10 as const;
+            // The number must arrive as `2`, not as its key text `"2"`.
+            assert.ok(s === "b" || s === 2);
+            // Returning the shape verbatim lets the `Assert` block check the
+            // exact value dispatch passed.
+            return s;
         },
-        _: (s) => {
+    );
-            expectTypeOf(s).toEqualTypeOf<"a" | "b" | 1 | 2>();
-            return "fallback" as const;
-        },
-    });
 
     // Assert
     // ❌ ReturnsStrict: mixed handler returns widen to their union.
     expectTypeOf(matcher).toEqualTypeOf<
-        (shape: "a" | "b" | 1 | 2) => "A" | 10 | "fallback"
+        (shape: "a" | "b" | 1 | 2) => "A" | 10 | "b" | 2
     >();
     assert.equal(matcher("a"), "A");
-    assert.equal(matcher("b"), "fallback");
+    assert.equal(matcher("b"), "b");
     assert.equal(matcher(1), 10);
-    assert.equal(matcher(2), "fallback");
+    assert.equal(matcher(2), 2);
-});
-
-test("getMatcherW: a `_` fallback also accepts an exhaustive pattern", () => {
-    // Arrange
-    const factory = getMatcherW<"x" | "y">();
-
-    // Act
-    const matcher = factory({
-        x: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"x">();
-            return 1 as const;
-        },
-        y: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"y">();
-            return "two" as const;
-        },
-    });
-
-    // Assert
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "x" | "y") => 1 | "two">();
-    assert.equal(matcher("x"), 1);
-    assert.equal(matcher("y"), "two");
 });
 
 // ============================================================================
@@ -341,8 +461,55 @@ test("getMatcher factory rejects patterns outside its contract", () => {
         // @ts-expect-error `c` is not part of the universe `"a" | "b"`
         c: () => 3,
     });
-    // @ts-expect-error a gap without `_` is not exhaustive
+    // @ts-expect-error a gap without a `_` fallback is not exhaustive
     factory({ a: () => 1 });
+    // @ts-expect-error a `string` fallback does not fit the `number` handler
+    factory({ a: () => 1 }, () => "x");
+    // @ts-expect-error a fallback is redundant once the map covers the universe
+    factory({ a: () => 1, b: () => 2 }, () => 0);
+});
+
+test("getMatcher factory rejects non-exhaustive boolean and nullish maps", () => {
+    // Arrange
+    const factory = getMatcher<boolean | null | undefined>();
+
+    // Act / Assert — the calls below must not compile
+    // @ts-expect-error only `true` is handled; `false`, `null`, `undefined` are not
+    factory({ true: () => 1 });
+    // @ts-expect-error `null` and `undefined` are not handled
+    factory({ true: () => 1, false: () => 2 });
+    factory(
+        // @ts-expect-error a fallback is redundant once the map covers the universe
+        {
+            true: () => 1,
+            false: () => 2,
+            null: () => 3,
+            undefined: () => 4,
+        },
+        () => 0,
+    );
+});
+
+test("getMatcher: an open universe keeps the fallback's remainder open", () => {
+    // Arrange
+    const factory = getMatcher<string>();
+
+    // Act
+    const matcher = factory({ a: () => 1 }, (s) => {
+        // The map's literal keys do not close an open universe, so the
+        // remainder stays `string` and the fallback is not redundant.
+        expectTypeOf(s).toEqualTypeOf<string>();
+        // A strict pattern fixes one `R` for every handler, so this fallback
+        // cannot return its shape; `typeof` is the strongest claim the value
+        // makes on its own — any string passes, including `""`.
+        assert.equal(typeof s, "string");
+        return 2 as const;
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<(shape: string) => number>();
+    assert.equal(matcher("a"), 1);
+    assert.equal(matcher("b"), 2);
 });
 
 test("getMatcherW factory rejects patterns outside its contract", () => {
@@ -350,14 +517,55 @@ test("getMatcherW factory rejects patterns outside its contract", () => {
     const factory = getMatcherW<"x" | "y">();
 
     // Act / Assert — the calls below must not compile
-    // @ts-expect-error `z` is not part of the universe `"x" | "y"`
     factory({
         x: () => 1 as const,
         y: () => 2 as const,
+        // @ts-expect-error `z` is not part of the universe `"x" | "y"`
         z: () => 3 as const,
     });
-    // @ts-expect-error a gap without `_` is not exhaustive
+    // @ts-expect-error a gap without a `_` fallback is not exhaustive
     factory({ x: () => 1 as const });
+    // @ts-expect-error a fallback is redundant once the map covers the universe
+    factory({ x: () => 1 as const, y: () => 2 as const }, () => 0);
+});
+
+// ============================================================================
+// Dispatch — runtime behavior
+// ============================================================================
+
+test("getMatcher: an unhandled shape throws without a fallback", () => {
+    // Arrange — an open universe types its handler map as an index signature,
+    // so the type system cannot prove the runtime map is exhaustive.
+    const handlers: Record<string, (shape: unknown) => number> = {
+        a: (shape) => {
+            // The raw shape reaches the handler, not the property key's text.
+            assert.equal(shape, "a");
+            return 1;
+        },
+    };
+    const matcher = getMatcher<string>()(handlers);
+
+    // Act / Assert
+    assert.equal(matcher("a"), 1);
+    assert.throws(() => matcher("b"), /Unhandled shape: b/);
+});
+
+test("getMatcher: an unhandled boolean shape throws without a fallback", () => {
+    // Arrange — an `string | boolean` universe widens its handler map to an
+    // index signature, so the runtime map's exhaustiveness is not provable.
+    const handlers: Record<string, (shape: unknown) => number> = {
+        true: (shape) => {
+            // `true` indexes the map as the property `"true"`, but the handler
+            // is still called with the boolean.
+            assert.equal(shape, true);
+            return 1;
+        },
+    };
+    const matcher = getMatcher<string | boolean>()(handlers);
+
+    // Act / Assert
+    assert.equal(matcher(true), 1);
+    assert.throws(() => matcher(false), /Unhandled shape: false/);
 });
 
 // ============================================================================
@@ -374,19 +582,29 @@ const UNIVERSE = `"a" | "b" | "c"`;
 
 // One session per probe: the tests share no language-server state (open
 // documents, project membership), so they pass in any order.
-const labelsFor = (
+interface LabelsProbe {
-    name: string,
+    readonly name: string;
-    factory: "getMatcher" | "getMatcherW",
+    readonly factory: "getMatcher" | "getMatcherW";
-    body: string,
+    readonly body: string;
-): Promise<readonly string[]> => {
+    readonly universe?: string;
+    readonly tail?: string;
+}
+
+const labelsFor = ({
+    name,
+    factory,
+    body,
+    universe = UNIVERSE,
+    tail = "",
+}: LabelsProbe): Promise<readonly string[]> => {
     const session = new LspSession(REPO_ROOT);
     const target: CompletionTarget = {
         file: `src/__autocomplete_${name}.ts`,
         source: [
             `import { ${factory} } from "./index.ts";`,
-            `const m = ${factory}<${UNIVERSE}>()({`,
+            `const m = ${factory}<${universe}>()({`,
             body,
-            "});",
+            `}${tail});`,
             "",
         ].join("\n"),
     };
@@ -396,16 +614,20 @@ const labelsFor = (
         .finally(() => session.close());
 };
 
-test("autocomplete: an exhaustive pattern requires the universe, `_` optional", () => {
+test("autocomplete: an exhaustive pattern requires the universe", () => {
     // Arrange
     const name = "getMatcher_fresh";
 
     // Act
-    const labels = labelsFor(name, "getMatcher", "    /*COMPLETE*/");
+    const labels = labelsFor({
+        name,
+        factory: "getMatcher",
+        body: "    /*COMPLETE*/",
+    });
 
     // Assert
     return labels.then((result) => {
-        assert.deepEqual([...result], ["_?", "a", "b", "c"]);
+        assert.deepEqual([...result], ["a", "b", "c"]);
     });
 });
 
@@ -414,28 +636,29 @@ test("autocomplete: handled keys drop out of the popup", () => {
     const name = "getMatcher_after_key";
 
     // Act
-    const labels = labelsFor(
+    const labels = labelsFor({
         name,
-        "getMatcher",
+        factory: "getMatcher",
-        "    a: () => 1,\n    /*COMPLETE*/",
+        body: "    a: () => 1,\n    /*COMPLETE*/",
-    );
+    });
 
     // Assert
     return labels.then((result) => {
-        assert.deepEqual([...result], ["_?", "b", "c"]);
+        assert.deepEqual([...result], ["b", "c"]);
     });
 });
 
-test("autocomplete: `_` makes the remaining keys optional", () => {
+test("autocomplete: a fallback makes the remaining keys optional", () => {
     // Arrange
-    const name = "getMatcher_after_fallback";
+    const name = "getMatcher_with_fallback";
 
     // Act
-    const labels = labelsFor(
+    const labels = labelsFor({
         name,
-        "getMatcher",
+        factory: "getMatcher",
-        "    _: () => 0,\n    /*COMPLETE*/",
+        body: "    /*COMPLETE*/",
-    );
+        tail: ", () => 0",
+    });
 
     // Assert
     return labels.then((result) => {
@@ -443,15 +666,91 @@ test("autocomplete: `_` makes the remaining keys optional", () => {
     });
 });
 
+test("autocomplete: with a fallback, handled keys stay optional", () => {
+    // Arrange
+    const name = "getMatcher_with_fallback_after_key";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getMatcher",
+        body: "    a: () => 1,\n    /*COMPLETE*/",
+        tail: ", () => 0",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["b?", "c?"]);
+    });
+});
+
 test("autocomplete: `getMatcherW` offers the same popup as `getMatcher`", () => {
     // Arrange
     const name = "getMatcherW_fresh";
 
     // Act
-    const labels = labelsFor(name, "getMatcherW", "    /*COMPLETE*/");
+    const labels = labelsFor({
+        name,
+        factory: "getMatcherW",
+        body: "    /*COMPLETE*/",
+    });
 
     // Assert
     return labels.then((result) => {
-        assert.deepEqual([...result], ["_?", "a", "b", "c"]);
+        assert.deepEqual([...result], ["a", "b", "c"]);
+    });
+});
+
+test("autocomplete: `getMatcherW` also offers optional keys with a fallback", () => {
+    // Arrange
+    const name = "getMatcherW_with_fallback";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getMatcherW",
+        body: "    /*COMPLETE*/",
+        tail: ", () => 0",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["a?", "b?", "c?"]);
+    });
+});
+
+test("autocomplete: boolean and nullish keys are offered by name", () => {
+    // Arrange
+    const name = "getMatcher_boolean_nullish";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getMatcher",
+        universe: "boolean | null | undefined",
+        body: "    /*COMPLETE*/",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["false", "null", "true", "undefined"]);
+    });
+});
+
+test("autocomplete: a handled boolean literal drops out of the popup", () => {
+    // Arrange
+    const name = "getMatcher_boolean_after_key";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getMatcher",
+        universe: "boolean | null | undefined",
+        body: "    true: () => 1,\n    /*COMPLETE*/",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["false", "null", "undefined"]);
     });
 });

src/primitive.ts

@@ -1,63 +1,128 @@
-import type { ValueOf } from "type-fest";
+import type { Exact } from "type-fest";
 
-type UnaryFn<T, R> = (shape: T) => R;
+import type {
+    HandlerMap,
+    PatternReturns,
+    RedundantFallback,
+    UnaryFn,
+} from "./matcher-shared.ts";
 
-// `Extract` drops optional handlers (`undefined`) so `PatternReturns` also works
+// The primitive universe a matcher can discriminate. `boolean` is admitted as
-// when `P`'s constraint has optional keys.
+// the pair `true | false`; see README § Caveats for the unsupported members.
-type PatternReturns<P> = ReturnType<
+type Matchable = string | number | boolean | null | undefined;
-    Extract<ValueOf<P>, (...args: never[]) => unknown>
+
+// `boolean`, `null` and `undefined` cannot be property keys, so a mapped type
+// over the universe keys each non-key member by its stringification. `Param`
+// inverts that projection, so a handler callback still receives the *real*
+// member (`true`, not `"true"`) — see README § Caveats for the limits.
+type PatternKey<T> = T extends boolean
+    ? T extends true
+        ? "true"
+        : "false"
+    : T extends null
+      ? "null"
+      : T extends undefined
+        ? "undefined"
+        : T;
+type PatternParam<K> = K extends "true"
+    ? true
+    : K extends "false"
+      ? false
+      : K extends "null"
+        ? null
+        : K extends "undefined"
+          ? undefined
+          : K;
+
+type Handlers<T extends Matchable, R> = {
+    [K in PatternKey<T>]: UnaryFn<PatternParam<K>, R>;
+};
+
+// The fallback is a *second argument*, not a property of the handler map,
+// because its parameter is the remainder `Exclude<T, keyof Handled>` and TypeScript
+// fixes a property's contextual type before it infers its sibling keys. A later
+// argument, by contrast, is contextually typed from inference on an earlier
+// one, so the split is what makes the remainder expressible at all.
+// See development/library.md.
+type Fallback<T extends Matchable, Handled, R> = UnaryFn<
+    Exclude<T, PatternParam<keyof Handled>>,
+    R
 >;
 
-type Handlers<R, T extends string | number> = { [K in T]: UnaryFn<K, R> };
+// A fallback is redundant once the handler map covers `T`. The guard is folded
+// into `Handled`'s own (self-referential) constraint so it is checked *after*
+// inference; a conditional in the fallback's parameter type is evaluated while
+// `Handled` is still its constraint and would reject context-sensitive partial
+// maps. That placement also fixes where the diagnostic lands: the constraint
+// failure is reported on the argument that inferred `Handled` (the handler
+// map), so the required property is spelled as the message instead of relying
+// on its position. See development/library.md.
+type MustBePartial<T extends Matchable, Handled> =
+    PatternKey<T> extends keyof Handled ? RedundantFallback : unknown;
 
-// Fallback form: `_` is a required key, the T-keys are optional.
+// TypeScript does not apply the excess-property check to a generic constraint,
-type Fallback<R, T extends string | number> = Partial<Handlers<R, T>> & {
+// so `Exact` restores it for the generic forms: a handler map can otherwise
-    _: UnaryFn<T, R>;
+// carry keys outside `T`.
-};
-
-// Completion form: T-keys required, `_` optional. Overload #1, because
-// TypeScript takes the *first* overload as the contextual type for the popup.
-type ExhaustiveLoose<R, T extends string | number> = Handlers<R, T> & {
-    _?: UnaryFn<T, R>;
-};
 
 // oxlint-disable typescript/unified-signatures
 // Strict returns: one common `R`. Overload order is load-bearing:
-//   #1 ExhaustiveLoose -> autocomplete `_?, a, b`
+//   #1 Handlers (first) -> the exhaustive form and the autocomplete popup
-//   #2 Fallback        -> accepts a partial pattern
+//   #2 Fallback (last)  -> accepts a partial handler map plus a fallback
-//   #3 Handlers (last) -> "Property 'b' is missing" is the reported error
+interface MatcherStrict<T extends Matchable> {
-interface MatcherStrict<T extends string | number> {
+    <R>(handlers: Handlers<T, R>): UnaryFn<T, R>;
-    <R>(pattern: ExhaustiveLoose<R, T>): UnaryFn<T, R>;
+    <
-    <R>(pattern: Fallback<R, T>): UnaryFn<T, R>;
+        R,
-    <R>(pattern: Handlers<R, T>): UnaryFn<T, R>;
+        Handled extends Exact<Partial<Handlers<T, R>>, Handled> &
+            MustBePartial<T, Handled>,
+    >(
+        handlers: Handled & Partial<Handlers<T, R>>,
+        fallback: Fallback<T, Handled, R>,
+    ): UnaryFn<T, R>;
 }
 // oxlint-enable typescript/unified-signatures
 
 // Widened returns: the union of every handler's return type. `P` is inferred
-// from the whole parameter, whose closed constraint supplies the
+// from the whole handler map, whose closed constraint supplies the
-// contextual/autocomplete type; the `keyof P` guard appended to each overload
+// contextual/autocomplete type.
-// rejects keys outside `T`/`_`.
+// oxlint-disable typescript/unified-signatures
-interface MatcherWidening<T extends string | number> {
+interface MatcherWidening<T extends Matchable> {
-    <P extends ExhaustiveLoose<unknown, T>>(
+    <P extends Exact<Handlers<T, unknown>, P>>(
-        pattern: P & (keyof P extends T | "_" ? unknown : never),
+        handlers: P,
-    ): UnaryFn<T, PatternReturns<P>>;
-    <P extends Fallback<unknown, T>>(
-        pattern: P & (keyof P extends T | "_" ? unknown : never),
-    ): UnaryFn<T, PatternReturns<P>>;
-    <P extends Handlers<unknown, T>>(
-        pattern: P & (keyof P extends T | "_" ? unknown : never),
     ): UnaryFn<T, PatternReturns<P>>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, unknown>>, Handled> &
+            MustBePartial<T, Handled>,
+    >(
+        handlers: Handled,
+        fallback: Fallback<T, Handled, R>,
+    ): UnaryFn<T, PatternReturns<Handled> | R>;
 }
-
+// oxlint-enable typescript/unified-signatures
-type HandlerMap = Record<string | number, UnaryFn<never, unknown> | undefined>;
 
 const dispatch =
-    (pattern: HandlerMap) =>
+    (handlers: HandlerMap, fallback?: UnaryFn<never, unknown>) =>
-    (shape: string | number): unknown =>
+    (shape: Matchable): unknown =>
-        // oxlint-disable-next-line typescript/no-non-null-assertion typescript/no-unsafe-type-assertion
+        // `handlers[true]` already coerces to the `"true"` property at runtime,
-        (pattern[shape] ?? pattern["_"]!)(shape as never);
+        // identical to `handlers[String(shape)]`, so indexing with `shape`
+        // directly is sound: `shape` is a facade-checked universe member and
+        // `PatternKey` only ever produces valid property keys. The assertion is
+        // needed solely because TypeScript forbids indexing with
+        // `boolean`/`null`/`undefined` (TS2538); it buys the number fast path.
+        (
+            handlers[
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+                shape as string | number
+            ] ??
+            fallback ??
+            (() => {
+                throw new Error(`Unhandled shape: ${String(shape)}`);
+            })
+        )(
+            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+            shape as never,
+        );
 
-export const getMatcher = <T extends string | number>(): MatcherStrict<T> =>
+export const getMatcher = <T extends Matchable>(): MatcherStrict<T> => dispatch;
-    dispatch;
+export const getMatcherW = <T extends Matchable>(): MatcherWidening<T> =>
-export const getMatcherW = <T extends string | number>(): MatcherWidening<T> =>
     dispatch;

src/tagged-union.test.ts

@@ -0,0 +1,452 @@
+import { strict as assert } from "node:assert";
+import path from "node:path";
+import { test } from "node:test";
+
+import { expectTypeOf } from "expect-type";
+
+import {
+    type CompletionTarget,
+    LspSession,
+} from "#test-utils/lsp-completion.ts";
+
+import {
+    getTaggedUnionMatcher,
+    getTaggedUnionMatcherW,
+} from "./tagged-union.ts";
+
+interface Circle {
+    readonly kind: "circle";
+    readonly radius: number;
+}
+interface Square {
+    readonly kind: "square";
+    readonly side: number;
+}
+interface Triangle {
+    readonly kind: "triangle";
+    readonly base: number;
+    readonly height: number;
+}
+type Shape = Circle | Square | Triangle;
+
+// ============================================================================
+// API: getTaggedUnionMatcher — ✔️ Exhaustive / ✔️ ReturnsStrict
+// ============================================================================
+
+test("getTaggedUnionMatcher: exhaustive pattern infers one common return type", () => {
+    // Arrange
+    const factory = getTaggedUnionMatcher<Shape>()("kind");
+
+    // Act
+    const area = factory({
+        circle: (s) => {
+            // Each handler receives the member its tag selects, not the union.
+            expectTypeOf(s).toEqualTypeOf<Circle>();
+            assert.equal(s.kind, "circle");
+            return Math.PI * s.radius ** 2;
+        },
+        square: (s) => {
+            expectTypeOf(s).toEqualTypeOf<Square>();
+            assert.equal(s.kind, "square");
+            return s.side ** 2;
+        },
+        triangle: (s) => {
+            expectTypeOf(s).toEqualTypeOf<Triangle>();
+            assert.equal(s.kind, "triangle");
+            return (s.base * s.height) / 2;
+        },
+    });
+
+    // Assert
+    // ✔️ ReturnsStrict: R is the best common return type, not a widening union.
+    expectTypeOf(area).toEqualTypeOf<(shape: Shape) => number>();
+    assert.equal(area({ kind: "square", side: 2 }), 4);
+    assert.equal(area({ kind: "triangle", base: 2, height: 3 }), 3);
+});
+
+test("getTaggedUnionMatcher: dispatches on numeric tags", () => {
+    // Arrange
+    type Version =
+        | { readonly kind: 1; readonly a: number }
+        | {
+              readonly kind: 2;
+              readonly b: number;
+          };
+    const factory = getTaggedUnionMatcher<Version>()("kind");
+
+    // Act
+    const pick = factory({
+        1: (v) => {
+            expectTypeOf(v).toEqualTypeOf<{
+                readonly kind: 1;
+                readonly a: number;
+            }>();
+            assert.equal(v.kind, 1);
+            return v.a;
+        },
+        2: (v) => {
+            expectTypeOf(v).toEqualTypeOf<{
+                readonly kind: 2;
+                readonly b: number;
+            }>();
+            assert.equal(v.kind, 2);
+            return v.b;
+        },
+    });
+
+    // Assert
+    expectTypeOf(pick).toEqualTypeOf<(shape: Version) => number>();
+    assert.equal(pick({ kind: 1, a: 10 }), 10);
+    assert.equal(pick({ kind: 2, b: 20 }), 20);
+});
+
+// ============================================================================
+// API: getTaggedUnionMatcher — ❌ Exhaustive (fallback) / ✔️ ReturnsStrict
+// ============================================================================
+
+test("getTaggedUnionMatcher: a fallback receives the unhandled members", () => {
+    // Arrange
+    const factory = getTaggedUnionMatcher<Shape>()("kind");
+
+    // Act
+    const area = factory(
+        {
+            circle: (s) => {
+                expectTypeOf(s).toEqualTypeOf<Circle>();
+                assert.equal(s.kind, "circle");
+                return 1 as const;
+            },
+        },
+        (s) => {
+            // The fallback sees only the members `circle` did not handle.
+            expectTypeOf(s).toEqualTypeOf<Square | Triangle>();
+            assert.ok(s.kind === "square" || s.kind === "triangle");
+            return 2 as const;
+        },
+    );
+
+    // Assert
+    expectTypeOf(area).toEqualTypeOf<(shape: Shape) => 1 | 2>();
+    assert.equal(area({ kind: "circle", radius: 1 }), 1);
+    assert.equal(area({ kind: "square", side: 1 }), 2);
+    assert.equal(area({ kind: "triangle", base: 1, height: 1 }), 2);
+});
+
+test("getTaggedUnionMatcher: an open discriminant keeps the fallback open", () => {
+    // Arrange
+    interface Message {
+        readonly kind: string;
+        readonly text: string;
+    }
+    const factory = getTaggedUnionMatcher<Message>()("kind");
+
+    // Act
+    const matcher = factory({ info: () => 1 as const }, (s) => {
+        // The map's literal key does not close an open discriminant, so the
+        // remainder stays `Message` and the fallback is not redundant.
+        expectTypeOf(s).toEqualTypeOf<Message>();
+        assert.equal(typeof s.text, "string");
+        return 2 as const;
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<(shape: Message) => 1 | 2>();
+    assert.equal(matcher({ kind: "info", text: "" }), 1);
+    assert.equal(matcher({ kind: "warn", text: "" }), 2);
+});
+
+// ============================================================================
+// API: getTaggedUnionMatcherW — ✔️ Exhaustive / ❌ ReturnsStrict
+// ============================================================================
+
+test("getTaggedUnionMatcherW: exhaustive pattern widens to the union of returns", () => {
+    // Arrange
+    const factory = getTaggedUnionMatcherW<Shape>()("kind");
+
+    // Act
+    const describe = factory({
+        circle: (s) => {
+            expectTypeOf(s).toEqualTypeOf<Circle>();
+            assert.equal(s.kind, "circle");
+            return "round" as const;
+        },
+        square: (s) => {
+            expectTypeOf(s).toEqualTypeOf<Square>();
+            assert.equal(s.kind, "square");
+            return 4 as const;
+        },
+        triangle: (s) => {
+            expectTypeOf(s).toEqualTypeOf<Triangle>();
+            assert.equal(s.kind, "triangle");
+            return true as const;
+        },
+    });
+
+    // Assert
+    // ❌ ReturnsStrict: mixed handler returns widen to their union.
+    expectTypeOf(describe).toEqualTypeOf<
+        (shape: Shape) => "round" | 4 | true
+    >();
+    assert.equal(describe({ kind: "circle", radius: 1 }), "round");
+    assert.equal(describe({ kind: "square", side: 1 }), 4);
+    assert.equal(describe({ kind: "triangle", base: 1, height: 1 }), true);
+});
+
+// ============================================================================
+// API: getTaggedUnionMatcherW — ❌ Exhaustive (fallback) / ❌ ReturnsStrict
+// ============================================================================
+
+test("getTaggedUnionMatcherW: a fallback widens gaps into the union", () => {
+    // Arrange
+    const factory = getTaggedUnionMatcherW<Shape>()("kind");
+
+    // Act
+    const matcher = factory({ circle: () => 1 as const }, (s) => {
+        expectTypeOf(s).toEqualTypeOf<Square | Triangle>();
+        // Returning the member verbatim lets the `Assert` block check the
+        // exact value dispatch passed.
+        return s;
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<
+        (shape: Shape) => 1 | Square | Triangle
+    >();
+    assert.equal(matcher({ kind: "circle", radius: 1 }), 1);
+    assert.deepEqual(matcher({ kind: "square", side: 1 }), {
+        kind: "square",
+        side: 1,
+    });
+    assert.deepEqual(matcher({ kind: "triangle", base: 1, height: 1 }), {
+        kind: "triangle",
+        base: 1,
+        height: 1,
+    });
+});
+
+// ============================================================================
+// Factory contracts — calls that must not compile
+// ============================================================================
+
+test("getTaggedUnionMatcher factory rejects patterns outside its contract", () => {
+    // Arrange
+    const factory = getTaggedUnionMatcher<Shape>()("kind");
+
+    // Act / Assert — the calls below must not compile
+    factory({
+        circle: () => 1,
+        square: () => 2,
+        triangle: () => 3,
+        // @ts-expect-error `hexagon` is not a tag of Shape
+        hexagon: () => 4,
+    });
+    // @ts-expect-error a gap without a fallback is not exhaustive
+    factory({ circle: () => 1 });
+    // @ts-expect-error a `string` fallback does not fit the `number` handlers
+    factory({ circle: () => 1 }, () => "x");
+    // @ts-expect-error a fallback is redundant once the map covers the union
+    factory({ circle: () => 1, square: () => 2, triangle: () => 3 }, () => 0);
+});
+
+test("getTaggedUnionMatcher factory rejects a non-discriminant key", () => {
+    // Arrange
+    type Mixed =
+        | { readonly id: Date; readonly kind: "a" }
+        | { readonly id: Date; readonly kind: "b" };
+
+    // Act / Assert — the calls below must not compile
+    // @ts-expect-error `id` is a common key but its value is not a tag
+    getTaggedUnionMatcher<Mixed>()("id");
+    getTaggedUnionMatcher<Mixed>()("kind");
+});
+
+test("getTaggedUnionMatcherW factory rejects patterns outside its contract", () => {
+    // Arrange
+    const factory = getTaggedUnionMatcherW<Shape>()("kind");
+
+    // Act / Assert — the calls below must not compile
+    factory({
+        circle: () => 1 as const,
+        square: () => 2 as const,
+        triangle: () => 3 as const,
+        // @ts-expect-error `hexagon` is not a tag of Shape
+        hexagon: () => 4 as const,
+    });
+    // @ts-expect-error a gap without a fallback is not exhaustive
+    factory({ circle: () => 1 as const });
+    factory(
+        // @ts-expect-error a fallback is redundant once the map covers the union
+        {
+            circle: () => 1 as const,
+            square: () => 2 as const,
+            triangle: () => 3 as const,
+        },
+        () => 0,
+    );
+});
+
+// ============================================================================
+// Dispatch — runtime behavior
+// ============================================================================
+
+test("getTaggedUnionMatcher: an unhandled tag throws without a fallback", () => {
+    // Arrange — an open discriminant widens its handler map to an index
+    // signature, so the type system cannot prove the runtime map is exhaustive.
+    interface Message {
+        readonly kind: string;
+    }
+    const handlers: Record<string, (shape: Message) => number> = {
+        info: (shape) => {
+            // The full member reaches the handler, not its tag.
+            assert.equal(shape.kind, "info");
+            return 1;
+        },
+    };
+    const matcher = getTaggedUnionMatcher<Message>()("kind")(handlers);
+
+    // Act / Assert
+    assert.equal(matcher({ kind: "info" }), 1);
+    assert.throws(() => matcher({ kind: "warn" }), /Unhandled tag: warn/);
+});
+
+// ============================================================================
+// Autocomplete — the language server is the oracle, not the type system
+// ============================================================================
+
+const REPO_ROOT = path.resolve(import.meta.dirname, "..");
+const SHAPE_SOURCE = `type Shape = { kind: "a"; a: number } | { kind: "b"; b: number } | { kind: "c"; c: number };`;
+
+interface LabelsProbe {
+    readonly name: string;
+    readonly factory: "getTaggedUnionMatcher" | "getTaggedUnionMatcherW";
+    readonly body: string;
+    readonly tail?: string;
+}
+
+const labelsFor = ({
+    name,
+    factory,
+    body,
+    tail = "",
+}: LabelsProbe): Promise<readonly string[]> => {
+    const session = new LspSession(REPO_ROOT);
+    const target: CompletionTarget = {
+        file: `src/__autocomplete_${name}.ts`,
+        source: [
+            `import { ${factory} } from "./index.ts";`,
+            SHAPE_SOURCE,
+            `const m = ${factory}<Shape>()("kind")({`,
+            body,
+            `}${tail});`,
+            "",
+        ].join("\n"),
+    };
+    return session
+        .completionLabelsAt(target)
+        .then((result) => result.labels)
+        .finally(() => session.close());
+};
+
+test("autocomplete: a tagged-union pattern requires the tags", () => {
+    // Arrange
+    const name = "tagged_union_fresh";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getTaggedUnionMatcher",
+        body: "    /*COMPLETE*/",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["a", "b", "c"]);
+    });
+});
+
+test("autocomplete: a handled tag drops out of the popup", () => {
+    // Arrange
+    const name = "tagged_union_after_key";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getTaggedUnionMatcher",
+        body: "    a: () => 1,\n    /*COMPLETE*/",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["b", "c"]);
+    });
+});
+
+test("autocomplete: a fallback makes the remaining tags optional", () => {
+    // Arrange
+    const name = "tagged_union_with_fallback";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getTaggedUnionMatcher",
+        body: "    /*COMPLETE*/",
+        tail: ", () => 0",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["a?", "b?", "c?"]);
+    });
+});
+
+// `Mixed` has two common keys, but `id`'s value is not a tag, so only `kind`
+// may serve as the discriminant.
+const MIXED_SOURCE = `type Mixed = { id: Date; kind: "a"; a: number } | { id: Date; kind: "b"; b: number };`;
+
+const discriminantLabelsFor = ({
+    name,
+    factory,
+    typeName,
+    typeSource,
+}: {
+    readonly name: string;
+    readonly factory: "getTaggedUnionMatcher" | "getTaggedUnionMatcherW";
+    readonly typeName: string;
+    readonly typeSource: string;
+}): Promise<readonly string[]> => {
+    const session = new LspSession(REPO_ROOT);
+    const target: CompletionTarget = {
+        file: `src/__autocomplete_${name}.ts`,
+        source: [
+            `import { ${factory} } from "./index.ts";`,
+            typeSource,
+            `const m = ${factory}<${typeName}>()(/*COMPLETE*/);`,
+            "",
+        ].join("\n"),
+    };
+    return session
+        .completionLabelsAt(target)
+        .then((result) => result.labels)
+        .finally(() => session.close());
+};
+
+test("autocomplete: the discriminant key is offered at the key argument", () => {
+    // Arrange
+    const name = "tagged_union_discriminant";
+
+    // Act
+    const labels = discriminantLabelsFor({
+        name,
+        factory: "getTaggedUnionMatcher",
+        typeName: "Mixed",
+        typeSource: MIXED_SOURCE,
+    });
+
+    // Assert
+    return labels.then((result) => {
+        // The argument position also offers every global identifier, so assert
+        // inclusion of the discriminant and exclusion of the non-tag key.
+        assert.ok(result.includes('"kind"'));
+        assert.ok(!result.includes('"id"'));
+    });
+});

src/tagged-union.ts

@@ -0,0 +1,124 @@
+import type { Exact, UnknownRecord } from "type-fest";
+
+import type {
+    HandlerMap,
+    PatternReturns,
+    RedundantFallback,
+    UnaryFn,
+} from "./matcher-shared.ts";
+
+// A tagged union is discriminated by one property whose values are the tags.
+// Only `string` and `number` tags can key a handler map: `symbol` has no
+// literal syntax to write a handler under, and `bigint` is not a property key.
+type Tag = string | number;
+
+// The discriminant values of `T` under `K`. `Extract` keeps the finite literal
+// tags and leaves a widened `string`/`number` as itself, so an open universe
+// keeps an open fallback.
+type Tags<T extends object, K extends keyof T> = Extract<T[K], Tag>;
+
+// The keys of `T` that can act as a discriminant. `getTaggedUnionMatcher<T>()`
+// accepts only these, so the factory rejects a key whose values are not tags.
+type Discriminated<T extends object> = {
+    [K in keyof T]: T[K] extends Tag ? K : never;
+}[keyof T];
+
+// The member(s) of `T` tagged `V`. `Extract` distributes over the union, so a
+// duplicated tag maps to a union of members rather than silently dropping one.
+type MapTaggedUnion<T extends object, K extends keyof T> = {
+    [V in Tags<T, K>]: Extract<T, Record<K, V>>;
+};
+
+type Handlers<T extends object, K extends keyof T, R> = {
+    [V in Tags<T, K>]: UnaryFn<MapTaggedUnion<T, K>[V], R>;
+};
+
+// The members `Handled` covers. Mapping over `Tags` keeps every index within
+// `MapTaggedUnion`'s keys, and the conditional drops a stray key outside `T` so
+// it cannot widen the remainder. The remainder is `Exclude<T, …>`, mirroring
+// the primitive matcher's `Exclude<T, PatternParam<keyof Handled>>`.
+type HandledMembers<T extends object, K extends keyof T, Handled> = {
+    [V in Tags<T, K>]: V extends keyof Handled
+        ? MapTaggedUnion<T, K>[V]
+        : never;
+}[Tags<T, K>];
+
+// The fallback is a *second argument*, not a property of the handler map, so
+// its parameter can be the remainder the map left open. See development/library.md.
+type Fallback<T extends object, K extends keyof T, Handled, R> = UnaryFn<
+    Exclude<T, HandledMembers<T, K, Handled>>,
+    R
+>;
+
+// A fallback is redundant once the handler map covers every tag of `T`. Folded
+// into `Handled`'s own (self-referential) constraint so it is checked *after*
+// inference; see the primitive matcher for why a conditional in the fallback's
+// parameter is evaluated too early.
+type MustBePartial<T extends object, K extends keyof T, Handled> =
+    Tags<T, K> extends keyof Handled ? RedundantFallback : unknown;
+
+// TypeScript does not apply the excess-property check to a generic constraint,
+// so `Exact` restores it for the generic forms.
+
+// Strict returns: one common `R`. Overload order is load-bearing:
+//   #1 Handlers (first) -> the exhaustive form and the autocomplete popup
+//   #2 Fallback (last)  -> accepts a partial handler map plus a fallback
+interface TaggedUnionMatcherStrict<T extends object, K extends keyof T> {
+    <R>(handlers: Handlers<T, K, R>): UnaryFn<T, R>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, K, R>>, Handled> &
+            MustBePartial<T, K, Handled>,
+    >(
+        handlers: Handled & Partial<Handlers<T, K, R>>,
+        fallback: Fallback<T, K, Handled, R>,
+    ): UnaryFn<T, R>;
+}
+
+// Widened returns: the union of every handler's return type. `P` is inferred
+// from the whole handler map, whose closed constraint supplies the
+// contextual/autocomplete type.
+interface TaggedUnionMatcherWidening<T extends object, K extends keyof T> {
+    <P extends Exact<Handlers<T, K, unknown>, P>>(
+        handlers: P,
+    ): UnaryFn<T, PatternReturns<P>>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, K, unknown>>, Handled> &
+            MustBePartial<T, K, Handled>,
+    >(
+        handlers: Handled,
+        fallback: Fallback<T, K, Handled, R>,
+    ): UnaryFn<T, PatternReturns<Handled> | R>;
+}
+
+const dispatch =
+    (k: PropertyKey) =>
+    (handlers: HandlerMap, fallback?: UnaryFn<never, unknown>) =>
+    (shape: object): unknown => {
+        // `object` carries no index signature, so the read needs the assertion;
+        // the factory admits only keys whose values are `string | number` tags,
+        // so the result is narrowed to the map's key space.
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+        const tag = (shape as UnknownRecord)[k] as string | number;
+        return (
+            handlers[tag] ??
+            fallback ??
+            (() => {
+                throw new Error(`Unhandled tag: ${String(tag)}`);
+            })
+        )(
+            // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+            shape as never,
+        );
+    };
+
+export const getTaggedUnionMatcher =
+    <T extends object>() =>
+    <K extends Discriminated<T>>(k: K): TaggedUnionMatcherStrict<T, K> =>
+        dispatch(k);
+
+export const getTaggedUnionMatcherW =
+    <T extends object>() =>
+    <K extends Discriminated<T>>(k: K): TaggedUnionMatcherWidening<T, K> =>
+        dispatch(k);

src/util/__tests__/lsp-completion.test.ts

@@ -1,4 +1,3 @@
-/* oxlint-disable typescript/no-floating-promises -- expectTypeOf() is a sync type-assertion library that the type-aware linter misidentifies as a promise */
 import { strict as assert } from "node:assert";
 import path from "node:path";
 import { test } from "node:test";