🚀 Release 0.5.0

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

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

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

.oxlintrc.json

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

AGENTS.md

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

CHANGELOG.md

@@ -7,7 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-- move the `_` fallback to a second argument typed `Exclude<T, keyof handlers>`, so it receives only the unhandled keys, and infer handler returns from short, unannotated handlers
+## [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
 
@@ -61,7 +68,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - basic setup
 
-[Unreleased]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.3.0...main
+[Unreleased]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.5.0...main
+[0.5.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.4.0...0.5.0
+[0.4.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.3.0...0.4.0
 [0.3.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.2.0...0.3.0
 [0.2.0]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.1.8...0.2.0
 [0.1.8]: https://gitea.e1nsnull.de/tmu/tiny-pattern-ts/compare/0.1.7...0.1.8

CONTRIBUTING.md

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

README.md

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

backlog.tasks

@@ -44,16 +44,17 @@ Matcher:
     → 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
+✔ A fallback for an already-exhaustive handler map must be a compile error @medium @done
-    → `(handlers, fallback)` with `handlers` covering all of `T` is accepted; the redundant fallback should be rejected (currying would allow the guard)
+    → 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
 
 Bugs:
 ✔ TS 7 LSP server logs `context canceled` on stderr at shutdown @done
     → `handleExit` returns `io.EOF`, cancelling the background context while `Session.updateWatches` is still in flight; the bare error is flushed to stderr and the server exits 1
     → close stdin after `shutdown` instead of sending `exit`; the server exits cleanly (code 0, no output), kill kept as a fallback
 Enhancements:
-☐ Allow boolean literals in primitive union patterns (e.g. `true: () => "yes"`) @medium
+✔ Allow boolean literals in primitive union patterns (e.g. `true: () => "yes"`) @medium @done
-☐ Are there other primitive types that should be supported in union patterns? (e.g. `bigint`, `symbol`) @medium
+    ✔ Are there other primitive types that should be supported in union patterns? (e.g. `bigint`, `symbol`) @medium @done
+        → added boolean, null and undefined; rejected `symbol` (compile-time brand, nothing at runtime) and `bigint` (not a property key)
 
 Documentation:
 ☐ Bring README.md back to its previous form — synopsis and examples restored, in the correct place

development/library.md

@@ -31,8 +31,9 @@ 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>` plus
+2. `Handled extends Exact<Partial<Handlers<T, R>>, Handled>` intersected with
-   `Fallback<T, Handled, R>` — a partial handler map plus the fallback.
+   `MustBePartial<T, Handled>`, plus `Fallback<T, Handled, R>` — a partial
+   handler map plus the fallback, rejected when the map already covers `T`.
 
 #### Why
 
@@ -41,6 +42,14 @@ Each factory is two overloads whose order is load-bearing:
   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.
@@ -57,9 +66,9 @@ Each factory is two overloads whose order is load-bearing:
 - **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)`. `Handled` is fixed before
+- **Curried handlers-first** — `(handlers)(fallback)`. Rejected: two calls for
-  the second call, so a redundant-fallback guard would work. Rejected: two calls
+  the common case. It is not needed for the redundant-fallback guard, which the
-  for the common case.
+  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.
@@ -76,14 +85,32 @@ Each factory is two overloads whose order is load-bearing:
 
 #### Known issue
 
-- A redundant fallback is accepted: when the handler map already covers `T`, the
-  fallback is still allowed. The guard would be
-  `Exclude<T, keyof Handled> extends never ? never : unknown`, but the
-  conditional is evaluated before `Handled` is inferred; currying is the only
-  encoding that fixes it (see Rejected).
 - `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).
+
+## Primitive universe
+
+#### Decision (2026-09)
+
+The universe (`Matchable`) is `string | number | boolean | null | undefined`,
+with `boolean` admitted as `true | false`.
+
+`boolean`/`null`/`undefined` are not property keys, so handler-map keys are a
+projection (`PatternKey`: each member stringified) and `PatternParam` inverts
+it, so callbacks receive the real member (`true`, not `"true"`). The popup
+offers `true`, `false`, `null`, `undefined` by name (verified over LSP).
+
+#### Why
+
+- Runtime dispatch indexes with the raw `shape`; `handlers[true]` coerces to
+  `"true"` at runtime exactly as `String` would. The `shape as string | number`
+  assertion only placates `TS2538` and buys the number fast path (an explicit
+  `String()` defeats V8's numeric-key path: measured ~2× on number-keyed
+  dispatch).
+- `symbol`/`bigint`/`NaN`/`-0` are rejected, and a member colliding with its
+  stringification is unguarded: user-facing, stated once in
+  [README § Caveats](../README.md#caveats).

development/testing.md

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

development/tooling.md

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

package-lock.json

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

package.json

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

src/primitive.test.ts

@@ -1,4 +1,3 @@
-/* oxlint-disable typescript/no-floating-promises -- expectTypeOf() is a sync type-assertion library that the type-aware linter misidentifies as a promise */
 import { strict as assert } from "node:assert";
 import path from "node:path";
 import { test } from "node:test";
@@ -24,10 +23,12 @@ test("getMatcher: exhaustive pattern infers one common return type", () => {
     const matcher = factory({
         a: (s) => {
             expectTypeOf(s).toEqualTypeOf<"a">();
+            assert.equal(s, "a");
             return 1;
         },
         b: (s) => {
             expectTypeOf(s).toEqualTypeOf<"b">();
+            assert.equal(s, "b");
             return 2;
         },
     });
@@ -49,10 +50,13 @@ test("getMatcher: dispatches on numeric literal keys", () => {
     const matcher = factory({
         1: (n) => {
             expectTypeOf(n).toEqualTypeOf<1>();
+            // A numeric key must not reach its handler as the string `"1"`.
+            assert.equal(n, 1);
             return n + 1;
         },
         2: (n) => {
             expectTypeOf(n).toEqualTypeOf<2>();
+            assert.equal(n, 2);
             return n * 10;
         },
     });
@@ -71,18 +75,22 @@ test("getMatcher: dispatches on mixed string and numeric keys", () => {
     const matcher = factory({
         a: (s) => {
             expectTypeOf(s).toEqualTypeOf<"a">();
+            assert.equal(s, "a");
             return 1;
         },
         b: (s) => {
             expectTypeOf(s).toEqualTypeOf<"b">();
+            assert.equal(s, "b");
             return 2;
         },
         1: (n) => {
             expectTypeOf(n).toEqualTypeOf<1>();
+            assert.equal(n, 1);
             return 10;
         },
         2: (n) => {
             expectTypeOf(n).toEqualTypeOf<2>();
+            assert.equal(n, 2);
             return 20;
         },
     });
@@ -95,6 +103,56 @@ test("getMatcher: dispatches on mixed string and numeric keys", () => {
     assert.equal(matcher(2), 20);
 });
 
+test("getMatcher: dispatches on boolean literals", () => {
+    // Arrange
+    const factory = getMatcher<boolean>();
+
+    // Act
+    const matcher = factory({
+        true: (s) => {
+            expectTypeOf(s).toEqualTypeOf<true>();
+            // The `true` key is a property name; the handler must still be
+            // called with the boolean `true`, not the string `"true"`.
+            assert.equal(s, true);
+            return 1;
+        },
+        false: (s) => {
+            expectTypeOf(s).toEqualTypeOf<false>();
+            assert.equal(s, false);
+            return 2;
+        },
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<(shape: boolean) => number>();
+    assert.equal(matcher(true), 1);
+    assert.equal(matcher(false), 2);
+});
+
+test("getMatcher: dispatches on null and undefined", () => {
+    // Arrange
+    const factory = getMatcher<null | undefined>();
+
+    // Act
+    const matcher = factory({
+        null: (s) => {
+            expectTypeOf(s).toEqualTypeOf<null>();
+            assert.equal(s, null);
+            return "null";
+        },
+        undefined: (s) => {
+            expectTypeOf(s).toEqualTypeOf<undefined>();
+            assert.equal(s, undefined);
+            return "undefined";
+        },
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<(shape: null | undefined) => string>();
+    assert.equal(matcher(null), "null");
+    assert.equal(matcher(undefined), "undefined");
+});
+
 // ============================================================================
 // API: getMatcher — ❌ Exhaustive (fallback) / ✔️ ReturnsStrict
 // ============================================================================
@@ -108,12 +166,14 @@ test("getMatcher: a `_` fallback receives the unhandled keys", () => {
         {
             a: (s) => {
                 expectTypeOf(s).toEqualTypeOf<"a">();
+                assert.equal(s, "a");
                 return 1 as const;
             },
         },
         (s) => {
             // The fallback sees only the keys `a` did not handle.
             expectTypeOf(s).toEqualTypeOf<"b" | "c">();
+            assert.ok(s === "b" || s === "c");
             return 2 as const;
         },
     );
@@ -136,15 +196,20 @@ test("getMatcher: a `_` fallback routes mixed string and numeric gaps", () => {
         {
             a: (s) => {
                 expectTypeOf(s).toEqualTypeOf<"a">();
+                assert.equal(s, "a");
                 return "A";
             },
             1: (n) => {
                 expectTypeOf(n).toEqualTypeOf<1>();
+                assert.equal(n, 1);
                 return "one";
             },
         },
         (s) => {
             expectTypeOf(s).toEqualTypeOf<"b" | 2>();
+            // The gap mixes a string and a number, so the number must reach the
+            // fallback as `2`, never as its key text `"2"`.
+            assert.ok(s === "b" || s === 2);
             return "fallback";
         },
     );
@@ -157,6 +222,44 @@ test("getMatcher: a `_` fallback routes mixed string and numeric gaps", () => {
     assert.equal(matcher(2), "fallback");
 });
 
+test("getMatcher: a `_` fallback receives unhandled boolean and nullish keys", () => {
+    // Arrange
+    const factory = getMatcher<"a" | true | false | null | undefined>();
+
+    // Act
+    const matcher = factory(
+        {
+            a: (s) => {
+                expectTypeOf(s).toEqualTypeOf<"a">();
+                assert.equal(s, "a");
+                return 1 as const;
+            },
+            null: (s) => {
+                expectTypeOf(s).toEqualTypeOf<null>();
+                assert.equal(s, null);
+                return 2 as const;
+            },
+        },
+        (s) => {
+            // `true` and `false` are keyed as `"true"`/`"false"` but the
+            // fallback still sees them as booleans.
+            expectTypeOf(s).toEqualTypeOf<true | false | undefined>();
+            assert.ok(s === true || s === false || s === undefined);
+            return 3 as const;
+        },
+    );
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<
+        (shape: "a" | true | false | null | undefined) => 1 | 2 | 3
+    >();
+    assert.equal(matcher("a"), 1);
+    assert.equal(matcher(true), 3);
+    assert.equal(matcher(false), 3);
+    assert.equal(matcher(null), 2);
+    assert.equal(matcher(undefined), 3);
+});
+
 // ============================================================================
 // API: getMatcherW — ✔️ Exhaustive / ❌ ReturnsStrict
 // ============================================================================
@@ -169,10 +272,12 @@ test("getMatcherW: exhaustive pattern widens to the union of handler returns", (
     const matcher = factory({
         x: (s) => {
             expectTypeOf(s).toEqualTypeOf<"x">();
+            assert.equal(s, "x");
             return 1 as const;
         },
         y: (s) => {
             expectTypeOf(s).toEqualTypeOf<"y">();
+            assert.equal(s, "y");
             return "two" as const;
         },
     });
@@ -194,18 +299,22 @@ test("getMatcherW: dispatches on mixed string and numeric keys", () => {
     const matcher = factory({
         a: (s) => {
             expectTypeOf(s).toEqualTypeOf<"a">();
+            assert.equal(s, "a");
             return "A" as const;
         },
         b: (s) => {
             expectTypeOf(s).toEqualTypeOf<"b">();
+            assert.equal(s, "b");
             return "B" as const;
         },
         1: (n) => {
             expectTypeOf(n).toEqualTypeOf<1>();
+            assert.equal(n, 1);
             return 10 as const;
         },
         2: (n) => {
             expectTypeOf(n).toEqualTypeOf<2>();
+            assert.equal(n, 2);
             return 20 as const;
         },
     });
@@ -220,6 +329,44 @@ test("getMatcherW: dispatches on mixed string and numeric keys", () => {
     assert.equal(matcher(2), 20);
 });
 
+test("getMatcherW: exhaustive boolean and nullish widen to the union", () => {
+    // Arrange
+    const factory = getMatcherW<boolean | null | undefined>();
+
+    // Act
+    const matcher = factory({
+        true: (s) => {
+            expectTypeOf(s).toEqualTypeOf<true>();
+            assert.equal(s, true);
+            return "yes" as const;
+        },
+        false: (s) => {
+            expectTypeOf(s).toEqualTypeOf<false>();
+            assert.equal(s, false);
+            return "no" as const;
+        },
+        null: (s) => {
+            expectTypeOf(s).toEqualTypeOf<null>();
+            assert.equal(s, null);
+            return 0 as const;
+        },
+        undefined: (s) => {
+            expectTypeOf(s).toEqualTypeOf<undefined>();
+            assert.equal(s, undefined);
+            return 1 as const;
+        },
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<
+        (shape: boolean | null | undefined) => "yes" | "no" | 0 | 1
+    >();
+    assert.equal(matcher(true), "yes");
+    assert.equal(matcher(false), "no");
+    assert.equal(matcher(null), 0);
+    assert.equal(matcher(undefined), 1);
+});
+
 // ============================================================================
 // API: getMatcherW — ❌ Exhaustive (fallback) / ❌ ReturnsStrict
 // ============================================================================
@@ -233,25 +380,28 @@ test("getMatcherW: a `_` fallback widens gaps into the union", () => {
         {
             x: (s) => {
                 expectTypeOf(s).toEqualTypeOf<"x">();
+                assert.equal(s, "x");
                 return 1 as const;
             },
         },
         (s) => {
             // The fallback sees only the keys `x` did not handle.
             expectTypeOf(s).toEqualTypeOf<"y" | "z">();
-            return "fallback" as const;
+            // Returning the shape verbatim lets the `Assert` block check the
+            // exact value dispatch passed.
+            return s;
         },
     );
 
     // Assert
     expectTypeOf(matcher).toEqualTypeOf<
-        (shape: "x" | "y" | "z") => 1 | "fallback"
+        (shape: "x" | "y" | "z") => 1 | "y" | "z"
     >();
     // ❌ a value outside T must not be accepted by the matcher
     expectTypeOf<"w">().not.toExtend<Parameters<typeof matcher>[0]>();
     assert.equal(matcher("x"), 1);
-    assert.equal(matcher("y"), "fallback");
+    assert.equal(matcher("y"), "y");
-    assert.equal(matcher("z"), "fallback");
+    assert.equal(matcher("z"), "z");
 });
 
 test("getMatcherW: a `_` fallback widens mixed string and numeric returns", () => {
@@ -263,28 +413,34 @@ test("getMatcherW: a `_` fallback widens mixed string and numeric returns", () =
         {
             a: (s) => {
                 expectTypeOf(s).toEqualTypeOf<"a">();
+                assert.equal(s, "a");
                 return "A" as const;
             },
             1: (n) => {
                 expectTypeOf(n).toEqualTypeOf<1>();
+                assert.equal(n, 1);
                 return 10 as const;
             },
         },
         (s) => {
             expectTypeOf(s).toEqualTypeOf<"b" | 2>();
-            return "fallback" as const;
+            // The number must arrive as `2`, not as its key text `"2"`.
+            assert.ok(s === "b" || s === 2);
+            // Returning the shape verbatim lets the `Assert` block check the
+            // exact value dispatch passed.
+            return s;
         },
     );
 
     // Assert
     // ❌ ReturnsStrict: mixed handler returns widen to their union.
     expectTypeOf(matcher).toEqualTypeOf<
-        (shape: "a" | "b" | 1 | 2) => "A" | 10 | "fallback"
+        (shape: "a" | "b" | 1 | 2) => "A" | 10 | "b" | 2
     >();
     assert.equal(matcher("a"), "A");
-    assert.equal(matcher("b"), "fallback");
+    assert.equal(matcher("b"), "b");
     assert.equal(matcher(1), 10);
-    assert.equal(matcher(2), "fallback");
+    assert.equal(matcher(2), 2);
 });
 
 // ============================================================================
@@ -309,6 +465,51 @@ test("getMatcher factory rejects patterns outside its contract", () => {
     factory({ a: () => 1 });
     // @ts-expect-error a `string` fallback does not fit the `number` handler
     factory({ a: () => 1 }, () => "x");
+    // @ts-expect-error a fallback is redundant once the map covers the universe
+    factory({ a: () => 1, b: () => 2 }, () => 0);
+});
+
+test("getMatcher factory rejects non-exhaustive boolean and nullish maps", () => {
+    // Arrange
+    const factory = getMatcher<boolean | null | undefined>();
+
+    // Act / Assert — the calls below must not compile
+    // @ts-expect-error only `true` is handled; `false`, `null`, `undefined` are not
+    factory({ true: () => 1 });
+    // @ts-expect-error `null` and `undefined` are not handled
+    factory({ true: () => 1, false: () => 2 });
+    factory(
+        // @ts-expect-error a fallback is redundant once the map covers the universe
+        {
+            true: () => 1,
+            false: () => 2,
+            null: () => 3,
+            undefined: () => 4,
+        },
+        () => 0,
+    );
+});
+
+test("getMatcher: an open universe keeps the fallback's remainder open", () => {
+    // Arrange
+    const factory = getMatcher<string>();
+
+    // Act
+    const matcher = factory({ a: () => 1 }, (s) => {
+        // The map's literal keys do not close an open universe, so the
+        // remainder stays `string` and the fallback is not redundant.
+        expectTypeOf(s).toEqualTypeOf<string>();
+        // A strict pattern fixes one `R` for every handler, so this fallback
+        // cannot return its shape; `typeof` is the strongest claim the value
+        // makes on its own — any string passes, including `""`.
+        assert.equal(typeof s, "string");
+        return 2 as const;
+    });
+
+    // Assert
+    expectTypeOf(matcher).toEqualTypeOf<(shape: string) => number>();
+    assert.equal(matcher("a"), 1);
+    assert.equal(matcher("b"), 2);
 });
 
 test("getMatcherW factory rejects patterns outside its contract", () => {
@@ -324,6 +525,8 @@ test("getMatcherW factory rejects patterns outside its contract", () => {
     });
     // @ts-expect-error a gap without a `_` fallback is not exhaustive
     factory({ x: () => 1 as const });
+    // @ts-expect-error a fallback is redundant once the map covers the universe
+    factory({ x: () => 1 as const, y: () => 2 as const }, () => 0);
 });
 
 // ============================================================================
@@ -333,7 +536,13 @@ test("getMatcherW factory rejects patterns outside its contract", () => {
 test("getMatcher: an unhandled shape throws without a fallback", () => {
     // Arrange — an open universe types its handler map as an index signature,
     // so the type system cannot prove the runtime map is exhaustive.
-    const handlers: Record<string, () => number> = { a: () => 1 };
+    const handlers: Record<string, (shape: unknown) => number> = {
+        a: (shape) => {
+            // The raw shape reaches the handler, not the property key's text.
+            assert.equal(shape, "a");
+            return 1;
+        },
+    };
     const matcher = getMatcher<string>()(handlers);
 
     // Act / Assert
@@ -341,6 +550,24 @@ test("getMatcher: an unhandled shape throws without a fallback", () => {
     assert.throws(() => matcher("b"), /Unhandled shape: b/);
 });
 
+test("getMatcher: an unhandled boolean shape throws without a fallback", () => {
+    // Arrange — an `string | boolean` universe widens its handler map to an
+    // index signature, so the runtime map's exhaustiveness is not provable.
+    const handlers: Record<string, (shape: unknown) => number> = {
+        true: (shape) => {
+            // `true` indexes the map as the property `"true"`, but the handler
+            // is still called with the boolean.
+            assert.equal(shape, true);
+            return 1;
+        },
+    };
+    const matcher = getMatcher<string | boolean>()(handlers);
+
+    // Act / Assert
+    assert.equal(matcher(true), 1);
+    assert.throws(() => matcher(false), /Unhandled shape: false/);
+});
+
 // ============================================================================
 // Autocomplete — the language server is the oracle, not the type system
 // ============================================================================
@@ -359,6 +586,7 @@ interface LabelsProbe {
     readonly name: string;
     readonly factory: "getMatcher" | "getMatcherW";
     readonly body: string;
+    readonly universe?: string;
     readonly tail?: string;
 }
 
@@ -366,6 +594,7 @@ const labelsFor = ({
     name,
     factory,
     body,
+    universe = UNIVERSE,
     tail = "",
 }: LabelsProbe): Promise<readonly string[]> => {
     const session = new LspSession(REPO_ROOT);
@@ -373,7 +602,7 @@ const labelsFor = ({
         file: `src/__autocomplete_${name}.ts`,
         source: [
             `import { ${factory} } from "./index.ts";`,
-            `const m = ${factory}<${UNIVERSE}>()({`,
+            `const m = ${factory}<${universe}>()({`,
             body,
             `}${tail});`,
             "",
@@ -489,3 +718,39 @@ test("autocomplete: `getMatcherW` also offers optional keys with a fallback", ()
         assert.deepEqual([...result], ["a?", "b?", "c?"]);
     });
 });
+
+test("autocomplete: boolean and nullish keys are offered by name", () => {
+    // Arrange
+    const name = "getMatcher_boolean_nullish";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getMatcher",
+        universe: "boolean | null | undefined",
+        body: "    /*COMPLETE*/",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["false", "null", "true", "undefined"]);
+    });
+});
+
+test("autocomplete: a handled boolean literal drops out of the popup", () => {
+    // Arrange
+    const name = "getMatcher_boolean_after_key";
+
+    // Act
+    const labels = labelsFor({
+        name,
+        factory: "getMatcher",
+        universe: "boolean | null | undefined",
+        body: "    true: () => 1,\n    /*COMPLETE*/",
+    });
+
+    // Assert
+    return labels.then((result) => {
+        assert.deepEqual([...result], ["false", "null", "undefined"]);
+    });
+});

src/primitive.ts

@@ -2,13 +2,42 @@ import type { Exact, ValueOf } from "type-fest";
 
 type UnaryFn<T, R> = (shape: T) => R;
 
+// The primitive universe a matcher can discriminate. `boolean` is admitted as
+// the pair `true | false`; see README § Caveats for the unsupported members.
+type Matchable = string | number | boolean | null | undefined;
+
+// `boolean`, `null` and `undefined` cannot be property keys, so a mapped type
+// over the universe keys each non-key member by its stringification. `Param`
+// inverts that projection, so a handler callback still receives the *real*
+// member (`true`, not `"true"`) — see README § Caveats for the limits.
+type PatternKey<T> = T extends boolean
+    ? T extends true
+        ? "true"
+        : "false"
+    : T extends null
+      ? "null"
+      : T extends undefined
+        ? "undefined"
+        : T;
+type PatternParam<K> = K extends "true"
+    ? true
+    : K extends "false"
+      ? false
+      : K extends "null"
+        ? null
+        : K extends "undefined"
+          ? undefined
+          : K;
+
 // `Extract` drops optional handlers (`undefined`) so `PatternReturns` also works
 // when `P`'s constraint has optional keys.
 type PatternReturns<P> = ReturnType<
     Extract<ValueOf<P>, (...args: never[]) => unknown>
 >;
 
-type Handlers<T extends string | number, R> = { [K in T]: UnaryFn<K, R> };
+type Handlers<T extends Matchable, R> = {
+    [K in PatternKey<T>]: UnaryFn<PatternParam<K>, R>;
+};
 
 // The fallback is a *second argument*, not a property of the handler map,
 // because its parameter is the remainder `Exclude<T, keyof Handled>` and TypeScript
@@ -16,11 +45,25 @@ type Handlers<T extends string | number, R> = { [K in T]: UnaryFn<K, R> };
 // 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 string | number, Handled, R> = UnaryFn<
+type Fallback<T extends Matchable, Handled, R> = UnaryFn<
-    Exclude<T, keyof Handled>,
+    Exclude<T, PatternParam<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.
+interface RedundantFallback {
+    readonly "every case is already handled, so the fallback is redundant": never;
+}
+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`.
@@ -29,9 +72,13 @@ type Fallback<T extends string | number, Handled, R> = UnaryFn<
 // 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 MatcherStrict<T extends string | number> {
+interface MatcherStrict<T extends Matchable> {
     <R>(handlers: Handlers<T, R>): UnaryFn<T, R>;
-    <R, Handled extends Exact<Partial<Handlers<T, R>>, Handled>>(
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, R>>, Handled> &
+            MustBePartial<T, Handled>,
+    >(
         handlers: Handled & Partial<Handlers<T, R>>,
         fallback: Fallback<T, Handled, R>,
     ): UnaryFn<T, R>;
@@ -42,11 +89,15 @@ interface MatcherStrict<T extends string | number> {
 // from the whole handler map, whose closed constraint supplies the
 // contextual/autocomplete type.
 // oxlint-disable typescript/unified-signatures
-interface MatcherWidening<T extends string | number> {
+interface MatcherWidening<T extends Matchable> {
     <P extends Exact<Handlers<T, unknown>, P>>(
         handlers: P,
     ): UnaryFn<T, PatternReturns<P>>;
-    <R, Handled extends Exact<Partial<Handlers<T, unknown>>, Handled>>(
+    <
+        R,
+        Handled extends Exact<Partial<Handlers<T, unknown>>, Handled> &
+            MustBePartial<T, Handled>,
+    >(
         handlers: Handled,
         fallback: Fallback<T, Handled, R>,
     ): UnaryFn<T, PatternReturns<Handled> | R>;
@@ -57,19 +108,27 @@ type HandlerMap = Record<string | number, UnaryFn<never, unknown> | undefined>;
 
 const dispatch =
     (handlers: HandlerMap, fallback?: UnaryFn<never, unknown>) =>
-    (shape: string | number): 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[shape] ??
+            handlers[
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+                shape as string | number
+            ] ??
             fallback ??
             (() => {
-                throw new Error(`Unhandled shape: ${shape}`);
+                throw new Error(`Unhandled shape: ${String(shape)}`);
             })
         )(
             // oxlint-disable-next-line typescript/no-unsafe-type-assertion
             shape as never,
         );
 
-export const getMatcher = <T extends string | number>(): MatcherStrict<T> =>
+export const getMatcher = <T extends Matchable>(): MatcherStrict<T> => dispatch;
-    dispatch;
+export const getMatcherW = <T extends Matchable>(): MatcherWidening<T> =>
-export const getMatcherW = <T extends string | number>(): MatcherWidening<T> =>
     dispatch;

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

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