✅ Add expect-type for type-level tests

- Install expect-type@1.4.0 (devDependency)
- New src/index.test.ts exercises the public API with both runtime
  assertions (node:assert/strict inside node:test) and type-level
  assertions (expectTypeOf().toEqualTypeOf, toMatchTypeOf, toHaveProperty)
- Tests are excluded from tsc -p tsconfig.build.json (no .d.ts pollution
  in dist/)
- Type-level checks happen during tsc --noEmit (run by 'npm run check' and
  the test script); expectTypeOf assertions have no runtime side effect,
  so they pair naturally with node --test in the same test() blocks
- cspell: add EDITMSG to dictionary (used in commit-message-template path)
- oxlint test-file overrides: silence no-nodejs-modules (we use node:
  builtins) and no-magic-numbers (literals in tests are fine)

Coverage:
- match() returns a builder with with/exhaustive/otherwise
- P.literal narrows to its literal type, P.type to its typeof target
- exhaustive() returns the union of handler return types
- otherwise() falls back when no case matches
- exhaustive() throws when no case matches

src/index.test.ts

@@ -0,0 +1,53 @@
+import { test } from "node:test";
+import { strict as assert } from "node:assert";
+import { expectTypeOf } from "expect-type";
+import { match, P, type Matcher } from "./index.js";
+
+test("match returns a builder", () => {
+    const builder = match("x");
+    expectTypeOf(builder).toHaveProperty("with");
+    expectTypeOf(builder).toHaveProperty("exhaustive");
+    expectTypeOf(builder).toHaveProperty("otherwise");
+});
+
+test("P.literal narrows to its literal type", () => {
+    const matcher = P.literal("yes");
+    expectTypeOf(matcher).toMatchTypeOf<Matcher<"yes">>();
+    assert.equal(matcher.matches("yes"), true);
+    assert.equal(matcher.matches("no"), false);
+});
+
+test("P.type narrows to the typeof target", () => {
+    const matcher = P.type<string>("string");
+    expectTypeOf(matcher).toMatchTypeOf<Matcher<string>>();
+    assert.equal(matcher.matches("hi"), true);
+    assert.equal(matcher.matches(42), false);
+});
+
+test("exhaustive() returns the union of handler return types", () => {
+    const result = match<"a" | "b">("a" as "a" | "b")
+        .with(P.literal("a"), () => 1 as const)
+        .with(P.literal("b"), () => "two" as const)
+        .exhaustive();
+
+    expectTypeOf(result).toEqualTypeOf<1 | "two">();
+    assert.equal(result, 1);
+});
+
+test("otherwise() falls back when no case matches", () => {
+    const result = match<"x" | "y" | "z">("z" as "x" | "y" | "z")
+        .with(P.literal("x"), (v): string => `got ${v}`)
+        .otherwise((v): string => `fallback ${v}`);
+    assert.equal(result, "fallback z");
+});
+
+test("exhaustive throws when no case matches", () => {
+    assert.throws(
+        () =>
+            match<"a" | "b" | "c">("c" as "a" | "b" | "c")
+                .with(P.literal("a"), () => "A")
+                .with(P.literal("b"), () => "B")
+                .exhaustive(),
+        /no matching case/,
+    );
+});