🚀 Release 0.7.1

🔀 Merge fix/knip-library-entry into main
🐛 Stop knip reporting the source entry
2026-09-23 14:56:59 +00:00 · 2026-09-23 14:56:15 +00:00 · 2026-09-23 14:55:27 +00:00 · 2026-09-23 14:51:49 +00:00 · 2026-09-23 14:50:29 +00:00 · 2026-09-23 14:34:51 +00:00
24 changed files with 4042 additions and 899 deletions
@@ -22,7 +22,8 @@
        "eslint/sort-imports": "off",
        "import/consistent-type-specifier-style": "off",
        "unicorn/prefer-export-from": "off",
-        "typescript/method-signature-style": "off"
+        "typescript/method-signature-style": "off",
+        "typescript/promise-function-async": "off"
    },
    "options": { "typeAware": true },
    "env": { "builtin": true, "es2024": true, "node": true },
@@ -33,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"
            }
        },
        {
@@ -41,6 +44,12 @@
            "rules": {
                "import/no-nodejs-modules": "off"
            }
+        },
+        {
+            "files": ["src/util/__tests__/**"],
+            "rules": {
+                "import/no-nodejs-modules": "off"
+            }
        }
    ],
    "ignorePatterns": ["dist", "node_modules", "coverage"]
@@ -9,7 +9,7 @@ first-action facts. Do not restate evolving prose here — it will drift.

 - Project: F#-style pattern matching for TypeScript/ESM. Node `>=26` (pinned via `.node-version`), ESM-only (no CommonJS shim).
 - **While iterating:** `npm run test` (`check:tsc` + the unit suite) for fast feedback on the files you changed.
