chore: initialize from frontend template 4dc033c

tests/unit/query-key-codec.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  canonicalize,
+  createRuntimeIdentityRegistry,
+  runtimeIdentityToken,
+} from "../../src/contracts/query-keys.ts";
+
+const sparseValue = Array<string>(2);
+sparseValue[1] = "sparse";
+
+describe("strict server-state identity codec", () => {
+  it("is stable across plain-object key ordering without exposing input in the token", () => {
+    const left = { limit: 20, filters: { state: "open" } };
+    const right = { filters: { state: "open" }, limit: 20 };
+    expect(canonicalize(left)).toEqual(canonicalize(right));
+    const token = runtimeIdentityToken(left);
+    expect(token).toBe(runtimeIdentityToken(right));
+    expect(token).not.toContain("open");
+  });
+
+  it.each([
+    { value: { missing: undefined }, label: "undefined" },
+    { value: { number: Number.NaN }, label: "NaN" },
+    { value: { date: new Date() }, label: "Date" },
+    { value: sparseValue, label: "sparse array" },
+  ])("rejects $label", ({ value }) => {
+    expect(() => canonicalize(value)).toThrow();
+  });
+
+  it("rejects cycles and shared-reference ambiguity", () => {
+    const shared = {};
+    expect(() => canonicalize({ left: shared, right: shared })).toThrow();
+    const cycle: Record<string, unknown> = {};
+    cycle.self = cycle;
+    expect(() => canonicalize(cycle)).toThrow();
+  });
+
+  it("keeps active identity leases non-evictable and evicts released LRU rows", () => {
+    let sequence = 0;
+    const registry = createRuntimeIdentityRegistry({
+      maxEntries: 1,
+      maxCanonicalBytes: 1_024,
+      tokenFactory: () => `identity-token-${sequence++}`,
+    });
+    const first = registry.intern({ resource: "first" });
+    first.acquire();
+    expect(() => registry.intern({ resource: "second" })).toThrow(
+      "capacity exceeded",
+    );
+    expect(registry.inspect().activeLeases).toBe(1);
+
+    first.release();
+    const second = registry.intern({ resource: "second" });
+    expect(second.token).not.toBe(first.token);
+    expect(registry.inspect()).toMatchObject({
+      entries: 1,
+      activeLeases: 0,
+      closed: false,
+    });
+  });
+
+  it("fails closed when token collisions cannot be resolved", () => {
+    const registry = createRuntimeIdentityRegistry({
+      maxEntries: 2,
+      tokenFactory: () => "identity-token-fixed",
+    });
+    registry.intern({ resource: "first" });
+    expect(() => registry.intern({ resource: "second" })).toThrow(
+      "token collision",
+    );
+  });
+});