🐛 Gate the universe to finite, literal keys

An open universe (`string`, `number`, a template literal) makes the
handler map index-like, so a partial object satisfied the exhaustive
overload and the runtime `dispatch` throw was reachable. A universe
containing a member and its stringification (`"true" | true`, `1 | "1"`)
collapsed two members onto one key.

- reject broad universes and value/stringification collisions at the
  factory, with a diagnostic naming the reason
- invert `PatternKey` against the universe (`Member<T, K>`) instead of
  `PatternParam<K>`, so a standalone `"true"` is typed `"true"`
- intersect `UniverseGate<T>` into the handler and fallback parameters,
  preserving `R` inference and the popup

src/matcher-shared.ts

@@ -1,4 +1,4 @@
-import type { ValueOf } from "type-fest";
+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
@@ -16,11 +16,11 @@ 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. `PatternParam` inverts that projection, 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.
+// 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"
@@ -30,15 +30,56 @@ export type PatternKey<T> = T extends boolean
       : T extends undefined
         ? "undefined"
         : T;
-export type PatternParam<K> = K extends "true"
-    ? true
-    : K extends "false"
-      ? false
-      : K extends "null"
-        ? null
-        : K extends "undefined"
-          ? undefined
-          : K;
+
+// 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.