stitchkit 0.92.0 → 0.94.0

package/dist/{testing.js → entrypoints/testing.js}

@@ -1,909 +1,77 @@
 import {
   createApplication
-} from "./index-a11g2kry.js";
-import"./index-3gye9wzb.js";
-import"./index-2k4yrqkc.js";
-import"./index-3z73fh2c.js";
-import {
-  createMemoryAgentRuntimeStore
-} from "./index-hrbajay7.js";
-import {
-  decodeAgentConversationArchive
-} from "./index-zwkgfq1s.js";
-import {
-  AgentMessageSchema,
-  AgentRunSchema
-} from "./index-gtj3zc53.js";
-import {
-  createAgentRaceBarrier,
-  createAgentRaceDriver,
-  createAgentRaceTrace
-} from "./index-cnyk6te3.js";
+} from "../index-fdp6hdxn.js";
+import"../index-3gye9wzb.js";
+import"../index-2k4yrqkc.js";
+import"../index-3z73fh2c.js";
 import {
   RealtimeRejectDirectionSchema,
   RealtimeRejectFaultSchema,
   RealtimeRejectPhaseSchema,
   RealtimeRejectReasonSchema
-} from "./index-p7hgdyhb.js";
+} from "../index-p7hgdyhb.js";
 import {
   createClient,
   createClients
-} from "./index-yewwh1w4.js";
+} from "../index-e87kakm4.js";
 import {
   RealtimeRequestDisconnectedError,
   RealtimeRequestInvalidAcknowledgementError,
   RealtimeRequestTimeoutError
-} from "./index-2qzskm8h.js";
-import"./index-v5573g1k.js";
-import"./index-3xwxfj4z.js";
-import {
-  compareCodepoints,
-  serializeCanonicalJson
-} from "./index-0j3vcp5m.js";
-import"./index-e0znv5gn.js";
+} from "../index-2qzskm8h.js";
+import"../index-48ffdxgk.js";
+import"../index-wqgjfstn.js";
+import"../index-zeemqhqx.js";
 import {
+  TOOL_TRANSPORTS,
   joinRoutePath
-} from "./index-0a349c33.js";
-import"./index-rxfy4cq7.js";
-import"./index-6k1937bx.js";
-import"./index-zcgf3gqf.js";
+} from "../index-gyr48nzg.js";
+import"../index-zcgf3gqf.js";
 import {
   mcpProjectionCandidate,
   prepareProjectedMcpTools,
   projectToolSurface,
   staticInputRounds
-} from "./index-h9etkkyk.js";
+} from "../index-dydjcp8z.js";
 import {
   toJsonSchema
-} from "./index-cby4ar3v.js";
-import"./index-2vtcmrj9.js";
-import"./index-kzfs85xp.js";
+} from "../index-eqqvgdb3.js";
+import"../index-znfs20ss.js";
+import"../index-p5r7qpdd.js";
+import"../index-2vtcmrj9.js";
+import {
+  compareCodeUnits,
+  serializeCanonicalJson
+} from "../index-k5hsfc3j.js";
+import"../index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-77fekveh.js";
-// src/testing/agent-store-conformance.ts
-function userMessage(conversationId, id) {
-  return AgentMessageSchema.parse({
-    schemaVersion: 1,
-    id,
-    conversationId,
-    role: "user",
-    status: "committed",
-    parts: [{ type: "text", text: id }],
-    createdAt: "2026-08-22T00:00:00.000Z",
-    updatedAt: "2026-08-22T00:00:00.000Z"
-  });
-}
-function queuedRun(conversationId, inputMessageId, id) {
-  return AgentRunSchema.parse({
-    schemaVersion: 1,
-    id,
-    conversationId,
-    inputMessageIds: [inputMessageId],
-    assistantMessageId: `${id}-assistant`,
-    state: "queued",
-    revision: 0,
-    createdAt: "2026-08-22T00:00:00.000Z",
-    updatedAt: "2026-08-22T00:00:00.000Z"
-  });
-}
-function requireOutcome(actual, expected) {
-  if (actual.outcome !== expected) {
-    throw new Error(`Agent store conformance expected ${expected}, received ${actual.outcome}`);
-  }
-}
-async function runAgentStoreConformance(config) {
-  const run = `conformance-${crypto.randomUUID()}`;
-  const context = {
-    conversationIds: [
-      run,
-      `${run}-recovery`,
-      `${run}-absorb`,
-      `${run}-causal-history`,
-      `${run}-causal-active`,
-      `${run}-interrupt-priority`,
-      `${run}-ledger`,
-      `${run}-archive`,
-      `${run}-seed`
-    ]
-  };
-  const store = await config.createStore(context);
-  let failure;
-  try {
-    await conformanceScenario(store, context.conversationIds);
-  } catch (error) {
-    failure = error;
-  }
-  try {
-    await config.cleanup?.(context);
-  } catch (cleanupError) {
-    if (failure === undefined)
-      throw cleanupError;
-    throw new AggregateError([failure, cleanupError], `${failure instanceof Error ? failure.message : String(failure)} (cleanup also failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)})`);
+} from "../index-hffjpmq9.js";
+
+// src/testing/handler-clients.ts
+function resolveTestBaseUrl(origin, pathPrefix) {
+  const base = new URL(origin ?? "http://stitchkit.test");
+  if (base.pathname !== "/" || base.search || base.hash) {
+    throw new TypeError("Handler test client origin must contain only an absolute origin");
   }
-  if (failure !== undefined)
-    throw failure;
+  const prefix = pathPrefix?.replace(/^\/+|\/+$/g, "");
+  return prefix ? `${base.origin}/${prefix}` : base.origin;
 }
-async function seedScenario(store, conversationId) {
-  const input = {
-    conversationId,
-    seedKey: "brief",
-    inputs: [userMessage(conversationId, "seed-a"), userMessage(conversationId, "seed-b")]
-  };
-  const first = await store.seedConversationInput(input);
-  requireOutcome(first, "applied");
-  const before = await store.loadSnapshot(conversationId);
-  if (before.messages.map((message) => message.id).join(",") !== "seed-a,seed-b")
-    throw new Error("Seed conformance: complete ordered seed missing");
-  await Promise.all([store.seedConversationInput(input), store.seedConversationInput(input)]);
-  const repeated = await store.loadSnapshot(conversationId);
-  if (repeated.version !== before.version || repeated.messages.length !== 2)
-    throw new Error("Seed conformance: replay changed history");
-  const compacted = await store.replaceCompactedRange({
-    conversationId,
-    expectedVersion: repeated.version,
-    replacedMessageIds: ["seed-a", "seed-b"],
-    summary: AgentMessageSchema.parse({
-      ...userMessage(conversationId, "seed-summary"),
-      role: "summary"
-    })
-  });
-  requireOutcome(compacted, "applied");
-  await store.seedConversationInput(input);
-  const after = await store.loadSnapshot(conversationId);
-  if (after.messages.some((message) => message.id === "seed-a" || message.id === "seed-b"))
-    throw new Error("Seed conformance: compacted instructions resurrected");
+function createHandlerFetch(handler, server) {
+  return async (input, init) => handler(new Request(input, init), server);
 }
-async function conformanceScenario(store, conversationIds) {
-  const [
-    conversationId,
-    recoveryConversationId,
-    absorbConversationId,
-    causalHistoryConversationId,
-    causalActiveConversationId,
-    interruptPriorityConversationId,
-    ledgerConversationId,
-    archiveConversationId,
-    seedConversationId
-  ] = conversationIds;
-  if (seedConversationId)
-    await seedScenario(store, seedConversationId);
-  if (ledgerConversationId)
-    await ledgerScenario(store, ledgerConversationId);
-  if (archiveConversationId)
-    await archiveScenario(store, archiveConversationId);
-  if (!conversationId || !recoveryConversationId || !absorbConversationId || !causalHistoryConversationId || !causalActiveConversationId || !interruptPriorityConversationId) {
-    throw new Error("Agent store conformance requires six conversation identities");
-  }
-  const absentConversationId = `${conversationId}-absent`;
-  const firstInput = userMessage(conversationId, "input-1");
-  const firstRun = queuedRun(conversationId, firstInput.id, "run-1");
-  const accepted = await store.acceptInputAndAssignRun({
-    idempotencyKey: "request-1",
-    input: firstInput,
-    run: firstRun
-  });
-  requireOutcome(accepted, "applied");
-  const duplicate = await store.acceptInputAndAssignRun({
-    idempotencyKey: "request-1",
-    input: userMessage(conversationId, "discarded-input"),
-    run: queuedRun(conversationId, "discarded-input", "discarded-run")
-  });
-  requireOutcome(duplicate, "duplicate");
-  if (duplicate.input.id !== firstInput.id || duplicate.inputMessageId !== firstInput.id || duplicate.runId !== firstRun.id || duplicate.assistantMessageId !== firstRun.assistantMessageId) {
-    throw new Error("Duplicate admission did not return its original durable identity");
-  }
-  const secondInput = userMessage(conversationId, "input-2");
-  const coalesced = await store.acceptInputAndAssignRun({
-    idempotencyKey: "request-2",
-    input: secondInput,
-    run: queuedRun(conversationId, secondInput.id, "discarded-coalesced-run"),
-    coalesceIntoRunId: firstRun.id
-  });
-  requireOutcome(coalesced, "applied");
-  const assigned = coalesced.snapshot.runs.find((run) => run.id === firstRun.id);
-  if (assigned?.inputMessageIds.join(",") !== "input-1,input-2") {
-    throw new Error("Coalesced admission did not preserve ordered input identities");
-  }
-  const collidingInput = userMessage(conversationId, assigned.assistantMessageId);
-  await store.acceptInputAndAssignRun({
-    idempotencyKey: "request-collision",
-    input: collidingInput,
-    run: queuedRun(conversationId, collidingInput.id, "discarded-collision-run"),
-    coalesceIntoRunId: assigned.id
-  }).then(() => {
-    throw new Error("Coalesced input reused the reserved assistant identity");
-  }, (error) => {
-    if (!(error instanceof TypeError))
-      throw error;
-  });
-  await store.replaceCompactedRange({
-    conversationId,
-    expectedVersion: coalesced.snapshot.version,
-    replacedMessageIds: [firstInput.id, secondInput.id],
-    summary: AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: assigned.assistantMessageId,
-      conversationId,
-      role: "summary",
-      status: "committed",
-      parts: [{ type: "text", text: "invalid reserved identity" }],
-      createdAt: "2026-08-22T00:00:02.000Z",
-      updatedAt: "2026-08-22T00:00:02.000Z"
-    })
-  }).then(() => {
-    throw new Error("Compaction reused a reserved assistant identity");
-  }, (error) => {
-    if (!(error instanceof TypeError))
-      throw error;
-  });
-  const compacted = await store.replaceCompactedRange({
-    conversationId,
-    expectedVersion: coalesced.snapshot.version,
-    replacedMessageIds: [firstInput.id, secondInput.id],
-    summary: AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: "summary-1",
-      conversationId,
-      role: "summary",
-      status: "committed",
-      parts: [{ type: "text", text: "two inputs" }],
-      createdAt: "2026-08-22T00:00:02.000Z",
-      updatedAt: "2026-08-22T00:00:02.000Z"
-    })
-  });
-  requireOutcome(compacted, "applied");
-  const duplicateAfterCompaction = await store.acceptInputAndAssignRun({
-    idempotencyKey: "request-1",
-    input: userMessage(conversationId, "discarded-after-compaction"),
-    run: queuedRun(conversationId, "discarded-after-compaction", "discarded-run-2")
-  });
-  requireOutcome(duplicateAfterCompaction, "duplicate");
-  if (duplicateAfterCompaction.input.id !== firstInput.id) {
-    throw new Error("Compaction discarded the canonical duplicate admission input");
-  }
-  const acquired = await store.acquireRun({
-    conversationId,
-    runId: assigned.id,
-    expectedRevision: assigned.revision,
-    ownerId: "conformance-owner"
-  });
-  requireOutcome(acquired, "applied");
-  const running = acquired.snapshot.runs.find((run) => run.id === assigned.id);
-  if (!running)
-    throw new Error("Acquired run disappeared");
-  const stale = await store.checkpointRunAssistant({
-    conversationId,
-    runId: running.id,
-    expectedRevision: running.revision - 1,
-    ownerId: "conformance-owner",
-    assistant: AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: running.assistantMessageId,
-      conversationId,
-      runId: running.id,
-      role: "assistant",
-      status: "streaming",
-      parts: [],
-      createdAt: "2026-08-22T00:00:00.000Z",
-      updatedAt: "2026-08-22T00:00:01.000Z"
-    })
-  });
-  requireOutcome(stale, "conflict");
-  await store.recoverRun({
-    conversationId,
-    runId: running.id,
-    expectedRevision: running.revision,
-    action: "requeue"
-  }).then(() => {
-    throw new Error("Acquired recovery replayed without explicit safety evidence");
-  }, (error) => {
-    if (!(error instanceof TypeError))
-      throw error;
-  });
-  const checkpoint = await store.checkpointRunAssistant({
-    conversationId,
-    runId: running.id,
-    expectedRevision: running.revision,
-    ownerId: "conformance-owner",
-    assistant: AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: running.assistantMessageId,
-      conversationId,
-      runId: running.id,
-      role: "assistant",
-      status: "streaming",
-      parts: [{ type: "text", text: "checkpoint" }],
-      createdAt: "2026-08-22T00:00:00.000Z",
-      updatedAt: "2026-08-22T00:00:01.000Z"
-    }),
-    usage: {
-      inputTokens: { value: 1000, provenance: "provider-reported" },
-      outputTokens: { value: 100, provenance: "provider-reported" },
-      cost: { value: 0.25, currency: "USD", provenance: "provider-reported" }
-    }
-  });
-  requireOutcome(checkpoint, "applied");
-  const checkpointedRun = checkpoint.snapshot.runs.find((run) => run.id === running.id);
-  if (!checkpointedRun)
-    throw new Error("Checkpointed run disappeared");
-  if (checkpointedRun.usage?.cost?.value !== 0.25) {
-    throw new Error("Checkpoint did not persist the run usage it was given");
-  }
-  const terminalAssistant = AgentMessageSchema.parse({
-    schemaVersion: 1,
-    id: running.assistantMessageId,
-    conversationId,
-    runId: running.id,
-    role: "assistant",
-    status: "completed",
-    parts: [{ type: "text", text: "done" }],
-    createdAt: "2026-08-22T00:00:00.000Z",
-    updatedAt: "2026-08-22T00:00:02.000Z"
-  });
-  if (checkpointedRun.fencingToken === undefined) {
-    throw new Error("Acquisition must persist a fencing token the store can read back");
-  }
-  const staleFence = await store.checkpointRunAssistant({
-    conversationId,
-    runId: running.id,
-    expectedRevision: checkpointedRun.revision,
-    ownerId: "conformance-owner",
-    fencingToken: checkpointedRun.fencingToken + 1,
-    assistant: AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: running.assistantMessageId,
-      conversationId,
-      runId: running.id,
-      role: "assistant",
-      status: "streaming",
-      parts: [{ type: "text", text: "stale fence" }],
-      createdAt: "2026-08-22T00:00:00.000Z",
-      updatedAt: "2026-08-22T00:00:01.500Z"
-    })
-  });
-  if (staleFence.outcome !== "conflict") {
-    throw new Error("A checkpoint with a stale fencing token must conflict");
-  }
-  const foreignOwner = await store.checkpointRunAssistant({
-    conversationId,
-    runId: running.id,
-    expectedRevision: checkpointedRun.revision,
-    ownerId: "a-different-runtime",
-    assistant: AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: running.assistantMessageId,
-      conversationId,
-      runId: running.id,
-      role: "assistant",
-      status: "streaming",
-      parts: [{ type: "text", text: "foreign owner" }],
-      createdAt: "2026-08-22T00:00:00.000Z",
-      updatedAt: "2026-08-22T00:00:01.700Z"
-    })
-  });
-  if (foreignOwner.outcome !== "conflict") {
-    throw new Error("A checkpoint from another owner must conflict");
-  }
-  const liveView = await store.loadRun({ conversationId, runId: running.id });
-  if (!liveView)
-    throw new Error("loadRun must find a run of this conversation");
-  if (liveView.run.id !== running.id || liveView.run.conversationId !== conversationId) {
-    throw new Error("loadRun returned a run it was not asked for");
-  }
-  if (liveView.run.revision !== checkpointedRun.revision) {
-    throw new Error("loadRun must return the run as the last mutation left it");
-  }
-  if (liveView.run.usage?.cost?.value !== 0.25) {
-    throw new Error("loadRun must carry the figure the run has spent so far");
-  }
-  if (liveView.snapshotVersion !== checkpoint.snapshot.version) {
-    throw new Error("loadRun must report the conversation version it read at");
-  }
-  if (liveView.assistant !== undefined) {
-    throw new Error("loadRun must not report a terminal answer for a live run");
-  }
-  if (await store.loadRun({ conversationId, runId: "no-such-run" })) {
-    throw new Error("loadRun must return undefined for an unknown run");
-  }
-  if (await store.loadRun({ conversationId: absentConversationId, runId: running.id })) {
-    throw new Error("loadRun must not cross conversation boundaries");
-  }
-  const activeRuns = await store.listActiveRuns(conversationId);
-  if (!activeRuns.some((run) => run.id === running.id)) {
-    throw new Error("listActiveRuns must report a run that is in flight");
-  }
-  if (activeRuns.some((run) => run.terminalReason !== undefined)) {
-    throw new Error("listActiveRuns must not report a run that has ended");
-  }
-  for (let index = 1;index < activeRuns.length; index += 1) {
-    const previous = activeRuns[index - 1];
-    const current = activeRuns[index];
-    if (!previous || !current)
-      continue;
-    const ordered = previous.createdAt === current.createdAt ? previous.id.localeCompare(current.id) < 0 : previous.createdAt < current.createdAt;
-    if (!ordered) {
-      throw new Error("listActiveRuns must order by createdAt and then by id");
-    }
-  }
-  if ((await store.listActiveRuns(absentConversationId)).length !== 0) {
-    throw new Error("listActiveRuns must be empty for an unknown conversation");
-  }
-  const recoverable = await store.scanRecoverable({ limit: 10 });
-  if (!recoverable.items.some((item) => item.run.id === running.id)) {
-    throw new Error("A running run must appear in a recoverable scan");
-  }
-  const operation = await store.recordRunOperation({
-    conversationId,
-    runId: running.id,
-    expectedRevision: checkpointedRun.revision,
-    ownerId: "conformance-owner",
-    fencingToken: checkpointedRun.fencingToken,
-    operation: {
-      operationId: "model-call-1:0",
-      kind: "model-request",
-      phase: "first-output",
-      step: 0,
-      startedAt: "2026-08-22T00:00:01.800Z",
-      firstOutputAt: "2026-08-22T00:00:01.900Z"
-    }
-  });
-  requireOutcome(operation, "applied");
-  const operatedRun = operation.snapshot.runs.find((run) => run.id === running.id);
-  if (operatedRun?.lastOperation?.operationId !== "model-call-1:0") {
-    throw new Error("Run operation identity did not survive its durable mutation");
-  }
-  const operatedView = await store.loadRun({ conversationId, runId: running.id });
-  if (operatedView?.run.lastOperation?.startedAt !== "2026-08-22T00:00:01.800Z") {
-    throw new Error("loadRun did not retain the original operation timestamp");
-  }
-  const interrupted = await store.requestRunInterrupt({
-    conversationId,
-    runId: running.id,
-    expectedRevision: operatedRun.revision
-  });
-  requireOutcome(interrupted, "applied");
-  const interruptedRun = interrupted.snapshot.runs.find((run) => run.id === running.id);
-  if (interruptedRun?.state !== "interrupt_requested") {
-    throw new Error("A durable interrupt must move the run to interrupt_requested");
-  }
-  if (interruptedRun.usage?.cost?.value !== 0.25) {
-    throw new Error("An interrupt must not discard the figure the run had already spent");
-  }
-  const terminalUsage = {
-    inputTokens: { value: 3000, provenance: "computed" },
-    outputTokens: { value: 300, provenance: "computed" },
-    reasoningTokens: { value: 30, provenance: "computed" },
-    cacheReadTokens: { value: 200, provenance: "computed" },
-    cacheWriteTokens: { value: 100, provenance: "computed" },
-    cost: { value: 1.5, currency: "USD", provenance: "computed" }
+function createTestClientConfig(config) {
+  return {
+    ...config.client,
+    baseUrl: resolveTestBaseUrl(config.origin, config.pathPrefix),
+    fetch: createHandlerFetch(config.handler, config.server)
   };
-  const terminalResults = await Promise.all([
-    store.commitRunTerminal({
-      conversationId,
-      runId: running.id,
-      expectedRevision: interruptedRun.revision,
-      ownerId: "conformance-owner",
-      assistant: terminalAssistant,
-      reason: "success",
-      usage: terminalUsage
-    }),
-    store.commitRunTerminal({
-      conversationId,
-      runId: running.id,
-      expectedRevision: interruptedRun.revision,
-      ownerId: "conformance-owner",
-      assistant: terminalAssistant,
-      reason: "success",
-      usage: terminalUsage
-    })
-  ]);
-  const terminalOutcomes = terminalResults.map((result) => result.outcome).sort();
-  if (terminalOutcomes.join(",") !== "applied,conflict") {
-    throw new Error(`Terminal race was not linearized: ${terminalOutcomes.join(",")}`);
-  }
-  const terminalApplied = terminalResults.find((result) => result.outcome === "applied");
-  if (terminalApplied?.outcome !== "applied") {
-    throw new Error("Terminal race produced no applied result");
-  }
-  const settledRun = terminalApplied.snapshot.runs.find((run) => run.id === running.id);
-  if (JSON.stringify(settledRun?.usage) !== JSON.stringify(terminalUsage)) {
-    throw new Error("Terminal commit did not persist the run usage it was given");
-  }
-  const terminalView = await store.loadRun({ conversationId, runId: running.id });
-  if (terminalView?.run.terminalReason !== "success") {
-    throw new Error("loadRun must report the terminal reason a settled run ended with");
-  }
-  if (JSON.stringify(terminalView.run.usage) !== JSON.stringify(terminalUsage)) {
-    throw new Error("loadRun must return every persisted terminal usage field");
-  }
-  if (JSON.stringify(terminalView.assistant) !== JSON.stringify(terminalAssistant)) {
-    throw new Error("loadRun must retain the answer a settled run produced");
-  }
-  if ((await store.listActiveRuns(conversationId)).some((run) => run.id === running.id)) {
-    throw new Error("listActiveRuns must drop a run once it has ended");
-  }
-  const compactedTerminal = await store.replaceCompactedRange({
-    conversationId,
-    expectedVersion: terminalApplied.snapshot.version,
-    replacedMessageIds: ["summary-1", terminalAssistant.id],
-    summary: AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: "summary-2",
-      conversationId,
-      role: "summary",
-      status: "committed",
-      parts: [{ type: "text", text: "terminal history" }],
-      createdAt: "2026-08-22T00:00:03.000Z",
-      updatedAt: "2026-08-22T00:00:03.000Z"
-    })
-  });
-  requireOutcome(compactedTerminal, "applied");
-  const duplicateTerminal = await store.acceptInputAndAssignRun({
-    idempotencyKey: "request-1",
-    input: userMessage(conversationId, "discarded-terminal-input"),
-    run: queuedRun(conversationId, "discarded-terminal-input", "discarded-terminal-run")
-  });
-  requireOutcome(duplicateTerminal, "duplicate");
-  if (duplicateTerminal.run.terminalReason !== "success" || JSON.stringify(duplicateTerminal.assistant) !== JSON.stringify(terminalAssistant)) {
-    throw new Error("Compaction discarded the canonical duplicate terminal result");
-  }
-  const recoveryInput = userMessage(recoveryConversationId, "recovery-input");
-  const recoveryRun = queuedRun(recoveryConversationId, recoveryInput.id, "recovery-run");
-  const recoveryAccepted = await store.acceptInputAndAssignRun({
-    idempotencyKey: "recovery-request",
-    input: recoveryInput,
-    run: recoveryRun
-  });
-  requireOutcome(recoveryAccepted, "applied");
-  const recoveryAssigned = recoveryAccepted.snapshot.runs.find((run) => run.id === recoveryRun.id);
-  if (!recoveryAssigned)
-    throw new Error("Recovery run disappeared after admission");
-  const recoveryAcquired = await store.acquireRun({
-    conversationId: recoveryConversationId,
-    runId: recoveryAssigned.id,
-    expectedRevision: recoveryAssigned.revision,
-    ownerId: "abandoned-owner"
-  });
-  requireOutcome(recoveryAcquired, "applied");
-  const abandonedRun = recoveryAcquired.snapshot.runs.find((run) => run.id === recoveryRun.id);
-  if (!abandonedRun)
-    throw new Error("Recovery run disappeared after acquisition");
-  const abandoned = await store.recoverRun({
-    conversationId: recoveryConversationId,
-    runId: abandonedRun.id,
-    expectedRevision: abandonedRun.revision,
-    action: "abandon"
-  });
-  requireOutcome(abandoned, "applied");
-  const terminalRun = abandoned.snapshot.runs.find((run) => run.id === abandonedRun.id);
-  const terminalMessage = abandoned.snapshot.messages.find((message) => message.id === abandonedRun.assistantMessageId);
-  if (terminalRun?.state !== "abandoned" || terminalMessage?.status !== "failed") {
-    throw new Error("Abandon recovery did not atomically terminalize its assistant record");
-  }
-  const abandonedView = await store.loadRun({
-    conversationId: recoveryConversationId,
-    runId: abandonedRun.id
-  });
-  if (abandonedView?.run.state !== "abandoned" || abandonedView.run.terminalReason !== "abandoned" || abandonedView.assistant?.status !== "failed") {
-    throw new Error("The canonical run record disagrees with its abandoned index projection");
-  }
-  const afterAbandon = await store.scanRecoverable({ limit: 100 });
-  if (afterAbandon.items.some((item) => item.run.id === abandonedRun.id)) {
-    throw new Error("The recoverable index still exposes a canonically abandoned run");
-  }
-  await assertCausalHistoryOrder(store, causalHistoryConversationId);
-  await assertActiveRunCausalOrder(store, causalActiveConversationId);
-  await assertInterruptPriorityOrder(store, interruptPriorityConversationId);
-  await assertAbsorptionIsAtomic(store, absorbConversationId);
-}
-async function assertInterruptPriorityOrder(store, conversationId) {
-  const inputs = ["priority-a", "priority-b", "priority-c"].map((id) => userMessage(conversationId, id));
-  const [inputA, inputB, inputC] = inputs;
-  if (!inputA || !inputB || !inputC)
-    throw new Error("Priority fixture is incomplete");
-  const runA = queuedRun(conversationId, inputA.id, "priority-run-a");
-  const runB = queuedRun(conversationId, inputB.id, "priority-run-b");
-  const runC = AgentRunSchema.parse({
-    ...queuedRun(conversationId, inputC.id, "priority-run-c"),
-    queuePriority: "interrupt-next"
-  });
-  requireOutcome(await store.acceptInputAndAssignRun({ idempotencyKey: runA.id, input: inputA, run: runA }), "applied");
-  const acquiredA = await store.acquireRun({
-    conversationId,
-    runId: runA.id,
-    expectedRevision: runA.revision,
-    ownerId: "priority-owner-a"
-  });
-  requireOutcome(acquiredA, "applied");
-  const runningA = acquiredA.snapshot.runs.find((run) => run.id === runA.id);
-  if (!runningA)
-    throw new Error("Priority lead run disappeared after acquisition");
-  requireOutcome(await store.acceptInputAndAssignRun({ idempotencyKey: runB.id, input: inputB, run: runB }), "applied");
-  requireOutcome(await store.acceptInputAndAssignRun({ idempotencyKey: runC.id, input: inputC, run: runC }), "applied");
-  const active = await store.listActiveRuns(conversationId);
-  if (active.map((run) => run.id).join(",") !== `${runA.id},${runC.id},${runB.id}`) {
-    throw new Error("Active runs did not place urgent work before ordinary pending work");
-  }
-  requireOutcome(await store.acquireRun({
-    conversationId,
-    runId: runB.id,
-    expectedRevision: runB.revision,
-    ownerId: "priority-owner-b"
-  }), "conflict");
-  const abandonedA = await store.recoverRun({
-    conversationId,
-    runId: runA.id,
-    expectedRevision: runningA.revision,
-    action: "abandon"
-  });
-  requireOutcome(abandonedA, "applied");
-  const queuedC = abandonedA.snapshot.runs.find((run) => run.id === runC.id);
-  if (!queuedC)
-    throw new Error("Urgent run disappeared after predecessor settlement");
-  const acquiredC = await store.acquireRun({
-    conversationId,
-    runId: runC.id,
-    expectedRevision: queuedC.revision,
-    ownerId: "priority-owner-c"
-  });
-  requireOutcome(acquiredC, "applied");
-  const runningC = acquiredC.snapshot.runs.find((run) => run.id === runC.id);
-  if (!runningC)
-    throw new Error("Urgent run disappeared after acquisition");
-  requireOutcome(await store.acquireRun({
-    conversationId,
-    runId: runB.id,
-    expectedRevision: runB.revision,
-    ownerId: "priority-owner-b"
-  }), "conflict");
-  const abandonedC = await store.recoverRun({
-    conversationId,
-    runId: runC.id,
-    expectedRevision: runningC.revision,
-    action: "abandon"
-  });
-  requireOutcome(abandonedC, "applied");
-  const queuedB = abandonedC.snapshot.runs.find((run) => run.id === runB.id);
-  if (!queuedB)
-    throw new Error("Ordinary run disappeared after urgent settlement");
-  const acquiredB = await store.acquireRun({
-    conversationId,
-    runId: runB.id,
-    expectedRevision: queuedB.revision,
-    ownerId: "priority-owner-b"
-  });
-  requireOutcome(acquiredB, "applied");
-  const ordered = acquiredB.snapshot.runs.map((run) => run.id).join(",");
-  if (ordered !== `${runA.id},${runC.id},${runB.id}`) {
-    throw new Error(`Durable execution order was not preserved: ${ordered}`);
-  }
-  const [sequenceA, sequenceC, sequenceB] = acquiredB.snapshot.runs.map((run) => run.executionSequence);
-  if (sequenceA === undefined || sequenceC === undefined || sequenceB === undefined || !(sequenceA < sequenceC && sequenceC < sequenceB)) {
-    throw new Error("Acquisition did not persist increasing execution sequence values");
-  }
-}
-async function assertActiveRunCausalOrder(store, conversationId) {
-  for (const id of ["z-causal-run", "a-causal-run"]) {
-    const input = userMessage(conversationId, `${id}-input`);
-    requireOutcome(await store.acceptInputAndAssignRun({
-      idempotencyKey: id,
-      input,
-      run: queuedRun(conversationId, input.id, id)
-    }), "applied");
-  }
-  const active = await store.listActiveRuns(conversationId);
-  if (active.map((run) => run.id).join(",") !== "z-causal-run,a-causal-run") {
-    throw new Error("listActiveRuns must preserve causal history order for timestamp ties");
-  }
-}
-async function assertCausalHistoryOrder(store, conversationId) {
-  const leadInput = userMessage(conversationId, "causal-input-1");
-  const leadRun = queuedRun(conversationId, leadInput.id, "causal-run-1");
-  requireOutcome(await store.acceptInputAndAssignRun({
-    idempotencyKey: "causal-request-1",
-    input: leadInput,
-    run: leadRun
-  }), "applied");
-  const acquired = await store.acquireRun({
-    conversationId,
-    runId: leadRun.id,
-    expectedRevision: leadRun.revision,
-    ownerId: "causal-owner"
-  });
-  requireOutcome(acquired, "applied");
-  const running = acquired.snapshot.runs.find((run) => run.id === leadRun.id);
-  if (!running)
-    throw new Error("Causal-order run disappeared after acquisition");
-  const successorInput = userMessage(conversationId, "causal-input-2");
-  const successorRun = queuedRun(conversationId, successorInput.id, "causal-run-2");
-  requireOutcome(await store.acceptInputAndAssignRun({
-    idempotencyKey: "causal-request-2",
-    input: successorInput,
-    run: successorRun
-  }), "applied");
-  const assistant = AgentMessageSchema.parse({
-    schemaVersion: 1,
-    id: running.assistantMessageId,
-    conversationId,
-    runId: running.id,
-    role: "assistant",
-    status: "streaming",
-    parts: [{ type: "text", text: "causal answer" }],
-    createdAt: "2026-08-28T00:00:00.000Z",
-    updatedAt: "2026-08-28T00:00:01.000Z"
-  });
-  const checkpoint = await store.checkpointRunAssistant({
-    conversationId,
-    runId: running.id,
-    expectedRevision: running.revision,
-    ownerId: "causal-owner",
-    ...running.fencingToken !== undefined && { fencingToken: running.fencingToken },
-    assistant
-  });
-  requireOutcome(checkpoint, "applied");
-  const order = checkpoint.snapshot.messages.map((message) => message.id).join(",");
-  if (order !== `${leadInput.id},${assistant.id},${successorInput.id}`) {
-    throw new Error(`Agent history is not in causal run order: ${order}`);
-  }
 }
