fix: preserve logical mutation intent

tests/unit/runtime-adapters.test.ts

@@ -4,6 +4,7 @@ import {
   createRuntimeAdapters,
   createRuntimeHttpClient,
 } from "../../src/bootstrap/runtime-adapters.ts";
+import { createBrowserMutationIntentFactory } from "../../src/adapters/platform/browser-mutation-intent-factory.ts";
 import { TEST_HTTP_CONTRACT } from "../helpers/http-contract-fixture.ts";
 
 type Runtime = Parameters<typeof createRuntimeAdapters>[0]["runtime"];
@@ -53,6 +54,65 @@ const release: Release = {
 };
 
 describe("runtime adapter composition", () => {
+  it("creates validated intent and idempotency identities with independent UUID calls", () => {
+    const randomUUID = vi
+      .fn<() => string>()
+      .mockReturnValueOnce("intent-uuid")
+      .mockReturnValueOnce("idempotency-uuid");
+    const factory = createBrowserMutationIntentFactory({
+      randomUUID,
+      monotonicNow: () => 12.5,
+    });
+
+    const intent = factory.create({
+      operationId: "CREATE_REFERENCE_RESOURCE",
+      canonicalInputIdentity: "opaque-canonical-input",
+      requiresIdempotencyKey: true,
+    });
+
+    expect(intent).toEqual({
+      intentId: "intent-uuid",
+      operationId: "CREATE_REFERENCE_RESOURCE",
+      canonicalInputIdentity: "opaque-canonical-input",
+      idempotencyKey: "idempotency-uuid",
+      createdAtMonotonicMs: 12.5,
+    });
+    expect(Object.isFrozen(intent)).toBe(true);
+    expect(randomUUID).toHaveBeenCalledTimes(2);
+  });
+
+  it("rejects invalid or unbounded mutation intent values", () => {
+    const factory = createBrowserMutationIntentFactory({
+      randomUUID: () => "opaque-runtime-identifier",
+      monotonicNow: () => 1,
+    });
+
+    expect(() =>
+      factory.create({
+        operationId: " ",
+        canonicalInputIdentity: "valid-identity",
+        requiresIdempotencyKey: false,
+      }),
+    ).toThrow(TypeError);
+    expect(() =>
+      factory.create({
+        operationId: "CREATE_REFERENCE_RESOURCE",
+        canonicalInputIdentity: "x".repeat(16_385),
+        requiresIdempotencyKey: false,
+      }),
+    ).toThrow(TypeError);
+    expect(() =>
+      createBrowserMutationIntentFactory({
+        randomUUID: () => "opaque-runtime-identifier",
+        monotonicNow: () => -1,
+      }).create({
+        operationId: "CREATE_REFERENCE_RESOURCE",
+        canonicalInputIdentity: "valid-identity",
+        requiresIdempotencyKey: false,
+      }),
+    ).toThrow(TypeError);
+  });
+
   it("constructs the local demo seam and infrastructure adapters", async () => {
     const adapters = await createRuntimeAdapters({
       runtime,
@@ -66,6 +126,7 @@ describe("runtime adapter composition", () => {
     });
     expect(adapters.infrastructure.queryClient).toBeDefined();
     expect(adapters.infrastructure.queryInvalidation).toBeDefined();
+    expect(adapters.infrastructure.mutationIntentFactory).toBeDefined();
     expect(
       adapters.infrastructure.crossContextInvalidationStatus(),
     ).toBe("DEGRADED_LOCAL_ONLY");
@@ -81,6 +142,8 @@ describe("runtime adapter composition", () => {
     const adapters = await createRuntimeAdapters({ runtime, release, host: {} });
     const previousClient = adapters.infrastructure.queryClient;
     const previousCoordinator = adapters.infrastructure.queryInvalidation;
+    const runtimeMutationIntentFactory =
+      adapters.infrastructure.mutationIntentFactory;
     const clearPrevious = vi.spyOn(previousClient, "clear");
 
     await adapters.outputPorts.session.beginSignIn();
@@ -91,6 +154,9 @@ describe("runtime adapter composition", () => {
     expect(adapters.infrastructure.queryInvalidation).not.toBe(
       previousCoordinator,
     );
+    expect(adapters.infrastructure.mutationIntentFactory).toBe(
+      runtimeMutationIntentFactory,
+    );
 
     const clearCallsAfterReplacement = clearPrevious.mock.calls.length;
     await previousCoordinator.resetLocal();
@@ -99,6 +165,60 @@ describe("runtime adapter composition", () => {
     adapters.infrastructure.dispose();
   });
 
+  it("passes the supplied command intent unchanged and keeps private identity out of URLs and diagnostics", async () => {
+    const requests: Array<Readonly<{ url: string; headers: Headers }>> = [];
+    const fetcher = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      requests.push({
+        url: String(input),
+        headers: new Headers(init?.headers),
+      });
+      return Response.json(
+        { id: "resource-1", name: "Created resource" },
+        { status: 201 },
+      );
+    });
+    const adapters = await createRuntimeAdapters({
+      runtime,
+      release,
+      host: {},
+      fetcher,
+    });
+    await adapters.outputPorts.session.beginSignIn();
+    await vi.waitFor(() =>
+      expect(adapters.infrastructure.serverStateScope.getPhase()).toBe("READY"),
+    );
+    const intent = Object.freeze({
+      intentId: "private-intent-id",
+      operationId: "CREATE_REFERENCE_RESOURCE",
+      canonicalInputIdentity: "private-canonical-input",
+      idempotencyKey: "private-idempotency-key",
+      createdAtMonotonicMs: 42,
+    });
+
+    await expect(
+      adapters.featureInputs["reference-feature"].createResource(
+        { name: "Created resource" },
+        { intent },
+      ),
+    ).resolves.toMatchObject({ ok: true });
+
+    expect(requests).toHaveLength(1);
+    expect(requests[0]?.headers.get("Idempotency-Key")).toBe(
+      "private-idempotency-key",
+    );
+    expect(requests[0]?.url).toBe(
+      "http://localhost:8080/api/reference-resources",
+    );
+    const safeEvidence = JSON.stringify({
+      requests: requests.map((request) => request.url),
+      diagnostics: adapters.outputPorts.diagnostics.entries(),
+    });
+    expect(safeEvidence).not.toContain("private-intent-id");
+    expect(safeEvidence).not.toContain("private-canonical-input");
+    expect(safeEvidence).not.toContain("private-idempotency-key");
+    adapters.infrastructure.dispose();
+  });
+
   it("does not fail boot when Web Storage capability getters throw", async () => {
     const host: Record<string, unknown> = {};
     Object.defineProperties(host, {