- **Optional code intelligence:** this repo installs `@spences10/pi-lsp` (pinned in `.pi/settings.json`) as a project-local pi extension. It talks to the repo's own TypeScript 7 via `tsc --lsp --stdio` and exposes **read-only** tools — `lsp_hover`, `lsp_definition`, `lsp_references`, `lsp_find_symbol`, `lsp_document_symbols`, `lsp_diagnostics(_many)`. Prefer `lsp_references` over `grep -w` for widely-colliding identifiers (`matches`, `type`, …); use `lsp_hover` to read inferred types on generic-heavy code. It has no rename / code-action / apply-edit surface — the write side is pi's `edit` tool + `check:tsc`. Treat empty LSP output as _inconclusive_, not success: **`npm run test` / `npm run verify` remain the sole authoritative gate** (see the next bullet). The server keeps running across that gate with a ~5 min idle timeout and registers no file watchers, so if you change `tsconfig.json` / `package.json` mid-session its diagnostics can be stale — when LSP output disagrees with `check:tsc`, trust `check:tsc` and restart pi (or wait out the idle timeout) before concluding the LSP is wrong.
+- **Optional code intelligence:** this repo installs `@spences10/pi-lsp` (pinned in `.pi/settings.json`) as a project-local pi extension. It talks to the repo's own TypeScript 7 via `tsc --lsp --stdio` and exposes **read-only** tools — `lsp_hover`, `lsp_definition`, `lsp_references`, `lsp_find_symbol`, `lsp_document_symbols`, `lsp_diagnostics(_many)`. **When you are looking for a symbol, reach for the LSP before `rg`/`grep`** — `lsp_references` / `lsp_find_symbol` / `lsp_definition` / `lsp_document_symbols` are semantic and cross-file, so they see shadowing, imports and overloads that a text search cannot; use `lsp_hover` to read inferred types on generic-heavy code. Use `rg` for what the LSP cannot see — doc prose, string literals, config, task lists, file discovery — and reconcile the two sets before editing (symbols from the LSP, strings and prose from `rg`). It has no rename / code-action / apply-edit surface — the write side is pi's `edit` tool + `check:tsc`. Treat empty LSP output as _inconclusive_, not success: **`npm run test` / `npm run verify` remain the sole authoritative gate** (see the next bullet). The server keeps running across that gate with a ~5 min idle timeout and registers no file watchers, so if you change `tsconfig.json` / `package.json` mid-session its diagnostics can be stale — when LSP output disagrees with `check:tsc`, trust `check:tsc` and restart pi (or wait out the idle timeout) before concluding the LSP is wrong.
 - **Definition of done — run this before you call the work finished:** `npm run verify`. If all green, commit. If red, look at the output, fix the root cause, and re-run.
 - **On commit:** write a good message (see [CONTRIBUTING.md § Commit messages](./CONTRIBUTING.md#commit-messages)). Lefthook's pre-commit hook already runs the fast, offline, staged-file checks — don't run them by hand. If the hook fails on style, `npm run fix`, restage, recommit.
 - **Document decisions where the next maintainer will look:** rationale, rejected alternatives and known issues go in `development/<category>.md` (see [development/README.md](./development/README.md)); the actionable rule stays in [CONTRIBUTING.md](./CONTRIBUTING.md) and links to it. Write each fact once — never copy the rule into `development/` or the reason into `CONTRIBUTING.md` — and change both in the same commit when a rule changes.
@@ -26,9 +26,10 @@ Don't silence the type system to force a green run. As an agent these are forbid

 - `// @ts-nocheck`, `// @ts-ignore`, `// @ts-expect-error`
 - `// 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. 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.
-
-In both cases, follow [CONTRIBUTING.md § Testing discipline (type-driven)](./CONTRIBUTING.md#testing-discipline-type-driven). Each subtask gets one or more commits.
+Follow [CONTRIBUTING.md § Testing discipline (type-driven)](./CONTRIBUTING.md#testing-discipline-type-driven) throughout.

 ## Read these

@@ -7,6 +7,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

+## [0.7.1] - 2026-09-23
+
+- upgrade dependencies
+
+## [0.7.0] - 2026-09-23
+
+- reject broad universes (`string`, `number`, template literals) and
+  value/stringification collisions (`true | "true"`, `1 | "1"`) at the factory
+- type handler parameters by the matched member, so a
+  standalone `"true"` universe is typed `"true"` rather than `true`
+
+## [0.6.0] - 2026-09-22
+
+- add `getTaggedUnionMatcher` / `getTaggedUnionMatcherW` for discriminated unions
+- rename the primitive matcher to primitive-union: `getMatcher` /
+  `getMatcherW` → `getPrimitiveUnionMatcher` / `getPrimitiveUnionMatcherW`, and
+  `src/primitive.ts` / `src/primitive.test.ts` → `src/primitive-union.*`
+
+## [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
+- house shared test helpers under `src/util/__tests__/`
+
 ## [0.2.0] - 2026-09-16

 - allow ternaries and lowercase comments in oxlint
@@ -54,7 +86,13 @@ 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.2.0...main
+[Unreleased]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.7.1...main
+[0.7.1]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.7.0...0.7.1
+[0.7.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.6.0...0.7.0
+[0.6.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.5.0...0.6.0
+[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
 [0.1.7]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.1.6...0.1.7
@@ -66,7 +66,15 @@ 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-union.test.ts` for the matcher's popup) are the
+exception —
+the language server, not the type system, is the oracle (see
+[development/testing.md § Autocomplete](./development/testing.md#autocomplete)).
 Each test body follows **AAA (Arrange–Act–Assert)** with labeled blocks
 separated by a blank line: `// Arrange` sets up the inputs (e.g. the matcher
 factory), `// Act` exercises the subject once from them (not a second
@@ -150,7 +158,8 @@ 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
+  finding (e.g. `typescript/no-floating-promises`) — see
  [AGENTS.md § Never do](./AGENTS.md#never-do). (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.**
@@ -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,23 @@ for the design decisions and the known limitations.

 Yet to be implemented

+## Caveats
+
+- **Only finite universes are supported.** The factory must be given a finite
+  union of literals; `string`, `number` and template literals are rejected. This
+  is what lets the exhaustive overload be proven, so the runtime `dispatch`
+  throw stays unreachable through the typed API.
+- **A value and its stringification must not both be present.** Object keys
+  stringify, so a universe containing both a member and the string it
+  stringifies to — `1 | "1"`, `true | "true"`, `null | "null"` — is rejected at
+  the factory. Either form alone is fine, and one value's string form may
+  coexist with a _different_ value's bare form (`"true" | false`).
+- **`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).
@@ -24,14 +24,57 @@ v1.0:
    ☐ Document all exported types and functions
    ☐ Add JSDoc for public APIs
 ☐ Test coverage meets threshold
-    ☐ Achieve 100% branch coverage on `src/primitive.ts`
+    ☐ Achieve 100% branch coverage on `src/primitive-union.ts`
    ☐ Achieve 100% branch coverage on `src/index.ts`

-Bugs:
+Testing:
+✔ Cover autocomplete with real completion test cases in the suite @medium @done
+    → `src/util/__tests__/lsp-completion.ts` (`#test-utils/…`) is the helper; the suite asserts its labels (see development/testing.md § Autocomplete)
+    → wire it into `node --test` so a test asserts the offered labels
+    → note: `Parameters<typeof factory>[0]` resolves only the *last* overload; use `@ts-expect-error` call sites for factory negatives, not `not.toExtend<Parameters<…>>`
+✔ Drive the LSP completion helper through the LSP protocol library instead of a hand-rolled JSON-RPC client @medium @done
+    ✔ Add `vscode-languageserver-protocol` and record the tooling decision @done
+    ✔ 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 @cancelled
+    → broad universes are rejected; the rejection is covered by the broad-universe gate tests
+✔ Type hole when using broad types like string as a universe @high @done
+    → decided: broad universes are rejected at the factory, so the exhaustive overload can always be proven
+    → value/stringification collisions (`true | "true"`, `1 | "1"`) are rejected too; handler params are typed by `Member<T, K>`
+    → see development/library.md § Supported universes

+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 @done
+    → the fallback is now a second argument: `(handlers, (s) => …)`, `s: Exclude<T, keyof handlers>`
+✔ A fallback for an already-exhaustive handler map must be a compile error @medium @done
+    → 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 @done
+    → `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
+    → shipped as `getPrimitiveUnionMatcher` / `getPrimitiveUnionMatcherW`; kept `Union` for symmetry with the tagged-union pair
+☐ when using a union type as a property, the current behavior of tagged union matcher is
+    to pass never to handler parameters
+    → new matcher function needed or can be fixed in tagged union matcher
+    ☐ optional discriminant (`{ type?: "x" }`) is the same hole: the boolean/nullish change now admits the `undefined` tag, so the factory accepts the key, but `Extract<T, Record<K, V>>` still passes `never` to both the `x` and `undefined` handlers
+
+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
-☐ Are there other primitive types that should be supported in union patterns? (e.g. `bigint`, `symbol`) @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 @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 @done
+    → moved the `PatternKey` / `PatternParam` projection to `matcher-shared.ts` and keyed the tagged-union handler map through it; see development/library.md § Tagged-union matcher

 Documentation:
 ☐ Bring README.md back to its previous form — synopsis and examples restored, in the correct place
@@ -41,6 +84,7 @@ Documentation:
 ☐ Add comparison section vs. other TS pattern-matching libs in Readme.md
 ☐ Write migration guide for users coming from discriminated unions
 ☐ Create backlog tasks for implementation
+✔ Document the matcher design paths in `development/` — union vs overload merge, inferred universe (`NoInfer`), conditional `RequireKeys`, cases-first — and why each was abandoned @done
 ☐ Validate code fences in Markdown (start with README.md) — compile the TypeScript examples against `src/` so the docs cannot drift from the API

 Workflow:
@@ -43,7 +43,9 @@
        "silverwind",
        "idris",
        "todotasks",
-        "connor"
+        "connor",
+        "injective",
+        "injectivity"
    ],
    "ignorePaths": ["dist", "node_modules", "coverage", "*.svg", ".gitignore"]
 }
@@ -3,4 +3,258 @@
 The type-level design of the public API and the limitations it carries. The
 user-facing reference is [README § API](../README.md#api).

-Currently the library is placeholder code.
+The matchers are implemented in `src/primitive-union.ts` (`getPrimitiveUnionMatcher` /
+`getPrimitiveUnionMatcherW`) and `src/tagged-union.ts` (`getTaggedUnionMatcher` /
+`getTaggedUnionMatcherW`), re-exported from `src/index.ts`; the rest of the
+library is placeholder code.
+
+## Matcher shape
+
+#### Decision (2026-09)
+
+A factory takes the universe and returns a builder; the builder takes a handler
+map and an optional fallback:
+
+```ts
+const matcher = getPrimitiveUnionMatcher<"a" | "b">()({ a: (s) => …, b: (s) => … });
+const fallback = getPrimitiveUnionMatcher<"a" | "b" | "c">()({ a: (s) => … }, (s) => …);
+```
+
+Exhaustive or fallback is decided **at the call site**, by whether the second
+argument is present. The fallback's parameter is the remainder
+`Exclude<T, keyof Handled>`. Only the return-strictness axis remains, so there
+are two factories:
+
+- `getPrimitiveUnionMatcher` — one common `R`; the fallback must fit it;
+- `getPrimitiveUnionMatcherW` — the union `PatternReturns<Handled> | R`.
+
+Each factory is two overloads whose order is load-bearing:
+
+1. `Handlers<T, R>` — the exhaustive form, and the contextual type of the
+   handler-map popup;
+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
+
+- **The fallback is an argument, not a property.** TypeScript fixes a property's
+  contextual type before it infers its sibling keys, so `_: (s) => …` in the
+  handler map can only see all of `T`, never `Exclude<T, keyof Handled>`. A later
+  argument is contextually typed from inference on an earlier one, so the split
+  is what makes the remainder expressible.
+- **The redundant-fallback guard is an F-bounded constraint.** A map that
+  already covers `T` plus a fallback is rejected by folding
+  `MustBePartial<T, Handled>` into `Handled`'s own constraint. The guard is
+  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
+
+- **Single-object `_`** (the former shape). `_` sees only all of `T`; the
+  remainder is not expressible there, and an exhaustive map plus `_` was
+  accepted.
+- **Curried handlers-first** — `(handlers)(fallback)`. Rejected: two calls for
+  the common case. It is not needed for the redundant-fallback guard, which the
+  F-bounded constraint already provides (see Why).
+- **`this` / HKT self-reference.** `this` is post-construction (method bodies,
+  return positions); a parameter's contextual type is pre-construction.
+  `keyof this` in an interface method is the interface, not the literal.
+- **Variance / `const` type parameters / `NoInfer` / `unique symbol` brands /
+  defaulted type-param guards.** None change inference or evaluation order;
+  `in`/`out` on the handler map broke contextual typing outright. `NoInfer`
+  specifically leaks into the emitted `.d.ts`, raising the consumer floor to
+  TypeScript 5.4 (README promises `>= 5.0`).
+- **Union merge**, **overload merge with only the exhaustive arm last**,
+  **inferred universe**, **conditional `RequireKeys`**, **cases-first curried** —
+  decided against while the API was single-object; their reasons (reported
+  near-miss member, no `_` in the exhaustive popup, `NoInfer`/floor, `keyof P`
+  counts optional keys, not pipe-friendly) hold where they still apply.
+
+#### Known issue
+
+- `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 universe-agnostic pieces both matchers use:
+`UnaryFn`, `PatternReturns`, `RedundantFallback`, `HandlerMap`, the shared
+`Matchable` universe, the `PatternKey` key projection and its `Member` inverse,
+and the `Stringified` / `Collisions` / `UnsupportedReason` / `UnsupportedUniverse`
+/ `UniverseGate` universe gate.
+
+#### Why
+
+- `RedundantFallback`'s property name is the diagnostic, so one definition
+  keeps the two matchers' message from drifting; the other pieces appear
+  verbatim in both public signatures or are the same projection over each
+  matcher's universe.
+- **`Matchable` is one definition, not two.** The primitive-union matcher's
+  universe and the tagged-union matcher's allowed `Tag` values are the same set,
+  so aliasing them keeps the two matchers from drifting apart on what they
+  accept (`symbol`/`bigint` rejected once).
+
+#### Rejected
+
+- **A generic `Matcher<Universe>` over the interface pair, `Handlers`,
+  `Fallback` and `MustBePartial`.** Each is built from its own universe
+  (`Tags`/`MapTaggedUnion` vs the primitive values); abstracting over the
+  F-bounded `Handled` constraint that makes the remainder work risks the
+  contextual typing it exists to preserve. `Matchable`, the `PatternKey` /
+  `Member` projection and the `UniverseGate` are the pieces both universes
+  genuinely share.
+
+## Supported universes
+
+#### Decision (2026-09)
+
+A universe must be a **finite union of literals** with **no
+value/stringification collision**. Broad types (`string`, `number`, a template
+literal) and `"true" | true` / `1 | "1"` are rejected; the factory intersects
+`UniverseGate<T>` (the `UnsupportedUniverse<Reason>` diagnostic) into the
+handler and fallback parameters. `Member<T, K>` replaces the `PatternParam<K>`
+inversion: the handler parameter is the member(s) of `T` whose `PatternKey` is
+`K`, so a standalone `"true"` is `"true"`, not `true`.
+
+#### Why
+
+- **`PatternKey` is not injective.** `"true"` and `true` (and `1` / `"1"`)
+  share a runtime key, so `PatternParam<K>` cannot recover the member.
+  `Member<T, K>` inverts against `T`, which is exact.
+- **Broad types cannot be proven exhaustive.** An index-like map lets a partial
+  object satisfy the exhaustive overload and reaches the `dispatch` throw.
+  Rejecting at the boundary avoids threading an open/closed branch through
+  `Handlers`, `Fallback` and `MustBePartial`.
+- **Collisions are rejected, not merged.** `Member<T, K>` would be sound (the
+  handler gets the union), but the API is one handler per member; rejecting
+  keeps `Member` a singleton and the remainder exact.
+- **The collision predicate is type-checkable.** `Collisions<T> =
+Extract<T, Stringified<T>>` catches numeric collisions too.
+- **The gate is an intersection, not a branch,** so `R` inference and the popup
+  survive; a conditional parameter type would not.
+
+#### Rejected
+
+- **Open universes with a required fallback** (`fix/open-universe-*`): sound,
+  but left the collision hole and added an `IsLiteral` /
+  `OpenUniverseNeedsFallback` branch through every handler type. Findings, kept
+  so they are not re-run: `{}` satisfies an index signature (and `Exact` misses
+  it); an index signature dominates contextual typing; `R` infers only from a
+  non-self-referential parameter type (`{ [K in keyof H]: … R … }` gives
+  `unknown`); an F-bounded guard referencing `keyof Handled` in `Handled`'s own
+  constraint sees the constraint, not the map; all handlers share one `R` (only
+  the fallback widens it); `IsLiteral` is the finite-literal predicate.
+- **`Member<T, K>` without the gate:** sound, but a colliding handler gets a
+  union and `1 | "1"` stays one runtime key.
+- **A round-trip injectivity gate** (`IsEqual<T, PatternParam<PatternKey<T>>>`):
+  over-rejects standalone `"true"` / `"false"` / `"null"` / `"undefined"`.
+- **A case-list / ts-pattern builder:** removes the collision class but drops
+  the object map (footprint, popup) and reimplements an existing library.
+- **Normalize numeric keys to strings:** makes `PatternKey` injective but
+  changes "numeric keys stay numbers" and defeats the numeric dispatch fast
+  path.
+
+#### Known issue
+
+- A multi-collision universe lists every collision in the diagnostic.
+- The `dispatch` throw is unreachable through the typed API; the throw tests
+  widen the factory to `Function` to reach it.
+
+## Tagged-union matcher
+
+#### Decision (2026-09)
+
+`getTaggedUnionMatcher` / `getTaggedUnionMatcherW` mirror the primitive-union 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-union 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-union dispatch's `shape as string | number`.
+- **`MapTaggedUnion` distributes with `Extract`.** A duplicated tag yields a
+  union of members instead of dropping one.
+- **A `boolean` / `null` / `undefined` tag goes through the shared
+  `PatternKey` / `Member` projection.** `Discriminated` admits those tags
+  (they are in `Tag`), but they cannot key a mapped type, so the handler map is
+  keyed by the stringified form (`true` → `"true"`) and `Member` inverts it
+  against the tag set to recover the member. This is the same projection the
+  primitive-union matcher uses over its universe, which is why it lives in
+  `matcher-shared.ts`.
+
+#### Known issue
+
+- A member's tag must be unique across the union; two members with the same tag
+  collapse to a union under one handler. A tag colliding with its
+  stringification (`true | "true"`) is rejected by the universe gate — see
+  § Supported universes.
+
+## 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 `Member` inverts it
+against the universe, so callbacks receive the real member (`true`, not
+`"true"`; the standalone string `"true"` stays `"true"`). The popup offers
+`true`, `false`, `null`, `undefined` by name (verified over LSP). The same
+projection is shared with the tagged-union matcher; see § Tagged-union matcher.
+The supported universes are constrained as described in § Supported universes.
+
+#### 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 rejected by the gate: user-facing, stated once in
+  [README § Caveats](../README.md#caveats).
@@ -28,14 +28,49 @@ before the implementation.
 - Runtime-first (classic red/green): it verifies the value, not the contract,
  and the contract is the product.
 - Testing the type only: it would not catch handler dispatch or the `_`
-  fallback (see `src/primitive.test.ts`).
+  fallback (see `src/primitive-union.test.ts`).

-The runner is `node --test --strip-types "src/**/*.test.ts"` and the tiers are in
+The runner is `node --test --strip-types "src/**/*.test.ts"` and the tiers are
+in
 [CONTRIBUTING.md § Development commands](../CONTRIBUTING.md#development-commands).
 `c8` uses V8 coverage, so the `--strip-types` source is instrumented without a
 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
@@ -63,11 +98,111 @@ separated by a blank line; an empty block drops its label.
 - Unlabeled ordering (bare blank lines): the seams still have to be found by
  reading; the labels cost nothing.

+## Test helpers
+
+The rule is enforced by `import/no-relative-parent-imports`; this section records
+why the mechanism is shaped like this.
+
+#### Decision (2026-09)
+
+A shared test helper — code that scattered `*.test.ts` files import to do their
+testing — lives under `src/util/__tests__/` and is addressed by the
+`#test-utils/…` self-reference (`package.json#imports`:
+`"#test-utils/*": "./src/util/__tests__/*"`), never by a relative path:
+
+```ts
+import { LspSession } from "#test-utils/lsp-completion.ts";
+```
+
+#### Why
+
+- The lint rule bans upward (`../`) imports, and a cross-cutting helper can
+  always be placed above _some_ scattered consumer, wherever it goes. Name
+  beats path: a `#test-utils/…` specifier has no direction, so the rule never
+  fires and file moves only touch the one mapping in `package.json`.
+- `#…` is Node's reserved prefix for _private_ subpath imports: publishing
+  `package.json` leaks nothing and resolves nothing for consumers.
+- `__tests__` as the folder name is not about tests living there; it is the
+  directory pattern `tsconfig.build.json` already excludes, so a helper can
+  never be emitted into `dist/` and shipped by accident.
+- Node's own resolver handles `#…` under `--strip-types`, and `tsc` resolves it
+  via the same `imports` field — one mechanism for runtime and type gate, no
+  loader needed.
+- The helper uses `node:` builtins (it drives a language server), so
+  `import/no-nodejs-modules` is off for `src/util/__tests__/**` in
+  `.oxlintrc.json` — the same exception the `scripts/**` scope carries.
+- Helpers carry no library coupling: their tests probe in-memory documents
+  whose contextual types are written inline, so only the helper's own contract
+  (marker handling, position, label extraction) is under test. A test that
+  asserts a _matcher's_ popup belongs with the matcher.
+
+#### Rejected
+
+- A helper beside the tests (`src/util/test.ts`, flat `src/`): composes only
+  while `src/` stays flat; the first nested test reaching it reintroduces the
+  banned upward import.
+- Bare `~/…` specifier: not valid in `imports` (keys must start with `#`) —
+  resolution fails at runtime with `ERR_MODULE_NOT_FOUND`. A `#~/…` “home”
+  shorthand was dropped in review; `#test-utils/…` states what it is.
+- tsconfig `paths` alias: resolves for `tsc` but not for plain
+  `node --test --strip-types` (no loader hook), breaking the fast tier.
+- Turning `import/no-relative-parent-imports` off for test files: the rule
+  still guards non-test helpers importing each other, and the exemption is
+  only needed for the one specifier the mapping already solves cleanly.
+
+## Autocomplete
+
+#### Decision (2026-09)
+
+Completion is verified by driving the repo's own language server
+(`tsc --lsp --stdio`, the same server pi's LSP extension talks to) through
+the test helper `#test-utils/lsp-completion.ts`
+(`src/util/__tests__/lsp-completion.ts`), not through the type system:
+
+```sh
+node --strip-types src/util/__tests__/lsp-completion.ts <file> [<marker>]
+```
+
+The script prints the labels the server offers at a `/*COMPLETE*/` marker inside
+`<file>` (the marker is stripped before the document is sent). Its `LspSession`
+is imported by `src/util/__tests__/lsp-completion.test.ts` — which tests the
+helper itself against inline documents, never the library's code — and by
+`src/primitive-union.test.ts`, where the same probe asserts the matcher's popup;
+the CLI is for manual inspection.
+
+#### Why
+
+- Completion is a contextual-type property: it depends on which overload
+  signature TypeScript picks for the object literal, and no type-level assertion
+  observes that.
+- `Parameters<typeof factory>[0]` resolves only the _last_ overload, so it is
+  not the popup's contextual type either — see
+  [library.md § Matcher shape](./library.md#matcher-shape).
+- The server is the only ground truth; the script reproduces what the editor
+  shows.
+
+#### Rejected
+
+- **`expect-type` would not work**: there is no operator for “the popup offers
+  these labels”. `toExtend` / `toEqualTypeOf` test assignability and cannot say
+  which overload supplied the contextual type.
+- **Checking by hand in the editor**: not reproducible in review or by an agent.
+- **`@ts-expect-error` at a completion position**: it asserts the absence of a
+  compile error, not the presence of specific labels.
+
+#### Known issue
+
+- Each test spawns its own `tsc` server so the tests share no state and pass in
+  any order; the file is an integration test (~1.6 s) that needs `node_modules`.
+  `didOpen` is handled in order before the completion request, so no settle
+  delay is needed.
+- The server answers some requests with a string id (`client/registerCapability`);
+  the client must tolerate `string | number` ids or the server stalls.
+
 ## Known issues

- The type-aware linter misidentifies `expectTypeOf()` as a floating promise, so
-  test files that use it (`src/primitive.test.ts`) carry a
-  file-level `oxlint-disable
-typescript/no-floating-promises` with an explanatory comment. It is a known
-  false positive, not a rule worth disabling project-wide (see
+- The type-aware linter misidentifies `expectTypeOf()` as a floating promise.
+  It is a known false positive, so `typescript/no-floating-promises` is off for
+  `**/*.test.ts` in the `.oxlintrc.json` override rather than repeated as a
+  file-level header (see
  [tooling.md § oxlint-disable directives live next to the code](./tooling.md#oxlint-disable-directives-live-next-to-the-code)).
@@ -24,6 +24,8 @@ in [package.json](../package.json).
 - **@spences10/pi-lsp** — read-only LSP code intelligence for AI agents
  (project-local `.pi/settings.json`); talks to this repo's TypeScript 7 via
  `tsc --lsp --stdio`.
+- **vscode-languageserver-protocol** — LSP client and protocol types for the
+  autocomplete test helper (`src/util/__tests__/lsp-completion.ts`).

 When each runs is in
 [CONTRIBUTING.md § Feedback tiers](../CONTRIBUTING.md#feedback-tiers).
@@ -104,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
-`oxlint-disable` directive (see `src/primitive.ts`,
-`src/primitive.test.ts`), not by turning the rule off in `.oxlintrc.json`.
+A type-aware rule that false-positives **at one site** is silenced with a
+source-level `oxlint-disable` directive (see `src/primitive-union.ts`). A rule that is
+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
-  source.
- The rule stays on everywhere else, so only the mis-firing line is exempted.
+- A one-site disable sits next to the code it silences, visible to anyone
+  reading the source, and the rule stays on everywhere else.
+- 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
-  exemption from the reader of the affected code and switches the rule off
-  repo-wide for a one-site problem.
+- A project-wide disable in `.oxlintrc.json` for a one-site false positive: it
+  hides the exemption from the reader of the affected code and switches the rule
+  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;
-  they fix the type at its root (see [AGENTS.md § Never do](../AGENTS.md#never-do)).
+- Both placements are _human_ last resorts. AI agents must neither add a source
+  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

@@ -186,6 +196,28 @@ joining the oxfmt-superseded rules already off.
  are part of the public API.
 - The narrower scope keeps the signal high without config-file boilerplate.

+### `knip` lists `src/index.ts` as an entry
+
+#### Decision (2026-09)
+
+`knip.json` declares `"entry": ["src/index.ts", "scripts/*.ts"]`.
+
+#### Why
+
+- Supplying `entry` **replaces** knip's default entry detection, which otherwise
+  derives the public entry from `package.json` `exports`. Adding `scripts/*.ts`
+  there therefore dropped the library entry, so knip resolved the package through
+  its `dist/index.js` output and reported the unreferenced source entry file
+  `src/index.ts` as an unused file.
+- Naming the source entry restores the link between the public API and the
+  source graph without pointing knip at build output.
+
+#### Rejected
+
+- `paths` mapping `dist/index.*` back to `src/index.ts`: more config to model a
+  relation the explicit entry states directly, and it would break whenever the
+  build layout changes.
+
 ### `maintain:outdated` ignores `@types/node`

 #### Decision (2026-09)
@@ -247,6 +279,38 @@ project.
 - The same script works by hand (whole project) and staged (scoped), so there is
  no second command to maintain.

+## Language server tooling
+
+### `vscode-languageserver-protocol` backs the autocomplete helper
+
+#### Decision (2026-09)
+
+The autocomplete helper (`src/util/__tests__/lsp-completion.ts`) drives
+`tsc --lsp --stdio` through `vscode-languageserver-protocol`'s
+`createMessageConnection` and its typed request / notification objects, instead
+of a hand-rolled JSON-RPC client.
+
+#### Why
+
+- Framing, `Content-Length` parsing, the pending-request map and server-request
+  dispatch are protocol plumbing the helper only reimplemented; the official
+  client owns them and tolerates the server's `string | number` ids.
+- `InitializeRequest`, `CompletionRequest`, `DidOpenTextDocumentNotification`,
+  … carry their parameter and result types, so `CompletionList` / `CompletionItem`
+  replace the helper's ad-hoc shape guards.
+- The `./node` entry re-exports `vscode-jsonrpc/node`, so one devDependency
+  supplies both the transport and the protocol types. It is test-only and never
+  ships (`files` publishes `dist/` only).
+
+#### Rejected
+
+- `vscode-languageclient`: the editor-side client with a full feature registry
+  — far more than a test helper needs.
+- Generic JSON-RPC (`jsonrpc-lite`, `jayson`): still no LSP types, so they
+  replace framing only and leave the typed protocol surface unimplemented.
+- Keeping the hand-rolled client: the low-level shape is the maintenance cost
+  the helper exists to remove, and it must be re-audited against the server.
+
 ## Editor and agent tooling

 ### VSCode integration
@@ -1,5 +1,5 @@
 {
    "$schema": "./node_modules/knip/schema.json",
-    "entry": ["scripts/*.ts"],
+    "entry": ["src/index.ts", "scripts/*.ts"],
    "ignoreDependencies": ["@runwisp/pubv"]
 }
@@ -1,6 +1,6 @@
 {
    "name": "tiny-pattern-ts",
-    "version": "0.2.0",
+    "version": "0.7.1",
    "description": "Pattern matching for TypeScript/ESM environments (F#-style, not regex)",
    "keywords": [
        "adt",
@@ -27,6 +27,9 @@
    ],
    "type": "module",
    "sideEffects": false,
+    "imports": {
+        "#test-utils/*": "./src/util/__tests__/*"
+    },
    "exports": {
        ".": {
            "types": "./dist/index.d.ts",
@@ -80,11 +83,12 @@
        "expect-type": "1.4.0",
        "knip": "^6.34.0",
        "lefthook": "^2.1.12",
-        "oxfmt": "^0.68.0",
+        "oxfmt": "^0.70.0",
        "oxlint": "^1.83.0",
        "oxlint-tsgolint": "^7.0.2001",
        "publint": "^0.3.24",
-        "typescript": "^7.0.2"
+        "typescript": "^7.0.2",
+        "vscode-languageserver-protocol": "^3.18.3"
    },
    "engines": {
        "node": ">=26"
@@ -73,9 +73,9 @@ git show-ref --verify --quiet "refs/heads/${BASE}" || {
    exit 1
 }

-# Derive the remote rather than hardcoding it: this repo has `origin` (ssh) and
-# `origin_https`, and `main` tracks the latter — `git fetch origin main` would
-# check currency against a ref that is never updated here.
+# Derive the remote rather than hardcoding it: `main` tracks `origin` (ssh)
+# here; a hardcoded name would check currency against a ref that may not
+# exist on a differently configured clone.
 # `--quiet` echoes the unresolved `main@{upstream}` literal to stdout on
 # failure, so it cannot be paired with a `$(...) || fallback`; the non-quiet
 # form prints nothing on failure and the fallback runs.
@@ -1,6 +1,8 @@
 export {
    getPrimitiveUnionMatcher,
-    getPrimitiveUnionMatcherPartial,
-    getPrimitiveUnionMatcherPartialW,
    getPrimitiveUnionMatcherW,
-} from "./primitive.ts";
+} from "./primitive-union.ts";
+export {
+    getTaggedUnionMatcher,
+    getTaggedUnionMatcherW,
+} from "./tagged-union.ts";
@@ -0,0 +1,101 @@
+import type { IsLiteral, IsNever, ValueOf } from "type-fest";
+
+// The primitive-union 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;
+
+// The primitive universe a matcher can discriminate. The primitive-union matcher
+// uses it directly; the tagged-union matcher uses it as the set of allowed
+// discriminant (`Tag`) values. `boolean` is admitted as the pair `true | false`;
+// see README § Caveats for the unsupported members.
+export type Matchable = string | number | boolean | null | undefined;
+
+// `boolean`, `null` and `undefined` cannot be property keys, so a mapped type
+// over a universe that includes one keys each such member by its
+// stringification. `Member` inverts that projection against the universe, so a
+// handler callback still receives the *real* member (`true`, not `"true"`).
+// Both matchers use the projection: the primitive-union matcher over its
+// universe, the tagged-union matcher over a discriminant property's values. See
+// README § Caveats for the limits.
+export type PatternKey<T> = T extends boolean
+    ? T extends true
+        ? "true"
+        : "false"
+    : T extends null
+      ? "null"
+      : T extends undefined
+        ? "undefined"
+        : T;
+
+// The member(s) of `T` whose `PatternKey` is `K`: the universe-keyed inverse of
+// `PatternKey`. The key alone cannot recover the member (`"true"` and `true`
+// share it), so the handler parameter is derived from `T` instead. For a
+// supported (injective) universe the result is a single member.
+export type Member<
+    T extends Matchable,
+    K extends PropertyKey,
+> = T extends Matchable ? (PatternKey<T> extends K ? T : never) : never;
+
+// The property key a `Matchable` member takes at runtime: booleans, `null` and
+// `undefined` stringify, and a numeric literal becomes its decimal string.
+export type Stringified<T> = T extends boolean
+    ? T extends true
+        ? "true"
+        : "false"
+    : T extends null
+      ? "null"
+      : T extends undefined
+        ? "undefined"
+        : T extends number
+          ? `${T}`
+          : never;
+
+// The members of `T` that are also the stringification of another member, so
+// `PatternKey` cannot invert them. `never` means the universe is injective.
+export type Collisions<T> = Extract<T, Stringified<T>>;
+
+// Why `T` is not a supported universe, or `never` when it is. A supported
+// universe is a finite union of literals with no value/stringification
+// collision: only then can `PatternKey` be inverted unambiguously.
+export type UnsupportedReason<T extends Matchable> =
+    IsLiteral<PatternKey<T>> extends false
+        ? "broad types like string, number and template literals are not supported"
+        : [Collisions<T>] extends [never]
+          ? never
+          : `a value and its stringification collide. Value is "${Collisions<T> & string}"`;
+
+// The diagnostic for an unsupported universe. Extends `HandlerMap` so the
+// implementation's `handlers: HandlerMap` stays assignable when the gate is
+// intersected into a parameter; the property name is the message.
+export type UnsupportedUniverse<Reason extends string> = HandlerMap &
+    Readonly<Record<`unsupported universe: ${Reason}`, never>>;
+
+// `unknown` for a supported universe (an intersection no-op), the diagnostic
+// otherwise. Intersecting rather than branching keeps `R` inference intact.
+export type UniverseGate<T extends Matchable> =
+    IsNever<UnsupportedReason<T>> extends true
+        ? unknown
+        : UnsupportedUniverse<UnsupportedReason<T>>;
+
+// `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
+>;
@@ -0,0 +1,104 @@
+import type { Exact } from "type-fest";
+
+import type {
+    HandlerMap,
+    Matchable,
+    Member,
+    PatternKey,
+    PatternReturns,
+    RedundantFallback,
+    UnaryFn,
+    UniverseGate,
+} from "./matcher-shared.ts";
+
+type Handlers<T extends Matchable, R> = {
+    [K in PatternKey<T>]: UnaryFn<Member<T, K>, R>;
+};
+
+// The fallback is a *second argument*, not a property of the handler map,
+// because its parameter is the remainder `Exclude<T, Member<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, Member<T, keyof Handled>>,
+    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;
+
+// TypeScript does not apply the excess-property check to a generic constraint,
+// so `Exact` restores it for the generic forms: a handler map can otherwise
+// carry keys outside `T`.
+
+// 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 PrimitiveUnionMatcherStrict<T extends Matchable> {
+    <R>(handlers: Handlers<T, R> & UniverseGate<T>): UnaryFn<T, R>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, R>>, Handled> &
+            MustBePartial<T, Handled>,
+    >(
+        handlers: Handled & Partial<Handlers<T, R>> & UniverseGate<T>,
+        fallback: Fallback<T, Handled, R> & UniverseGate<T>,
+    ): 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 PrimitiveUnionMatcherWidening<T extends Matchable> {
+    <P extends Exact<Handlers<T, unknown>, P>>(
+        handlers: P & UniverseGate<T>,
+    ): UnaryFn<T, PatternReturns<P>>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, unknown>>, Handled> &
+            MustBePartial<T, Handled>,
+    >(
+        handlers: Handled & UniverseGate<T>,
+        fallback: Fallback<T, Handled, R> & UniverseGate<T>,
+    ): UnaryFn<T, PatternReturns<Handled> | R>;
+}
+
+const dispatch =
+    (handlers: HandlerMap, fallback?: UnaryFn<never, unknown>) =>
+    (shape: Matchable): unknown =>
+        // `handlers[true]` already coerces to the `"true"` property at runtime,
+        // 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 getPrimitiveUnionMatcher = <
+    T extends Matchable,
+>(): PrimitiveUnionMatcherStrict<T> => dispatch;
+export const getPrimitiveUnionMatcherW = <
+    T extends Matchable,
+>(): PrimitiveUnionMatcherWidening<T> => dispatch;
@@ -1,357 +0,0 @@
-/* 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 { test } from "node:test";
-
-import { expectTypeOf } from "expect-type";
-
-import {
-    getPrimitiveUnionMatcher,
-    getPrimitiveUnionMatcherPartial,
-    getPrimitiveUnionMatcherPartialW,
-    getPrimitiveUnionMatcherW,
-} from "./primitive.ts";
-
-// ============================================================================
-// API: getPrimitiveUnionMatcherW — ✔️ Exhaustive / ❌ ReturnsStrict
-// ============================================================================
-
-test("getPrimitiveUnionMatcherW requires every literal key", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherW<"a" | "b">();
-
-    // Act
-    const matcher = factory({
-        a: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"a">();
-            return 1 as const;
-        },
-        b: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"b">();
-            return "two" as const;
-        },
-    });
-
-    // Assert
-    // ❌ ReturnsStrict: mixed handler returns widen to their union.
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b") => 1 | "two">();
-    // A pattern missing a key must not satisfy the parameter type.
-    expectTypeOf<{
-        a: () => number;
-    }>().not.toExtend<Parameters<typeof factory>[0]>();
-    assert.equal(matcher("a"), 1);
-    assert.equal(matcher("b"), "two");
-});
-
-test("getPrimitiveUnionMatcherW dispatches on numeric literal keys", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherW<1 | 2>();
-
-    // Act
-    const matcher = factory({
-        1: (n) => {
-            expectTypeOf(n).toEqualTypeOf<1>();
-            return n + 1;
-        },
-        2: (n) => {
-            expectTypeOf(n).toEqualTypeOf<2>();
-            return n * 10;
-        },
-    });
-
-    // Assert
-    expectTypeOf(matcher).toEqualTypeOf<(shape: 1 | 2) => number>();
-    assert.equal(matcher(1), 2);
-    assert.equal(matcher(2), 20);
-});
-
-test("getPrimitiveUnionMatcherW dispatches on mixed string and numeric keys", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherW<"a" | "b" | 1 | 2>();
-
-    // Act
-    const matcher = factory({
-        a: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"a">();
-            return "A" as const;
-        },
-        b: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"b">();
-            return "B" as const;
-        },
-        1: (n) => {
-            expectTypeOf(n).toEqualTypeOf<1>();
-            return 10 as const;
-        },
-        2: (n) => {
-            expectTypeOf(n).toEqualTypeOf<2>();
-            return 20 as const;
-        },
-    });
-
-    // Assert
-    expectTypeOf(matcher).toEqualTypeOf<
-        (shape: "a" | "b" | 1 | 2) => "A" | "B" | 10 | 20
-    >();
-    assert.equal(matcher("a"), "A");
-    assert.equal(matcher("b"), "B");
-    assert.equal(matcher(1), 10);
-    assert.equal(matcher(2), 20);
-});
-
-// ============================================================================
-// API: getPrimitiveUnionMatcher — ✔️ Exhaustive / ✔️ ReturnsStrict
-// ============================================================================
-
-test("getPrimitiveUnionMatcher infers a single return type shared by all handlers", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcher<"a" | "b">();
-
-    // Act
-    const matcher = factory({
-        a: (s): number => {
-            expectTypeOf(s).toEqualTypeOf<"a">();
-            return 1;
-        },
-        b: (s): 1 | 2 => {
-            expectTypeOf(s).toEqualTypeOf<"b">();
-            return 2;
-        },
-    });
-
-    // Assert
-    // ✔️ ReturnsStrict: R is the best common return type, not a widening union.
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b") => number>();
-    assert.equal(matcher("a"), 1);
-    assert.equal(matcher("b"), 2);
-});
-
-test("getPrimitiveUnionMatcher handlers receive the matched literal", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcher<"on" | "off">();
-
-    // Act
-    const matcher = factory({
-        on: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"on">();
-            return `handler ${s}`;
-        },
-        off: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"off">();
-            return `handler ${s}`;
-        },
-    });
-
-    // Assert
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "on" | "off") => string>();
-    assert.equal(matcher("on"), "handler on");
-    assert.equal(matcher("off"), "handler off");
-});
-
-test("getPrimitiveUnionMatcher infers one return type across mixed string and numeric keys", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcher<"a" | "b" | 1 | 2>();
-
-    // Act
-    const matcher = factory({
-        a: (s): number => {
-            expectTypeOf(s).toEqualTypeOf<"a">();
-            return 1;
-        },
-        b: (s): 1 | 2 => {
-            expectTypeOf(s).toEqualTypeOf<"b">();
-            return 2;
-        },
-        1: (n): number => {
-            expectTypeOf(n).toEqualTypeOf<1>();
-            return 10;
-        },
-        2: (n): number => {
-            expectTypeOf(n).toEqualTypeOf<2>();
-            return 20;
-        },
-    });
-
-    // Assert
-    // ✔️ ReturnsStrict: R is the best common return type, not a widening union.
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b" | 1 | 2) => number>();
-    assert.equal(matcher("a"), 1);
-    assert.equal(matcher("b"), 2);
-    assert.equal(matcher(1), 10);
-    assert.equal(matcher(2), 20);
-});
-
-// ============================================================================
-// API: getPrimitiveUnionMatcherPartial — ❌ Exhaustive / ✔️ ReturnsStrict
-// ============================================================================
-
-test("getPrimitiveUnionMatcherPartial routes shapes without a handler to _", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherPartial<"a" | "b" | "c">();
-    // Two keys, so `{ a }` lacks only the `_` fallback, nothing else.
-    const sparseFactory = getPrimitiveUnionMatcherPartial<"a" | "b">();
-
-    // Act
-    const matcher = factory({
-        a: (s): 1 | 2 => {
-            expectTypeOf(s).toEqualTypeOf<"a">();
-            return 1;
-        },
-        _: (s): 1 | 2 => {
-            // The fallback sees the whole union, not a single literal.
-            expectTypeOf(s).toEqualTypeOf<"a" | "b" | "c">();
-            return 2;
-        },
-    });
-
-    // Assert
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b" | "c") => 1 | 2>();
-    // ❌ Exhaustive: gaps are allowed, but only with a `_` fallback.
-    expectTypeOf<{
-        a: () => number;
-    }>().not.toExtend<Parameters<typeof sparseFactory>[0]>();
-    assert.equal(matcher("a"), 1);
-    assert.equal(matcher("b"), 2);
-    assert.equal(matcher("c"), 2);
-});
-
-test("getPrimitiveUnionMatcherPartial also accepts an exhaustive pattern", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherPartial<"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("getPrimitiveUnionMatcherPartial routes mixed string and numeric keys, gaps go to _", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherPartial<"a" | "b" | 1 | 2>();
-
-    // Act
-    const matcher = factory({
-        a: (s): string => {
-            expectTypeOf(s).toEqualTypeOf<"a">();
-            return "A";
-        },
-        1: (n): string => {
-            expectTypeOf(n).toEqualTypeOf<1>();
-            return "one";
-        },
-        _: (s): string => {
-            // The fallback sees the whole union, not a single literal.
-            expectTypeOf(s).toEqualTypeOf<"a" | "b" | 1 | 2>();
-            return "fallback";
-        },
-    });
-
-    // Assert
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "a" | "b" | 1 | 2) => string>();
-    assert.equal(matcher("a"), "A");
-    assert.equal(matcher("b"), "fallback");
-    assert.equal(matcher(1), "one");
-    assert.equal(matcher(2), "fallback");
-});
-
-// ============================================================================
-// API: getPrimitiveUnionMatcherPartialW — ❌ Exhaustive / ❌ ReturnsStrict
-// ============================================================================
-
-test("getPrimitiveUnionMatcherPartialW allows gaps and widens to the union of handler returns", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherPartialW<"x" | "y" | "z">();
-    // Two keys, so `{ x }` lacks only the `_` fallback, nothing else.
-    const sparseFactory = getPrimitiveUnionMatcherPartialW<"x" | "y">();
-
-    // Act
-    const matcher = factory({
-        x: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"x">();
-            return 1 as const;
-        },
-        _: (s) => {
-            // The fallback sees the whole union, not a single literal.
-            expectTypeOf(s).toEqualTypeOf<"x" | "y" | "z">();
-            return "fallback" as const;
-        },
-    });
-
-    // Assert
-    expectTypeOf(matcher).toEqualTypeOf<
-        (shape: "x" | "y" | "z") => 1 | "fallback"
-    >();
-    // ❌ Exhaustive: gaps are allowed, but only with a `_` fallback.
-    expectTypeOf<{
-        x: () => number;
-    }>().not.toExtend<Parameters<typeof sparseFactory>[0]>();
-    assert.equal(matcher("x"), 1);
-    assert.equal(matcher("y"), "fallback");
-    assert.equal(matcher("z"), "fallback");
-});
-
-test("getPrimitiveUnionMatcherPartialW widens mixed string and numeric key returns to their union", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherPartialW<"a" | "b" | 1 | 2>();
-
-    // Act
-    const matcher = factory({
-        a: (s) => {
-            expectTypeOf(s).toEqualTypeOf<"a">();
-            return "A" as const;
-        },
-        1: (n) => {
-            expectTypeOf(n).toEqualTypeOf<1>();
-            return 10 as const;
-        },
-        _: (s) => {
-            // The fallback sees the whole union, not a single literal.
-            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"
-    >();
-    assert.equal(matcher("a"), "A");
-    assert.equal(matcher("b"), "fallback");
-    assert.equal(matcher(1), 10);
-    assert.equal(matcher(2), "fallback");
-});
-
-test("getPrimitiveUnionMatcherPartialW also accepts an exhaustive pattern", () => {
-    // Arrange
-    const factory = getPrimitiveUnionMatcherPartialW<"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
-    // ❌ ReturnsStrict: mixed handler returns widen to their union.
-    expectTypeOf(matcher).toEqualTypeOf<(shape: "x" | "y") => 1 | "two">();
-    assert.equal(matcher("x"), 1);
-    assert.equal(matcher("y"), "two");
-});
@@ -1,71 +0,0 @@
-import type { Simplify, ValueOf } from "type-fest";
-
-type UnaryFn<T, R> = (shape: T) => R;
-
-// ============================================================================
-// ✔️ Exhaustive
-// ❌ ReturnsStrict
-// ============================================================================
-type PatternPrimitiveUnion<R, T extends string | number> = {
-    [K in T]: UnaryFn<K, R>;
-};
-
-type PatternReturns<
-    P extends Record<string | number, UnaryFn<never, unknown>>,
-> = ReturnType<ValueOf<P>>;
-
-export const getPrimitiveUnionMatcherW: <T extends string | number>() => <
-    P extends PatternPrimitiveUnion<unknown, T>,
->(
-    pattern: Simplify<P>,
-) => UnaryFn<T, PatternReturns<P>> = () => (pattern) => (shape) =>
-    // Rewrite not to use any is possible, was evaluated and solutions were
-    // more complex than the current solution.
-
-    // oxlint-disable-next-line typescript/no-explicit-any typescript/no-unsafe-type-assertion
-    (pattern[shape] as any)(shape);
-
-// ============================================================================
-// ✔️ Exhaustive
-// ✔️ ReturnsStrict
-// ============================================================================
-export const getPrimitiveUnionMatcher: <T extends string | number>() => <R>(
-    pattern: Simplify<PatternPrimitiveUnion<R, T>>,
-) => UnaryFn<T, R> = getPrimitiveUnionMatcherW;
-
-// ============================================================================
-// ❌ Exhaustive
-// ✔️ ReturnsStrict
-// ============================================================================
-type PatternPrimitiveUnionPartial<R, T extends string | number> =
-    | PatternPrimitiveUnion<R, T>
-    | (Partial<PatternPrimitiveUnion<R, T>> & {
-          _: UnaryFn<T, R>;
-      });
-
-export const getPrimitiveUnionMatcherPartial: <T extends string | number>() => <
-    R,
->(
-    pattern: Simplify<PatternPrimitiveUnionPartial<R, T>>,
-) => UnaryFn<T, R> = () => (pattern) => (shape) =>
-    // Rewrite not to use any is possible, was evaluated and solutions were
-    // more complex than the current solution.
-
-    // oxlint-disable-next-line typescript/no-explicit-any typescript/no-unsafe-type-assertion
-    (pattern[shape] ?? (pattern as any)["_"])(shape);
-
-// ============================================================================
-// ❌ Exhaustive
-// ❌ ReturnsStrict
-// ============================================================================
-export const getPrimitiveUnionMatcherPartialW: <
-    T extends string | number,
->() => <P extends PatternPrimitiveUnionPartial<unknown, T>>(
-    // `Simplify<P>` is the inference hook: callers infer `P` from the argument.
-    // the second half pins the impl parameter's `R` to `PatternReturns<P>`.
-    // that makes the `= getPrimitiveUnionMatcherPartial` assignment type-check.
-    // neither half works alone.
-    // without the witness the union's `_` arm demands `_ ∈ keyof P`.
-    // without `Simplify<P>` the parameter types do not compare.
-    pattern: Simplify<P> & PatternPrimitiveUnionPartial<PatternReturns<P>, T>,
-) => UnaryFn<T, PatternReturns<P>> = getPrimitiveUnionMatcherPartial;
@@ -0,0 +1,146 @@
+import type { Exact, UnknownRecord } from "type-fest";
+
+import type {
+    HandlerMap,
+    Matchable,
+    Member,
+    PatternKey,
+    PatternReturns,
+    RedundantFallback,
+    UnaryFn,
+    UniverseGate,
+} from "./matcher-shared.ts";
+
+// A tagged union is discriminated by one property whose values are the tags (a
+// `Matchable`). `string` and `number` tags key a handler map directly;
+// `boolean`, `null` and `undefined` are admitted too but are not property keys,
+// so they go through the `PatternKey` projection. `symbol` has no literal syntax
+// to write a handler under, and `bigint` is not a property key.
+
+// The discriminant values of `T` under `K`. `Extract` keeps the finite literal
+// tags and leaves a widened `string`/`number` as itself; a broad tag is then
+// rejected by the universe gate.
+type Tags<T extends object, K extends keyof T> = Extract<T[K], Matchable>;
+
+// 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 Matchable ? 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.
+// Keyed by `PatternKey`, so `boolean`/`null`/`undefined` tags can key a mapped
+// type; `Member` inverts the projection against the tag set to recover the
+// member.
+type MapTaggedUnion<T extends object, K extends keyof T> = {
+    [P in PatternKey<Tags<T, K>>]: Extract<T, Record<K, Member<Tags<T, K>, P>>>;
+};
+
+type Handlers<T extends object, K extends keyof T, R> = {
+    [P in PatternKey<Tags<T, K>>]: UnaryFn<MapTaggedUnion<T, K>[P], R>;
+};
+
+// The members `Handled` covers. Mapping over the projected keys 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-union matcher's
+// `Exclude<T, Member<T, keyof Handled>>`.
+type HandledMembers<T extends object, K extends keyof T, Handled> = {
+    [P in PatternKey<Tags<T, K>>]: P extends keyof Handled
+        ? MapTaggedUnion<T, K>[P]
+        : never;
+}[PatternKey<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 uncovered. 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-union matcher for why a conditional in the fallback's
+// parameter is evaluated too early.
+type MustBePartial<T extends object, K extends keyof T, Handled> =
+    PatternKey<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> & UniverseGate<Tags<T, K>>): UnaryFn<T, R>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, K, R>>, Handled> &
+            MustBePartial<T, K, Handled>,
+    >(
+        handlers: Handled &
+            Partial<Handlers<T, K, R>> &
+            UniverseGate<Tags<T, K>>,
+        fallback: Fallback<T, K, Handled, R> & UniverseGate<Tags<T, K>>,
+    ): 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 & UniverseGate<Tags<T, K>>,
+    ): UnaryFn<T, PatternReturns<P>>;
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, K, unknown>>, Handled> &
+            MustBePartial<T, K, Handled>,
+    >(
+        handlers: Handled & UniverseGate<Tags<T, K>>,
+        fallback: Fallback<T, K, Handled, R> & UniverseGate<Tags<T, K>>,
+    ): UnaryFn<T, PatternReturns<Handled> | R>;
+}
+
+// The key-taking step of the curried factory. Naming it lets the factory return
+// `dispatch` directly, the tacit twin of the primitive-union factory's bare
+// `=> dispatch`.
+type TaggedUnionMatcherFactory<T extends object> = <K extends Discriminated<T>>(
+    k: K,
+) => TaggedUnionMatcherStrict<T, K>;
+
+type TaggedUnionMatcherWideningFactory<T extends object> = <
+    K extends Discriminated<T>,
+>(
+    k: K,
+) => TaggedUnionMatcherWidening<T, K>;
+
+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 tags, and the map keys
+        // them by `PatternKey`, 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,
+>(): TaggedUnionMatcherFactory<T> => dispatch;
+
+export const getTaggedUnionMatcherW = <
+    T extends object,
+>(): TaggedUnionMatcherWideningFactory<T> => dispatch;
@@ -0,0 +1,147 @@
+import { strict as assert } from "node:assert";
+import path from "node:path";
+import { test } from "node:test";
+
+import { expectTypeOf } from "expect-type";
+
+import {
+    type CompletionResult,
+    type CompletionTarget,
+    LspSession,
+} from "#test-utils/lsp-completion.ts";
+
+const REPO_ROOT = path.resolve(import.meta.dirname, "../../..");
+
+// The `#test-utils/*` self-reference (package.json#imports) is the one route
+// scattered test files take to reach test helpers; this pins that it resolves
+// and types without starting a language server
+// (development/testing.md § Test helpers).
+test("test-helper home: `#test-utils/…` resolves to the helper and types it", () => {
+    // Arrange
+    const target: CompletionTarget = {
+        file: "src/util/__tests__/lsp-completion.ts",
+        source: "",
+    };
+
+    // Assert — no session is constructed: the constructor spawns `tsc --lsp`,
+    // so only the resolved values and their types are checked here.
+    expectTypeOf(LspSession).toBeConstructibleWith("repo-root");
+    expectTypeOf<CompletionResult>().toMatchTypeOf<{
+        labels: readonly string[];
+    }>();
+    assert.equal(typeof LspSession, "function");
+    assert.equal(target.file, "src/util/__tests__/lsp-completion.ts");
+});
+
+// The helper drives a language server, so its contract is asserted against the
+// server. Every document below is probed from memory and carries its
+// contextual type inline, so the helper is tested without the library's code.
+const probe = (source: string, marker?: string): Promise<CompletionResult> => {
+    const session = new LspSession(REPO_ROOT);
+    const target: CompletionTarget =
+        marker === undefined
+            ? { file: "src/__probe.ts", source }
+            : { file: "src/__probe.ts", source, marker };
+    return session.completionLabelsAt(target).finally(() => session.close());
+};
+
+const HANDLERS = [
+    "type Handlers = { a: () => number; b: () => number; _?: () => number };",
+    "declare const apply: (handlers: Handlers) => Handlers;",
+];
+
+test("helper: a fresh object literal completes with its contextual keys", () => {
+    // Arrange
+    const source = [
+        ...HANDLERS,
+        "const done = apply({",
+        "    /*COMPLETE*/",
+        "});",
+        "export { done };",
+    ].join("\n");
+
+    // Act
+    const probed = probe(source);
+
+    // Assert — the position is the marker's, which the helper strips
+    expectTypeOf(probed).toEqualTypeOf<Promise<CompletionResult>>();
+    return probed.then((result) => {
+        assert.deepEqual(result.position, { line: 3, character: 4 });
+        assert.deepEqual([...result.labels], ["_?", "a", "b"]);
+    });
+});
+
+test("helper: a handled key drops out of the popup", () => {
+    // Arrange
+    const source = [
+        ...HANDLERS,
+        "const done = apply({",
+        "    b: () => 1,",
+        "    /*COMPLETE*/",
+        "});",
+        "export { done };",
+    ].join("\n");
+
+    // Act
+    const probed = probe(source);
+
+    // Assert
+    expectTypeOf<CompletionResult["labels"]>().toEqualTypeOf<
+        readonly string[]
+    >();
+    return probed.then((result) => {
+        assert.deepEqual([...result.labels], ["_?", "a"]);
+    });
+});
+
+test("helper: a custom marker is located at the line start", () => {
+    // Arrange
+    const source = [
+        "type Handlers = { a: () => number; _?: () => number };",
+        "declare const apply: (handlers: Handlers) => Handlers;",
+        "const done = apply({",
+        "@@@",
+        "});",
+        "export { done };",
+    ].join("\n");
+
+    // Act
+    const probed = probe(source, "@@@");
+
+    // Assert
+    expectTypeOf(probed).resolves.toEqualTypeOf<CompletionResult>();
+    return probed.then((result) => {
+        assert.deepEqual(result.position, { line: 3, character: 0 });
+        assert.deepEqual([...result.labels], ["_?", "a"]);
+    });
+});
+
+test("helper: labels are read from the server, not from a pattern literal", () => {
+    // Arrange
+    const source = [
+        'const text = "x";',
+        "const upper = text./*COMPLETE*/;",
+        "export { upper };",
+    ].join("\n");
+
+    // Act
+    const probed = probe(source);
+
+    // Assert
+    expectTypeOf(probed).resolves.toHaveProperty("labels");
+    return probed.then((result) => {
+        assert.ok(result.labels.includes("toUpperCase"));
+    });
+});
+
+test("helper: a source without the marker rejects", () => {
+    // Arrange
+    const source = "const text = 1;\nexport { text };\n";
+
+    // Act
+    const probed = probe(source);
+
+    // Assert
+    expectTypeOf(probed).resolves.toEqualTypeOf<CompletionResult>();
+    return assert.rejects(probed, /marker not found/);
+});
@@ -0,0 +1,254 @@
+// oxlint-disable no-magic-numbers unicorn/no-null - tolerable here, this is a helper
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { pathToFileURL } from "node:url";
+
+import {
+    type CompletionItem,
+    type CompletionList,
+    CompletionRequest,
+    ConfigurationRequest,
+    createMessageConnection,
+    DidOpenTextDocumentNotification,
+    InitializedNotification,
+    InitializeRequest,
+    type MessageConnection,
+    ShutdownRequest,
+    StreamMessageReader,
+    StreamMessageWriter,
+} from "vscode-languageserver-protocol/node";
+
+/**
+ * Print the completion labels TypeScript's language server offers at a marker
+ * inside a source file.
+ *
+ * Usage: node --strip-types src/util/__tests__/lsp-completion.ts <file> [<marker>]
+ *
+ * The marker (default `DEFAULT_MARKER`, a `COMPLETE` block comment) is stripped
+ * from the source before it is sent; the request position is where the marker
+ * stood. Point it at a scratch file whose expected type is a matcher pattern to
+ * inspect the popup.
+ *
+ * `LspSession` exposes the same probe to the test suite, so completion is
+ * asserted against the server rather than the type system.
+ *
+ * Why a script and not a type assertion: completion is a contextual-type
+ * property that `expect-type` cannot observe, and `Parameters<…>` resolves only
+ * a single overload. The server is the only ground truth. See
+ * development/testing.md § Autocomplete.
+ */
+
+const DEFAULT_MARKER = "/*COMPLETE*/";
+const ARGV_PREFIX_LENGTH = 2;
+const EXIT_DELAY_MS = 200;
+const FAILURE_EXIT_CODE = 1;
+const USAGE = "usage: lsp-completion.ts <file> [<marker>]";
+
+export interface Position {
+    readonly line: number;
+    readonly character: number;
+}
+
+/** A document to probe: `source` carries `marker`, which is stripped. */
+export interface CompletionTarget {
+    /** Path relative to the session's repo root; drives URI and resolution. */
+    readonly file: string;
+    readonly source: string;
+    readonly marker?: string;
+}
+
+export interface CompletionResult {
+    readonly position: Position;
+    readonly labels: readonly string[];
+}
+
+const completionLabels = (
+    result: CompletionItem[] | CompletionList | null,
+): readonly string[] => {
+    if (result === null) {
+        return [];
+    }
+    const items = Array.isArray(result) ? result : result.items;
+    return items
+        .map((item) => item.label)
+        .toSorted((left, right) => left.localeCompare(right));
+};
+
+const markerPosition = (source: string, marker: string): Position => {
+    const index = source.indexOf(marker);
+    if (index === -1) {
+        throw new Error(`marker not found: ${marker}`);
+    }
+    const lines = source.slice(0, index).split("\n");
+    const lineIndex = lines.length - 1;
+    const line = lines[lineIndex];
+    return { line: lineIndex, character: line === undefined ? 0 : line.length };
+};
+
+/**
+ * One language server, initialized on first use, shared across probes. Callers
+ * own the lifecycle and must `close()` it.
+ */
+export class LspSession {
+    readonly #child: ChildProcessWithoutNullStreams;
+    readonly #connection: MessageConnection;
+    readonly #repoRoot: string;
+    #ready: Promise<void> | undefined;
+
+    public constructor(repoRoot: string) {
+        this.#repoRoot = repoRoot;
+        this.#child = spawn(
+            path.join(repoRoot, "node_modules", ".bin", "tsc"),
+            ["--lsp", "--stdio"],
+            { cwd: repoRoot },
+        );
+        this.#child.stderr.on("data", (chunk: Buffer) => {
+            process.stderr.write(chunk);
+        });
+        this.#connection = createMessageConnection(
+            new StreamMessageReader(this.#child.stdout),
+            new StreamMessageWriter(this.#child.stdin),
+        );
+        // Server -> client requests the server waits on: answer so it proceeds.
+        // `workspace/configuration` wants one reply per requested item; a
+        // catch-all covers the rest (e.g. `client/registerCapability`).
+        this.#connection.onRequest(ConfigurationRequest.type, ({ items }) =>
+            items.map(() => null),
+        );
+        this.#connection.onRequest(() => null);
+        this.#connection.listen();
+    }
+
+    public completionLabelsAt(
+        target: CompletionTarget,
+    ): Promise<CompletionResult> {
+        return this.#ensureInitialized()
+            .then(() => this.#open(target))
+            .then(({ uri, position }) =>
+                this.#connection
+                    .sendRequest(CompletionRequest.type, {
+                        textDocument: { uri },
+                        position,
+                        context: { triggerKind: 1 },
+                    })
+                    .then((result) => ({
+                        position,
+                        labels: completionLabels(result),
+                    })),
+            );
+    }
+
+    /** `shutdown` + close stdin, then kill the server; safe after a failed probe. */
+    public close(): Promise<void> {
+        return (
+            this.#connection
+                .sendRequest(ShutdownRequest.type)
+                // The TS 7 Go server logs a bare `context canceled` to stderr
+                // when it handles `exit`; EOF on stdin shuts it down cleanly
+                // (exit 0, no output) instead.
+                .then(() => {
+                    this.#child.stdin.end();
+                })
+                .then(() => delay(EXIT_DELAY_MS))
+                .finally(() => {
+                    this.#connection.dispose();
+                    this.#child.kill();
+                })
+        );
+    }
+
+    #ensureInitialized(): Promise<void> {
+        this.#ready ??= this.#initialize();
+        return this.#ready;
+    }
+
+    #initialize(): Promise<void> {
+        return this.#connection
+            .sendRequest(InitializeRequest.type, {
+                processId: process.pid,
+                rootUri: pathToFileURL(this.#repoRoot).href,
+                workspaceFolders: [
+                    { uri: pathToFileURL(this.#repoRoot).href, name: "repo" },
+                ],
+                capabilities: {
+                    textDocument: {
+                        completion: {
+                            completionItem: { snippetSupport: false },
+                        },
+                        publishDiagnostics: {},
+                    },
+                },
+            })
+            .then(() =>
+                this.#connection.sendNotification(
+                    InitializedNotification.type,
+                    {},
+                ),
+            );
+    }
+
+    #open(target: CompletionTarget): Promise<{
+        readonly uri: string;
+        readonly position: Position;
+    }> {
+        const absolute = path.resolve(this.#repoRoot, target.file);
+        const marker = target.marker ?? DEFAULT_MARKER;
+        const position = markerPosition(target.source, marker);
+        const text = target.source.replace(marker, "");
+        const uri = pathToFileURL(absolute).href;
+        // The server handles `didOpen` in order before the completion request,
+        // so no settle delay is needed.
+        return this.#connection
+            .sendNotification(DidOpenTextDocumentNotification.type, {
+                textDocument: {
+                    uri,
+                    languageId: "typescript",
+                    version: 1,
+                    text,
+                },
+            })
+            .then(() => ({ uri, position }));
+    }
+}
+
+const main = (args: readonly string[]): Promise<void> => {
+    const [file, markerArgument] = args;
+    if (file === undefined) {
+        process.stderr.write(`${USAGE}\n`);
+        process.exitCode = FAILURE_EXIT_CODE;
+        return Promise.resolve();
+    }
+
+    const repoRoot = path.resolve(import.meta.dirname, "../../..");
+    const absolute = path.resolve(repoRoot, file);
+    const source = fs.readFileSync(absolute, "utf8");
+    const session = new LspSession(repoRoot);
+    return session
+        .completionLabelsAt({
+            file,
+            source,
+            marker: markerArgument ?? DEFAULT_MARKER,
+        })
+        .then(({ position, labels }) => {
+            process.stdout.write(
+                `\n[${file}] completions @ ${position.line}:${position.character}:\n${labels.join(", ")}\n`,
+            );
+        })
+        .finally(() => session.close());
+};
+
+const isEntryPoint = (): boolean => {
+    const [entry] = process.argv.slice(1, 2);
+    return entry !== undefined && import.meta.url === pathToFileURL(entry).href;
+};
+
+if (isEntryPoint()) {
+    main(process.argv.slice(ARGV_PREFIX_LENGTH)).catch((error: unknown) => {
+        process.stderr.write(
+            `${error instanceof Error ? error.message : String(error)}\n`,
+        );
+        process.exitCode = FAILURE_EXIT_CODE;
+    });
+}