-async function assertAbsorptionIsAtomic(store, conversationId) {
-  const leadInput = userMessage(conversationId, "absorb-input-1");
-  const leadRun = queuedRun(conversationId, leadInput.id, "absorb-run-1");
-  const lead = await store.acceptInputAndAssignRun({
-    idempotencyKey: "absorb-request-1",
-    input: leadInput,
-    run: leadRun
-  });
-  requireOutcome(lead, "applied");
-  const successorInput = userMessage(conversationId, "absorb-input-2");
-  const successorRun = queuedRun(conversationId, successorInput.id, "absorb-run-2");
-  const successor = await store.acceptInputAndAssignRun({
-    idempotencyKey: "absorb-request-2",
-    input: successorInput,
-    run: successorRun
-  });
-  requireOutcome(successor, "applied");
-  const acquired = await store.acquireRun({
-    conversationId,
-    runId: leadRun.id,
-    expectedRevision: 0,
-    ownerId: "absorb-owner"
-  });
-  requireOutcome(acquired, "applied");
-  const running = acquired.snapshot.runs.find((run) => run.id === leadRun.id);
-  if (!running)
-    throw new Error("Absorbing run disappeared after acquisition");
-  const answer = AgentMessageSchema.parse({
-    schemaVersion: 1,
-    id: running.assistantMessageId,
-    conversationId,
-    runId: running.id,
-    role: "assistant",
-    status: "completed",
-    parts: [{ type: "text", text: "answered both" }],
-    createdAt: "2026-08-26T00:00:00.000Z",
-    updatedAt: "2026-08-26T00:00:02.000Z"
-  });
-  await store.commitRunTerminal({
-    conversationId,
-    runId: running.id,
-    expectedRevision: running.revision,
-    ownerId: "absorb-owner",
-    assistant: AgentMessageSchema.parse({ ...answer, status: "interrupted" }),
-    reason: "interrupted",
-    absorb: [{ runId: successorRun.id, inputMessageIds: [successorInput.id] }]
-  }).then(() => {
-    throw new Error("A non-completing run absorbed a queued successor");
-  }, (error) => {
-    if (!(error instanceof TypeError))
-      throw error;
-  });
-  const committed = await store.commitRunTerminal({
-    conversationId,
-    runId: running.id,
-    expectedRevision: running.revision,
-    ownerId: "absorb-owner",
-    assistant: answer,
-    reason: "success",
-    absorb: [{ runId: successorRun.id, inputMessageIds: [successorInput.id] }]
-  });
-  requireOutcome(committed, "applied");
-  const absorbingView = await store.loadRun({ conversationId, runId: leadRun.id });
-  if (absorbingView?.run.inputMessageIds.join(",") !== "absorb-input-1,absorb-input-2") {
-    throw new Error("An absorbing run must record the inputs it answered");
-  }
-  const absorbedView = await store.loadRun({ conversationId, runId: successorRun.id });
-  if (absorbedView?.run.terminalReason !== "absorbed") {
-    throw new Error("An absorbed successor must be terminal in the same transaction");
-  }
-  if (absorbedView.run.absorbedIntoRunId !== leadRun.id) {
-    throw new Error("An absorbed run must name the run that answered its input");
-  }
-  if (absorbedView.assistant !== undefined) {
-    throw new Error("An absorbed run produced no answer and must retain none");
-  }
-  if ((await store.listActiveRuns(conversationId)).length !== 0) {
-    throw new Error("An absorbed successor must leave the active listing");
-  }
-  const retried = await store.acceptInputAndAssignRun({
-    idempotencyKey: "absorb-request-2",
-    input: userMessage(conversationId, "absorb-discarded"),
-    run: queuedRun(conversationId, "absorb-discarded", "absorb-discarded-run")
-  });
-  requireOutcome(retried, "duplicate");
-  if (retried.runId !== leadRun.id || retried.assistant?.id !== answer.id) {
-    throw new Error("A retried absorbed key must resolve to the run that answered it");
-  }
-  if (retried.inputMessageId !== successorInput.id) {
-    throw new Error("A retried absorbed key must still name its own input");
-  }
-}
-async function ledgerScenario(store, conversationId) {
-  const first = await store.appendEvent({
-    conversationId,
-    kind: "state/set",
-    payload: { n: 1 }
-  });
-  if (first.seq !== 1)
-    throw new Error(`Agent store conformance expected seq 1, received ${first.seq}`);
-  const appended = await Promise.all(Array.from({ length: 20 }, (_, index) => store.appendEvent({ conversationId, kind: "state/set", payload: { n: index + 2 } })));
-  const seqs = [first.seq, ...appended.map((event) => event.seq)].sort((a, b) => a - b);
-  for (let index = 0;index < seqs.length; index += 1) {
-    if (seqs[index] !== index + 1) {
-      throw new Error(`Agent store conformance expected contiguous seq, received ${seqs.join(",")}`);
-    }
-  }
-  const page = await store.readEvents({ conversationId, fromSeq: 5, toSeq: 9, limit: 3 });
-  if (page.items.map((event) => event.seq).join(",") !== "5,6,7" || page.nextSeq !== 8) {
-    throw new Error(`Agent store conformance expected events 5,6,7 then 8, received ${page.items.map((event) => event.seq).join(",")} then ${page.nextSeq}`);
-  }
-  const ignorable = await store.appendEvent({
-    conversationId,
-    kind: "state/set",
-    payload: { n: "ignorable" },
-    ignorable: true
-  });
-  if (ignorable.ignorable !== true) {
-    throw new Error("Agent store conformance expected the ignorable flag to persist");
-  }
-  const archive = await store.exportConversation(conversationId);
-  const again = await store.exportConversation(conversationId);
-  if (Buffer.compare(Buffer.from(archive), Buffer.from(again)) !== 0) {
-    throw new Error("Agent store conformance expected two exports of a quiet store to be byte-equal");
-  }
-  const decoded = decodeAgentConversationArchive(archive);
-  if (decoded.events.length !== 22) {
-    throw new Error(`Agent store conformance expected 22 archived events, received ${decoded.events.length}`);
-  }
+function createHandlerTestClient(config) {
+  return createClient(config.contract, createTestClientConfig(config), config.contractConfig);
 }
-async function archiveScenario(store, conversationId) {
-  const origin = createMemoryAgentRuntimeStore();
-  const inputMessage = userMessage(conversationId, "archived-input");
-  const run = queuedRun(conversationId, inputMessage.id, "archived-run");
-  requireOutcome(await origin.acceptInputAndAssignRun({
-    idempotencyKey: "archived-request",
-    input: inputMessage,
-    run
-  }), "applied");
-  await origin.appendEvent({
-    conversationId,
-    kind: "state/set",
-    payload: { name: "topic", value: "archive" }
-  });
-  const imported = await store.importConversation(await origin.exportConversation(conversationId));
-  if (imported.conversationId !== conversationId || imported.events !== 2) {
-    throw new Error(`Agent store conformance expected 2 imported events for ${conversationId}, received ${imported.events} for ${imported.conversationId}`);
-  }
-  const restored = await store.loadSnapshot(conversationId);
-  const expected = await origin.loadSnapshot(conversationId);
-  if (restored.version !== expected.version || restored.messages.map((message) => message.id).join(",") !== expected.messages.map((message) => message.id).join(",") || restored.runs.map((entry) => `${entry.id}:${entry.state}`).join(",") !== expected.runs.map((entry) => `${entry.id}:${entry.state}`).join(",")) {
-    throw new Error(`Agent store conformance expected the imported snapshot to match its archive, received version ${restored.version} with ${restored.messages.length} messages and ${restored.runs.length} runs`);
-  }
-  const events = await store.readEvents({ conversationId, limit: 10 });
-  if (events.items.map((event) => event.kind).join(",") !== "runtime/transition,state/set") {
-    throw new Error(`Agent store conformance expected the imported ledger to keep its kinds, received ${events.items.map((event) => event.kind).join(",")}`);
-  }
+function createHandlerTestClients(config) {
+  return createClients(config.contracts, createTestClientConfig(config), config.contractConfig);
 }
 // src/testing/managed-resource-conformance-contract.ts
 import { z } from "zod";
@@ -1487,8 +655,9 @@ import { z as z3 } from "zod";
 // src/testing/surface-manifest.ts
 import { createHash } from "node:crypto";
 import { z as z2 } from "zod";
+var SURFACE_MANIFEST_VERSION = 3;
 var HttpMethodSchema = z2.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
-var ToolTransportSchema = z2.enum(["MCP", "AGENT", "CLI"]);
+var ToolTransportSchema = z2.enum(TOOL_TRANSPORTS);
 var SurfaceTransportSchema = z2.enum(["HTTP", "MCP", "AGENT", "CLI", "REALTIME"]);
 var SurfaceSchemaDigestsSchema = z2.object({
   params: z2.string().nullable(),
@@ -1496,6 +665,17 @@ var SurfaceSchemaDigestsSchema = z2.object({
   output: z2.string().nullable(),
   multipart: z2.string().nullable()
 });
+var SurfaceManifestOperationMcpSchema = z2.object({
+  inputRequired: z2.union([
+    z2.array(z2.object({ key: z2.string(), message: z2.string(), schema: z2.string().nullable() })),
+    z2.literal("resolved-per-call")
+  ])
+}).nullable();
+var SurfaceManifestOperationToolViewSchema = z2.object({
+  defaults: z2.string().nullable(),
+  output: z2.string().nullable(),
+  project: z2.boolean()
+});
 var SurfaceManifestOperationSchema = z2.object({
   kind: z2.enum(["contract", "runtime"]),
   service: z2.string(),
@@ -1504,6 +684,8 @@ var SurfaceManifestOperationSchema = z2.object({
   scope: z2.string().nullable(),
   description: z2.string(),
   schemas: SurfaceSchemaDigestsSchema,
+  mcp: SurfaceManifestOperationMcpSchema,
+  toolView: SurfaceManifestOperationToolViewSchema.optional(),
   http: z2.array(z2.object({ method: HttpMethodSchema, path: z2.string() }))
 });
 var SurfaceManifestToolSchema = z2.object({
@@ -1540,7 +722,7 @@ var SurfaceManifestRealtimeEventSchema = z2.object({
   acknowledgement: SurfaceRealtimeSchemaPairSchema.nullable()
 });
 var SurfaceManifestSchema = z2.object({
-  manifestVersion: z2.literal(2),
+  manifestVersion: z2.literal(SURFACE_MANIFEST_VERSION),
   digestVersion: z2.literal(1),
   operations: z2.array(SurfaceManifestOperationSchema),
   toolSurfaces: z2.array(SurfaceManifestToolSurfaceSchema),
@@ -1556,12 +738,12 @@ function digestValue(value) {
 function canonicalSchemaValue(value, parentKey) {
   if (Array.isArray(value)) {
     const entries = value.map((entry) => canonicalSchemaValue(entry));
-    return parentKey === "required" && entries.every((entry) => typeof entry === "string") ? entries.sort((left, right) => compareCodepoints(String(left), String(right))) : entries;
+    return parentKey === "required" && entries.every((entry) => typeof entry === "string") ? entries.sort((left, right) => compareCodeUnits(String(left), String(right))) : entries;
   }
   if (!isRecord(value))
     return value;
   const result = {};
-  for (const key of Object.keys(value).sort(compareCodepoints)) {
+  for (const key of Object.keys(value).sort(compareCodeUnits)) {
     result[key] = canonicalSchemaValue(value[key], key);
   }
   return result;
@@ -1594,18 +776,39 @@ function operationFrom(kind, source) {
       output: schemaDigest(source.outputSchema, "output"),
       multipart: multipartDigest(source.multipart)
     },
+    mcp: mcpRoundsOf(source),
+    ...toolViewEntry(source),
     http: []
   };
 }
-function operationFingerprint(source) {
-  const declaredRounds = source.mcp ? staticInputRounds(source.mcp) : undefined;
-  const mcp = source.mcp ? {
-    inputRequired: declaredRounds ? declaredRounds.map((request) => ({
+function toolViewOf(source) {
+  const view = source.toolView;
+  if (!view)
+    return null;
+  return {
+    defaults: view.defaults === undefined || Object.keys(view.defaults).length === 0 ? null : digestValue(view.defaults),
+    output: schemaDigest(view.output, "output"),
+    project: view.project !== undefined
+  };
+}
+function toolViewEntry(source) {
+  const toolView = toolViewOf(source);
+  return toolView ? { toolView } : {};
+}
+function mcpRoundsOf(source) {
+  if (!source.mcp)
+    return null;
+  const declared = staticInputRounds(source.mcp);
+  return {
+    inputRequired: declared ? declared.map((request) => ({
       key: request.key,
       message: request.message,
       schema: schemaDigest(request.schema, "input")
     })) : "resolved-per-call"
-  } : null;
+  };
+}
+function operationFingerprint(source) {
+  const mcp = mcpRoundsOf(source);
   return serializeSurfaceValue({
     method: source.method,
     serviceName: source.serviceName,
@@ -1613,11 +816,12 @@ function operationFingerprint(source) {
     desc: source.desc,
     scope: source.scope ?? null,
     path: source.path ?? null,
-    expose: source.expose ? [...source.expose].sort(compareCodepoints) : null,
+    expose: source.expose ? [...source.expose].sort(compareCodeUnits) : null,
     toolName: source.toolName ?? null,
     annotations: source.annotations ?? null,
     ui: source.ui ?? null,
     mcp,
+    toolView: toolViewOf(source),
     rawBody: source.rawBody ?? false,
     safelistedBody: source.safelistedBody ?? false,
     rawResponse: source.rawResponse ?? false,
@@ -1635,7 +839,7 @@ function operationFingerprint(source) {
   });
 }
 function sortTools(tools) {
-  return tools.sort((left, right) => compareCodepoints(left.name, right.name) || compareCodepoints(left.service, right.service) || compareCodepoints(left.action, right.action) || compareCodepoints(left.kind, right.kind));
+  return tools.sort((left, right) => compareCodeUnits(left.name, right.name) || compareCodeUnits(left.service, right.service) || compareCodeUnits(left.action, right.action) || compareCodeUnits(left.kind, right.kind));
 }
 function buildSurfaceManifest(config) {
   const operations = new Map;
@@ -1734,7 +938,7 @@ function buildSurfaceManifest(config) {
   if (explicitMcp)
     addToolProjection("MCP", null, explicitMcp);
   if (namedMcp) {
-    for (const name of Object.keys(namedMcp).sort(compareCodepoints)) {
+    for (const name of Object.keys(namedMcp).sort(compareCodeUnits)) {
       const projection = namedMcp[name];
       if (projection)
         addToolProjection("MCP", name, projection);
@@ -1746,14 +950,14 @@ function buildSurfaceManifest(config) {
   addToolProjection("AGENT", null, agent ?? shared, agent ?? {});
   addToolProjection("CLI", null, config.toolSurfaces?.CLI ?? shared);
   const realtime = [];
-  const realtimeContracts = Object.keys(config.realtime ?? {}).sort(compareCodepoints);
+  const realtimeContracts = Object.keys(config.realtime ?? {}).sort(compareCodeUnits);
   for (const contractName of realtimeContracts) {
     const contract = config.realtime?.[contractName];
     if (!contract)
       continue;
     for (const direction of ["serverToClient", "clientToServer"]) {
       const registry = contract[direction];
-      for (const event of Object.keys(registry).sort(compareCodepoints)) {
+      for (const event of Object.keys(registry).sort(compareCodeUnits)) {
         const definition = registry[event];
         if (!definition)
           continue;
@@ -1784,22 +988,26 @@ function buildSurfaceManifest(config) {
     description: command.description,
     input: schemaDigest(command.input, "input") ?? digestValue({}),
     output: schemaDigest(command.output, "output")
-  })).sort((left, right) => compareCodepoints(left.name, right.name));
+  })).sort((left, right) => compareCodeUnits(left.name, right.name));
   for (const operation of operations.values()) {
-    operation.http.sort((left, right) => compareCodepoints(left.path, right.path) || compareCodepoints(left.method, right.method));
+    operation.http.sort((left, right) => compareCodeUnits(left.path, right.path) || compareCodeUnits(left.method, right.method));
   }
   return SurfaceManifestSchema.parse({
-    manifestVersion: 2,
+    manifestVersion: SURFACE_MANIFEST_VERSION,
     digestVersion: 1,
-    operations: [...operations.values()].sort((left, right) => compareCodepoints(left.service, right.service) || compareCodepoints(left.action, right.action) || compareCodepoints(left.kind, right.kind)),
-    toolSurfaces: toolSurfaces.sort((left, right) => compareCodepoints(left.transport, right.transport) || compareCodepoints(left.surface ?? "", right.surface ?? "")),
+    operations: [...operations.values()].sort((left, right) => compareCodeUnits(left.service, right.service) || compareCodeUnits(left.action, right.action) || compareCodeUnits(left.kind, right.kind)),
+    toolSurfaces: toolSurfaces.sort((left, right) => compareCodeUnits(left.transport, right.transport) || compareCodeUnits(left.surface ?? "", right.surface ?? "")),
     realtimeContracts,
     realtime,
     cliOnly,
-    extensions: [...config.extensions ?? []].sort((left, right) => compareCodepoints(left.transport, right.transport) || compareCodepoints(left.name, right.name))
+    extensions: [...config.extensions ?? []].sort((left, right) => compareCodeUnits(left.transport, right.transport) || compareCodeUnits(left.name, right.name))
   });
 }
 function assertSurfaceManifestSnapshot(manifest, snapshot) {
+  const committed = snapshot.manifestVersion;
+  if (committed !== SURFACE_MANIFEST_VERSION) {
+    throw new Error(`Surface snapshot is manifestVersion ${String(committed)}; this build writes ` + `${SURFACE_MANIFEST_VERSION}. Regenerate it and review the diff — the format ` + "changed, so the first regeneration is expected to be large.");
+  }
   const actual = serializeSurfaceValue(SurfaceManifestSchema.parse(manifest));
   const expected = serializeSurfaceValue(SurfaceManifestSchema.parse(snapshot));
   if (actual !== expected) {
@@ -2005,7 +1213,7 @@ function assertSurfaceDiscovery(manifest, observed) {
   if (observed.openApi) {
     assertSameSet("HTTP/OpenAPI", manifest.operations.flatMap((operation) => operation.http.map((entry) => `${entry.method}:${entry.path.replace(/:([^/]+)/g, "{$1}")}`)), openApiOperations(observed.openApi));
   }
-  for (const transport of ["MCP", "AGENT", "CLI"]) {
+  for (const transport of TOOL_TRANSPORTS) {
     const names = observed[transport];
     if (names) {
       assertSameSet(`${transport} discovery`, expectedToolNames(manifest, transport, null), names);
@@ -2128,44 +1336,14 @@ actual: ${serializeSurfaceValue(actual)}`);
       throw failure;
   }
 }
-
-// src/testing.ts
-function resolveTestBaseUrl(origin, pathPrefix) {
-  const base = new URL(origin ?? "http://stitchkit.test");
-  if (base.pathname !== "/" || base.search || base.hash) {
-    throw new TypeError("Handler test client origin must contain only an absolute origin");
-  }
-  const prefix = pathPrefix?.replace(/^\/+|\/+$/g, "");
-  return prefix ? `${base.origin}/${prefix}` : base.origin;
-}
-function createHandlerFetch(handler, server) {
-  return async (input, init) => handler(new Request(input, init), server);
-}
-function createTestClientConfig(config) {
-  return {
-    ...config.client,
-    baseUrl: resolveTestBaseUrl(config.origin, config.pathPrefix),
-    fetch: createHandlerFetch(config.handler, config.server)
-  };
-}
-function createHandlerTestClient(config) {
-  return createClient(config.contract, createTestClientConfig(config), config.contractConfig);
-}
-function createHandlerTestClients(config) {
-  return createClients(config.contracts, createTestClientConfig(config), config.contractConfig);
-}
 export {
   serializeSurfaceValue,
   runSurfaceProbes,
   runManagedResourceConformance,
-  runAgentStoreConformance,
   defineRealtimeProbe,
   createRealtimeProbeDriver,
   createHandlerTestClients,
   createHandlerTestClient,
-  createAgentRaceTrace,
-  createAgentRaceDriver,
-  createAgentRaceBarrier,
   buildSurfaceManifest,
   assertSurfaceManifestSnapshot,
   assertSurfaceDiscovery,
@@ -2176,8 +1354,11 @@ export {
   SurfaceManifestToolSchema,
   SurfaceManifestSchema,
   SurfaceManifestRealtimeEventSchema,
+  SurfaceManifestOperationToolViewSchema,
   SurfaceManifestOperationSchema,
+  SurfaceManifestOperationMcpSchema,
   SurfaceManifestExtensionSchema,
+  SURFACE_MANIFEST_VERSION,
   RealtimeRejectionObservationSchema,
   RealtimeDisconnectObservationSchema,
   ManagedResourceConformanceTraceOutcomeSchema,