stitchkit 0.93.0 → 0.94.1

package/dist/testing.js

@@ -1,2209 +0,0 @@
-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";
-import {
-  RealtimeRejectDirectionSchema,
-  RealtimeRejectFaultSchema,
-  RealtimeRejectPhaseSchema,
-  RealtimeRejectReasonSchema
-} from "./index-p7hgdyhb.js";
-import {
-  createClient,
-  createClients
-} from "./index-yewwh1w4.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";
-import {
-  joinRoutePath
-} from "./index-0a349c33.js";
-import"./index-rxfy4cq7.js";
-import"./index-6k1937bx.js";
-import"./index-zcgf3gqf.js";
-import {
-  mcpProjectionCandidate,
-  prepareProjectedMcpTools,
-  projectToolSurface,
-  staticInputRounds
-} from "./index-h9etkkyk.js";
-import {
-  toJsonSchema
-} from "./index-cby4ar3v.js";
-import"./index-2vtcmrj9.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)})`);
-  }
-  if (failure !== undefined)
-    throw failure;
-}
-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");
-}
-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" }
-  };
-  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}`);
-  }
-}
-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(",")}`);
-  }
-}
-// src/testing/managed-resource-conformance-contract.ts
-import { z } from "zod";
-var ManagedResourceConformanceScenarioIdSchema = z.enum([
-  "clean-shutdown",
-  "partial-start-rollback",
-  "readiness-rejection",
-  "completion-before-ready",
-  "required-late-completion",
-  "optional-late-completion",
-  "activation-rejection",
-  "shutdown-during-startup",
-  "force-after-stalled-close"
-]);
-var ManagedResourceConformanceScenarioSchema = z.discriminatedUnion("id", [
-  z.object({ id: z.literal("clean-shutdown"), required: z.literal(true) }).readonly(),
-  z.object({ id: z.literal("partial-start-rollback"), required: z.literal(true) }).readonly(),
-  z.object({ id: z.literal("readiness-rejection"), required: z.literal(true) }).readonly(),
-  z.object({ id: z.literal("completion-before-ready"), required: z.literal(true) }).readonly(),
-  z.object({ id: z.literal("required-late-completion"), required: z.literal(true) }).readonly(),
-  z.object({ id: z.literal("optional-late-completion"), required: z.literal(false) }).readonly(),
-  z.object({ id: z.literal("activation-rejection"), required: z.literal(true) }).readonly(),
-  z.object({ id: z.literal("shutdown-during-startup"), required: z.literal(true) }).readonly(),
-  z.object({ id: z.literal("force-after-stalled-close"), required: z.literal(true) }).readonly()
-]);
-var ManagedResourceConformancePhaseSchema = z.enum([
-  "start",
-  "readiness",
-  "completion",
-  "activate",
-  "stop-admission",
-  "drain",
-  "close",
-  "force",
-  "dispose"
-]);
-var ManagedResourceConformanceTraceOutcomeSchema = z.enum([
-  "enter",
-  "resolve",
-  "reject"
-]);
-var ManagedResourceConformanceTraceEntrySchema = z.object({
-  sequence: z.number().int().nonnegative(),
-  phase: ManagedResourceConformancePhaseSchema,
-  outcome: ManagedResourceConformanceTraceOutcomeSchema
-}).strict().readonly();
-
-class ManagedResourceConformanceError extends Error {
-  scenarioId;
-  expected;
-  trace;
-  code = "MANAGED_RESOURCE_CONFORMANCE_FAILED";
-  constructor(scenarioId, expected, trace, detail) {
-    const observed = trace.length === 0 ? "(empty)" : trace.map((entry) => `${entry.phase}:${entry.outcome}`).join(" -> ");
-    super(`[stitchkit] managed resource conformance "${scenarioId}" failed: ${detail}; ` + `expected ${expected.join(" -> ")}; observed ${observed}`);
-    this.scenarioId = scenarioId;
-    this.expected = expected;
-    this.trace = trace;
-    this.name = "ManagedResourceConformanceError";
-  }
-}
-
-// src/testing/managed-resource-conformance-driver.ts
-function controlledPromise() {
-  const deferred = Promise.withResolvers();
-  let settled = false;
-  deferred.promise.catch(() => {
-    return;
-  });
-  return {
-    promise: deferred.promise,
-    resolve() {
-      if (settled)
-        return false;
-      settled = true;
-      deferred.resolve();
-      return true;
-    },
-    reject(error) {
-      if (settled)
-        return false;
-      settled = true;
-      deferred.reject(error);
-      return true;
-    }
-  };
-}
-
-class ManagedResourceConformanceTrace {
-  entries = [];
-  waiters = new Set;
-  record(phase, outcome) {
-    const entry = ManagedResourceConformanceTraceEntrySchema.parse({
-      sequence: this.entries.length,
-      phase,
-      outcome
-    });
-    this.entries.push(entry);
-    for (const waiter of this.waiters) {
-      if (waiter.phase !== phase || waiter.outcome !== outcome)
-        continue;
-      this.waiters.delete(waiter);
-      waiter.resolve();
-    }
-  }
-  has(phase, outcome) {
-    return this.entries.some((entry) => entry.phase === phase && entry.outcome === outcome);
-  }
-  count(phase, outcome) {
-    return this.entries.filter((entry) => entry.phase === phase && entry.outcome === outcome).length;
-  }
-  waitFor(phase, outcome = "enter") {
-    if (this.has(phase, outcome))
-      return Promise.resolve();
-    return new Promise((resolve) => this.waiters.add({ phase, outcome, resolve }));
-  }
-}
-function createManagedResourceConformanceGates(trace) {
-  const startup = controlledPromise();
-  const readiness = controlledPromise();
-  const completion = controlledPromise();
-  const activation = controlledPromise();
-  const close = controlledPromise();
-  const force = controlledPromise();
-  const gateFor = (phase) => {
-    if (phase === "start")
-      return startup;
-    if (phase === "readiness")
-      return readiness;
-    if (phase === "completion")
-      return completion;
-    if (phase === "activate")
-      return activation;
-    if (phase === "close")
-      return close;
-    return force;
-  };
-  const resolve = (phase) => {
-    if (gateFor(phase).resolve())
-      trace.record(phase, "resolve");
-  };
-  return {
-    controls: {
-      startup: startup.promise,
-      readiness: readiness.promise,
-      completion: completion.promise,
-      activation: activation.promise,
-      close: close.promise,
-      force: force.promise
-    },
-    resolve,
-    reject(phase, error) {
-      if (gateFor(phase).reject(error))
-        trace.record(phase, "reject");
-    },
-    releaseAll() {
-      resolve("start");
-      resolve("readiness");
-      resolve("completion");
-      resolve("activate");
-      resolve("close");
-      resolve("force");
-    }
-  };
-}
-async function observePhase(trace, phase, invoke) {
-  trace.record(phase, "enter");
-  try {
-    const value = await invoke();
-    trace.record(phase, "resolve");
-    return value;
-  } catch (error) {
-    trace.record(phase, "reject");
-    throw error;
-  }
-}
-function optionalPhase(resource, trace, phase, invoke) {
-  if (!invoke)
-    return {};
-  return {
-    [phase]: (context) => observePhase(trace, phase, () => invoke.call(resource, context))
-  };
-}
-function observeManagedResource(resource, required, trace) {
-  const start = async (context) => {
-    trace.record("start", "enter");
-    try {
-      const value = await resource.start(context);
-      trace.record("start", "resolve");
-      if (value === undefined)
-        return;
-      return value;
-    } catch (error) {
-      trace.record("start", "reject");
-      throw error;
-    }
-  };
-  return {
-    id: resource.id,
-    required,
-    start,
-    ...optionalPhase(resource, trace, "activate", resource.activate),
-    ...resource.stopAdmission ? {
-      stopAdmission: (context) => observePhase(trace, "stop-admission", () => resource.stopAdmission?.call(resource, context))
-    } : {},
-    ...optionalPhase(resource, trace, "drain", resource.drain),
-    ...optionalPhase(resource, trace, "close", resource.close),
-    ...optionalPhase(resource, trace, "force", resource.force)
-  };
-}
-
-// src/testing/managed-resource-conformance-scenarios.ts
-var MANAGED_RESOURCE_CONFORMANCE_SCENARIOS = ManagedResourceConformanceScenarioSchema.array().parse([
-  { id: "clean-shutdown", required: true },
-  { id: "partial-start-rollback", required: true },
-  { id: "readiness-rejection", required: true },
-  { id: "completion-before-ready", required: true },
-  { id: "required-late-completion", required: true },
-  { id: "optional-late-completion", required: false },
-  { id: "activation-rejection", required: true },
-  { id: "shutdown-during-startup", required: true },
-  { id: "force-after-stalled-close", required: true }
-]);
-var EXPECTED_TRACE = {
-  "clean-shutdown": [
-    "start:enter",
-    "start:resolve",
-    "readiness:resolve",
-    "activate:enter",
-    "activate:resolve",
-    "stop-admission:enter",
-    "drain:enter",
-    "close:enter",
-    "close:resolve"
-  ],
-  "partial-start-rollback": ["start:enter", "start:reject", "close:enter", "close:resolve"],
-  "readiness-rejection": [
-    "start:enter",
-    "start:resolve",
-    "readiness:reject",
-    "close:enter",
-    "close:resolve"
-  ],
-  "completion-before-ready": [
-    "start:enter",
-    "start:resolve",
-    "completion:reject",
-    "close:enter",
-    "close:resolve"
-  ],
-  "required-late-completion": [
-    "activate:resolve",
-    "completion:reject",
-    "stop-admission:enter",
-    "drain:enter",
-    "close:enter"
-  ],
-  "optional-late-completion": [
-    "activate:resolve",
-    "completion:reject",
-    "stop-admission:enter",
-    "drain:enter",
-    "close:enter"
-  ],
-  "activation-rejection": [
-    "readiness:resolve",
-    "activate:enter",
-    "activate:reject",
-    "close:enter",
-    "close:resolve"
-  ],
-  "shutdown-during-startup": ["start:enter", "start:resolve", "close:enter", "close:resolve"],
-  "force-after-stalled-close": [
-    "stop-admission:enter",
-    "drain:enter",
-    "close:enter",
-    "force:enter",
-    "force:resolve"
-  ]
-};
-function outcomeOf(promise) {
-  return promise.then(() => ({ status: "resolved" }), (error) => ({ status: "rejected", error }));
-}
-function requireCondition(condition, detail) {
-  if (!condition)
-    throw new Error(detail);
-}
-function observedTrace(trace) {
-  return trace.entries.map((entry) => `${entry.phase}:${entry.outcome}`);
-}
-function requireTrace(runtime) {
-  const expected = EXPECTED_TRACE[runtime.scenario.id];
-  const observed = observedTrace(runtime.trace);
-  let cursor = 0;
-  for (const entry of observed) {
-    if (entry === expected[cursor])
-      cursor += 1;
-  }
-  requireCondition(cursor === expected.length, `phase trace omitted or reordered "${expected[cursor] ?? "unknown"}"`);
-}
-async function phaseOrSettlement(trace, phase, settlement) {
-  return Promise.race([
-    trace.waitFor(phase).then(() => "phase"),
-    settlement.then(() => "settled", () => "settled")
-  ]);
-}
-async function startSuccessfully(runtime) {
-  const starting = runtime.application.start();
-  const startOutcome = outcomeOf(starting);
-  await runtime.trace.waitFor("start");
-  runtime.gates.resolve("start");
-  runtime.gates.resolve("readiness");
-  const activation = await Promise.race([
-    runtime.trace.waitFor("activate").then(() => ({ status: "resolved" })),
-    startOutcome
-  ]);
-  if (activation.status === "rejected")
-    throw activation.error;
-  runtime.gates.resolve("activate");
-  const outcome = await startOutcome;
-  requireCondition(outcome.status === "resolved", "application did not complete successful startup");
-}
-async function closeNormally(runtime) {
-  const shuttingDown = runtime.application.shutdown();
-  const close = await phaseOrSettlement(runtime.trace, "close", shuttingDown);
-  if (close === "phase")
-    runtime.gates.resolve("close");
-  const outcome = await outcomeOf(shuttingDown);
-  requireCondition(outcome.status === "resolved", "application shutdown rejected");
-}
-async function expectStartupFailure(runtime, starting) {
-  const close = await phaseOrSettlement(runtime.trace, "close", starting);
-  if (close === "phase")
-    runtime.gates.resolve("close");
-  const outcome = await outcomeOf(starting);
-  if (outcome.status === "resolved") {
-    await closeNormally(runtime);
-    throw new Error("application startup unexpectedly resolved");
-  }
-  requireCondition(runtime.trace.count("close", "enter") === 1, "attempted resource was not closed once");
-  await runtime.application.shutdown();
-}
-function waitForSnapshot(application, predicate) {
-  const deferred = Promise.withResolvers();
-  let unsubscribe = () => {
-    return;
-  };
-  unsubscribe = application.subscribe((snapshot) => {
-    if (!predicate(snapshot))
-      return;
-    unsubscribe();
-    deferred.resolve(snapshot);
-  });
-  return deferred.promise;
-}
-async function cleanShutdown(runtime) {
-  await startSuccessfully(runtime);
-  await closeNormally(runtime);
-  requireCondition(runtime.application.getSnapshot().lifecycle === "stopped", "clean shutdown did not stop the application");
-}
-async function partialStartRollback(runtime) {
-  const starting = runtime.application.start();
-  await runtime.trace.waitFor("start");
-  runtime.gates.reject("start", new Error("controlled partial startup rejection"));
-  await expectStartupFailure(runtime, starting);
-}
-async function readinessRejection(runtime) {
-  const starting = runtime.application.start();
-  await runtime.trace.waitFor("start");
-  runtime.gates.resolve("start");
-  await runtime.trace.waitFor("start", "resolve");
-  runtime.gates.reject("readiness", new Error("controlled readiness rejection"));
-  runtime.gates.resolve("activate");
-  await expectStartupFailure(runtime, starting);
-}
-async function completionBeforeReady(runtime) {
-  const starting = runtime.application.start();
-  await runtime.trace.waitFor("start");
-  runtime.gates.resolve("start");
-  await runtime.trace.waitFor("start", "resolve");
-  runtime.gates.reject("completion", new Error("controlled early completion rejection"));
-  runtime.gates.resolve("readiness");
-  runtime.gates.resolve("activate");
-  await expectStartupFailure(runtime, starting);
-}
-async function lateCompletion(runtime) {
-  await startSuccessfully(runtime);
-  const expectedHealth = runtime.scenario.required ? "unhealthy" : "degraded";
-  const changed = waitForSnapshot(runtime.application, (snapshot2) => snapshot2.health === expectedHealth);
-  runtime.gates.reject("completion", new Error("controlled late completion rejection"));
-  const snapshot = await changed;
-  requireCondition(snapshot.lifecycle === "ready", "late completion changed lifecycle ownership");
-  requireCondition(snapshot.health === expectedHealth, "late completion projected the wrong health");
-  requireCondition(snapshot.ready === !runtime.scenario.required, "late completion projected the wrong readiness");
-  requireCondition(snapshot.admission.accepting === !runtime.scenario.required, "late completion projected the wrong admission state");
-  await closeNormally(runtime);
-}
-async function activationRejection(runtime) {
-  const starting = runtime.application.start();
-  await runtime.trace.waitFor("start");
-  runtime.gates.resolve("start");
-  await runtime.trace.waitFor("start", "resolve");
-  runtime.gates.resolve("readiness");
-  await runtime.trace.waitFor("activate");
-  runtime.gates.reject("activate", new Error("controlled activation rejection"));
-  await expectStartupFailure(runtime, starting);
-}
-async function shutdownDuringStartup(runtime) {
-  const starting = runtime.application.start();
-  await runtime.trace.waitFor("start");
-  const shuttingDown = runtime.application.shutdown();
-  runtime.gates.resolve("start");
-  const close = await phaseOrSettlement(runtime.trace, "close", shuttingDown);
-  if (close === "phase")
-    runtime.gates.resolve("close");
-  const [startOutcome, shutdownOutcome] = await Promise.all([
-    outcomeOf(starting),
-    outcomeOf(shuttingDown)
-  ]);
-  requireCondition(startOutcome.status === "rejected", "startup won the shutdown race");
-  requireCondition(shutdownOutcome.status === "resolved", "shutdown race rejected");
-  requireCondition(!runtime.trace.has("activate", "enter"), "resource activated after shutdown won");
-}
-async function forceAfterStalledClose(runtime) {
-  await startSuccessfully(runtime);
-  const controller = new AbortController;
-  const shuttingDown = runtime.application.shutdown({
-    gracePeriodMs: 60000,
-    forceTimeoutMs: 60000,
-    signal: controller.signal
-  });
-  await runtime.trace.waitFor("close");
-  controller.abort();
-  const force = await phaseOrSettlement(runtime.trace, "force", shuttingDown);
-  if (force === "phase")
-    runtime.gates.resolve("force");
-  const result = await shuttingDown;
-  requireCondition(runtime.trace.count("close", "enter") === 1, "close was not invoked exactly once");
-  requireCondition(runtime.trace.count("force", "enter") === 1, "unfinished close did not invoke force");
-  requireCondition(result.outcome === "forced", "forced shutdown reported a clean outcome");
-  requireCondition(result.reason === "signal", "forced shutdown lost its signal reason");
-  runtime.gates.resolve("close");
-}
-function expectedManagedResourceConformanceTrace(scenarioId) {
-  return EXPECTED_TRACE[scenarioId];
-}
-async function executeManagedResourceConformanceScenario(scenario, resource, gates, trace) {
-  const application = createApplication({
-    id: `conformance-${scenario.id}`,
-    resources: [observeManagedResource(resource, scenario.required, trace)]
-  });
-  const runtime = { scenario, application, gates, trace };
-  if (scenario.id === "clean-shutdown")
-    await cleanShutdown(runtime);
-  else if (scenario.id === "partial-start-rollback")
-    await partialStartRollback(runtime);
-  else if (scenario.id === "readiness-rejection")
-    await readinessRejection(runtime);
-  else if (scenario.id === "completion-before-ready")
-    await completionBeforeReady(runtime);
-  else if (scenario.id === "required-late-completion" || scenario.id === "optional-late-completion") {
-    await lateCompletion(runtime);
-  } else if (scenario.id === "activation-rejection")
-    await activationRejection(runtime);
-  else if (scenario.id === "shutdown-during-startup")
-    await shutdownDuringStartup(runtime);
-  else
-    await forceAfterStalledClose(runtime);
-  requireTrace(runtime);
-}
-
-// src/testing/managed-resource-conformance.ts
-var DEFAULT_WATCHDOG_TIMEOUT_MS = 2000;
-
-class ManagedResourceConformanceWatchdogError extends Error {
-  phase;
-  constructor(phase) {
-    super(`emergency watchdog expired during ${phase}`);
-    this.phase = phase;
-    this.name = "ManagedResourceConformanceWatchdogError";
-  }
-}
-async function withWatchdog(promise, timeoutMs, phase) {
-  let timer;
-  const watchdog = new Promise((_resolve, reject) => {
-    timer = setTimeout(() => reject(new ManagedResourceConformanceWatchdogError(phase)), timeoutMs);
-  });
-  try {
-    return await Promise.race([promise, watchdog]);
-  } finally {
-    if (timer !== undefined)
-      clearTimeout(timer);
-  }
-}
-function detailOf(error) {
-  if (error instanceof ManagedResourceConformanceWatchdogError)
-    return error.message;
-  if (error instanceof Error)
-    return error.message;
-  return "unknown conformance failure";
-}
-async function runScenario(config, scenario, watchdogTimeoutMs) {
-  const trace = new ManagedResourceConformanceTrace;
-  const gates = createManagedResourceConformanceGates(trace);
-  const fixture = await withWatchdog(Promise.resolve().then(() => config.createFixture({ scenario, controls: gates.controls })), watchdogTimeoutMs, "factory").catch((error) => {
-    throw new ManagedResourceConformanceError(scenario.id, expectedManagedResourceConformanceTrace(scenario.id), trace.entries, detailOf(error));
-  });
-  let failure;
-  const execution = executeManagedResourceConformanceScenario(scenario, fixture.resource, gates, trace);
-  execution.catch(() => {
-    return;
-  });
-  let settlementIncomplete = false;
-  try {
-    await withWatchdog(execution, watchdogTimeoutMs, "scenario");
-  } catch (error) {
-    failure = { value: error };
-  } finally {
-    gates.releaseAll();
-    if (failure?.value instanceof ManagedResourceConformanceWatchdogError) {
-      try {
-        await withWatchdog(execution, watchdogTimeoutMs, "settlement");
-      } catch (error) {
-        if (error instanceof ManagedResourceConformanceWatchdogError) {
-          settlementIncomplete = true;
-        } else {
-          failure = { value: error };
-        }
-      }
-    }
-    trace.record("dispose", "enter");
-    try {
-      await withWatchdog(Promise.resolve(fixture.dispose()), watchdogTimeoutMs, "dispose");
-      trace.record("dispose", "resolve");
-    } catch (error) {
-      trace.record("dispose", "reject");
-      if (failure === undefined)
-        failure = { value: error };
-    }
-    if (settlementIncomplete) {
-      try {
-        await withWatchdog(execution, watchdogTimeoutMs, "settlement");
-        settlementIncomplete = false;
-      } catch (error) {
-        if (error instanceof ManagedResourceConformanceWatchdogError) {
-          const original = failure?.value;
-          failure = {
-            value: new Error(`${detailOf(original)}; execution remained live after fixture disposal`)
-          };
-        } else {
-          settlementIncomplete = false;
-          failure = { value: error };
-        }
-      }
-    }
-  }
-  if (failure !== undefined) {
-    if (failure.value instanceof ManagedResourceConformanceError)
-      throw failure.value;
-    throw new ManagedResourceConformanceError(scenario.id, expectedManagedResourceConformanceTrace(scenario.id), trace.entries, detailOf(failure.value));
-  }
-}
-async function runManagedResourceConformance(config) {
-  const watchdogTimeoutMs = config.watchdogTimeoutMs ?? DEFAULT_WATCHDOG_TIMEOUT_MS;
-  if (!Number.isSafeInteger(watchdogTimeoutMs) || watchdogTimeoutMs <= 0) {
-    throw new TypeError("[stitchkit] managed resource conformance watchdogTimeoutMs must be positive");
-  }
-  const selected = new Set((config.scenarios ?? MANAGED_RESOURCE_CONFORMANCE_SCENARIOS.map((scenario) => scenario.id)).map((scenario) => ManagedResourceConformanceScenarioIdSchema.parse(scenario)));
-  if (selected.size === 0) {
-    throw new TypeError("[stitchkit] managed resource conformance scenarios must not be empty");
-  }
-  for (const scenario of MANAGED_RESOURCE_CONFORMANCE_SCENARIOS) {
-    if (!selected.has(scenario.id))
-      continue;
-    await runScenario(config, scenario, watchdogTimeoutMs);
-  }
-}
-// src/testing/surface-conformance.ts
-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 SurfaceTransportSchema = z2.enum(["HTTP", "MCP", "AGENT", "CLI", "REALTIME"]);
-var SurfaceSchemaDigestsSchema = z2.object({
-  params: z2.string().nullable(),
-  input: z2.string().nullable(),
-  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 SurfaceManifestOperationSchema = z2.object({
-  kind: z2.enum(["contract", "runtime"]),
-  service: z2.string(),
-  action: z2.string(),
-  method: HttpMethodSchema,
-  scope: z2.string().nullable(),
-  description: z2.string(),
-  schemas: SurfaceSchemaDigestsSchema,
-  mcp: SurfaceManifestOperationMcpSchema,
-  http: z2.array(z2.object({ method: HttpMethodSchema, path: z2.string() }))
-});
-var SurfaceManifestToolSchema = z2.object({
-  kind: z2.enum(["contract", "runtime"]),
-  service: z2.string(),
-  action: z2.string(),
-  name: z2.string(),
-  input: z2.string()
-});
-var SurfaceManifestToolSurfaceSchema = z2.object({
-  transport: ToolTransportSchema,
-  surface: z2.string().nullable(),
-  tools: z2.array(SurfaceManifestToolSchema)
-});
-var SurfaceManifestCliCommandSchema = z2.object({
-  name: z2.string(),
-  description: z2.string(),
-  input: z2.string(),
-  output: z2.string().nullable()
-});
-var SurfaceManifestExtensionSchema = z2.object({
-  name: z2.string(),
-  transport: SurfaceTransportSchema
-});
-var SurfaceRealtimeSchemaPairSchema = z2.object({
-  input: z2.string(),
-  output: z2.string()
-});
-var SurfaceManifestRealtimeEventSchema = z2.object({
-  contract: z2.string(),
-  direction: z2.enum(["serverToClient", "clientToServer"]),
-  event: z2.string(),
-  args: SurfaceRealtimeSchemaPairSchema,
-  acknowledgement: SurfaceRealtimeSchemaPairSchema.nullable()
-});
-var SurfaceManifestSchema = z2.object({
-  manifestVersion: z2.literal(SURFACE_MANIFEST_VERSION),
-  digestVersion: z2.literal(1),
-  operations: z2.array(SurfaceManifestOperationSchema),
-  toolSurfaces: z2.array(SurfaceManifestToolSurfaceSchema),
-  realtimeContracts: z2.array(z2.string()),
-  realtime: z2.array(SurfaceManifestRealtimeEventSchema),
-  cliOnly: z2.array(SurfaceManifestCliCommandSchema),
-  extensions: z2.array(SurfaceManifestExtensionSchema)
-});
-var serializeSurfaceValue = serializeCanonicalJson;
-function digestValue(value) {
-  return createHash("sha256").update(serializeSurfaceValue(value)).digest("hex").slice(0, 16);
-}
-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;
-  }
-  if (!isRecord(value))
-    return value;
-  const result = {};
-  for (const key of Object.keys(value).sort(compareCodepoints)) {
-    result[key] = canonicalSchemaValue(value[key], key);
-  }
-  return result;
-}
-function schemaDigest(schema, io) {
-  if (!schema)
-    return null;
-  return digestValue(canonicalSchemaValue(toJsonSchema(schema, io, "any")));
-}
-function presentationDigest(schema) {
-  return digestValue(canonicalSchemaValue(schema));
-}
-function multipartDigest(value) {
-  return value === undefined ? null : digestValue(value);
-}
-function operationKey(kind, service, action) {
-  return `${kind}\x00${service}\x00${action}`;
-}
-function operationFrom(kind, source) {
-  return {
-    kind,
-    service: source.serviceName,
-    action: source.key,
-    method: source.method,
-    scope: source.scope ?? null,
-    description: source.desc,
-    schemas: {
-      params: schemaDigest(source.paramsSchema, "input"),
-      input: schemaDigest(source.inputSchema, "input"),
-      output: schemaDigest(source.outputSchema, "output"),
-      multipart: multipartDigest(source.multipart)
-    },
-    mcp: mcpRoundsOf(source),
-    http: []
-  };
-}
-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"
-  };
-}
-function operationFingerprint(source) {
-  const mcp = mcpRoundsOf(source);
-  return serializeSurfaceValue({
-    method: source.method,
-    serviceName: source.serviceName,
-    key: source.key,
-    desc: source.desc,
-    scope: source.scope ?? null,
-    path: source.path ?? null,
-    expose: source.expose ? [...source.expose].sort(compareCodepoints) : null,
-    toolName: source.toolName ?? null,
-    annotations: source.annotations ?? null,
-    ui: source.ui ?? null,
-    mcp,
-    rawBody: source.rawBody ?? false,
-    safelistedBody: source.safelistedBody ?? false,
-    rawResponse: source.rawResponse ?? false,
-    responseMeta: source.responseMeta ?? null,
-    maxJsonBodyBytes: source.maxJsonBodyBytes ?? null,
-    idempotent: source.idempotent ?? false,
-    contentType: source.contentType ?? null,
-    meta: source.meta ?? null,
-    schemas: {
-      params: schemaDigest(source.paramsSchema, "input"),
-      input: schemaDigest(source.inputSchema, "input"),
-      output: schemaDigest(source.outputSchema, "output"),
-      multipart: multipartDigest(source.multipart)
-    }
-  });
-}
-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));
-}
-function buildSurfaceManifest(config) {
-  const operations = new Map;
-  const operationFingerprints = new Map;
-  const operationDefinitions = new Map;
-  const addOperation = (kind, source) => {
-    const candidate = operationFrom(kind, source);
-    const key = operationKey(kind, candidate.service, candidate.action);
-    const definition = source.definitionToken ?? source;
-    const existing = operations.get(key);
-    if (!existing) {
-      operations.set(key, candidate);
-      operationFingerprints.set(key, operationFingerprint(source));
-      operationDefinitions.set(key, definition);
-      return candidate;
-    }
-    if (operationDefinitions.get(key) !== definition || operationFingerprints.get(key) !== operationFingerprint(source)) {
-      throw new Error(`Conflicting ${kind} operation identity ${candidate.service}.${candidate.action}`);
-    }
-    return existing;
-  };
-  const addHttp = (service, prefix) => {
-    for (const method of Object.values(service.methods)) {
-      const operation = addOperation("contract", method);
-      if (method.expose && !method.expose.includes("HTTP"))
-        continue;
-      const route = {
-        method: method.method,
-        path: joinRoutePath(prefix, service.prefix, method.path)
-      };
-      if (!operation.http.some((entry) => entry.method === route.method && entry.path === route.path)) {
-        operation.http.push(route);
-      }
-    }
-  };
-  for (const service of config.services ?? []) {
-    addHttp(service, config.scopePrefixes?.[service.scope] ?? "");
-  }
-  for (const group of config.groups ?? []) {
-    for (const service of group.services)
-      addHttp(service, group.pathPrefix ?? "");
-  }
-  const toolSurfaces = [];
-  const addToolProjection = (transport, surface, projection, presentation = {}) => {
-    const projected = projectToolSurface(projection, transport, transport === "MCP" ? config.mcpPreparation ?? {} : presentation);
-    const collected = transport === "MCP" ? prepareProjectedMcpTools(projected.map(mcpProjectionCandidate), config.mcpPreparation ?? {}).map((prepared) => ({
-      ...prepared.tool,
-      presentationSchema: prepared.inputSchema
-    })) : projected;
-    const tools = [];
-    for (const entry of collected) {
-      const source = entry.kind === "contract" ? entry.source : {
-        definitionToken: entry.source,
-        method: entry.source.identity.method,
-        serviceName: entry.source.identity.serviceName,
-        key: entry.source.identity.action,
-        desc: entry.source.description,
-        ...entry.source.identity.scope !== undefined && {
-          scope: entry.source.identity.scope
-        },
-        inputSchema: entry.source.input,
-        ...entry.source.output !== undefined && {
-          outputSchema: entry.source.output
-        },
-        toolName: entry.source.name,
-        expose: entry.source.transports,
-        ...entry.source.annotations !== undefined && {
-          annotations: entry.source.annotations
-        },
-        ...entry.source.ui !== undefined && { ui: entry.source.ui },
-        ...entry.source.identity.meta !== undefined && {
-          meta: entry.source.identity.meta
-        },
-        ...entry.source.mcp !== undefined && { mcp: entry.source.mcp }
-      };
-      const operation = addOperation(entry.kind, source);
-      tools.push({
-        kind: entry.kind,
-        service: operation.service,
-        action: operation.action,
-        name: entry.name,
-        input: presentationDigest(entry.presentationSchema)
-      });
-    }
-    toolSurfaces.push({ transport, surface, tools: sortTools(tools) });
-  };
-  const shared = {
-    services: config.services,
-    runtimeTools: config.runtimeTools
-  };
-  const explicitMcp = config.toolSurfaces?.MCP;
-  const namedMcp = config.mcpSurfaces;
-  if (explicitMcp && namedMcp) {
-    throw new Error("Surface manifest MCP topology must use either one direct surface or named surfaces");
-  }
-  if (explicitMcp)
-    addToolProjection("MCP", null, explicitMcp);
-  if (namedMcp) {
-    for (const name of Object.keys(namedMcp).sort(compareCodepoints)) {
-      const projection = namedMcp[name];
-      if (projection)
-        addToolProjection("MCP", name, projection);
-    }
-  }
-  if (!explicitMcp && !namedMcp)
-    addToolProjection("MCP", null, shared);
-  const agent = config.toolSurfaces?.AGENT;
-  addToolProjection("AGENT", null, agent ?? shared, agent ?? {});
-  addToolProjection("CLI", null, config.toolSurfaces?.CLI ?? shared);
-  const realtime = [];
-  const realtimeContracts = Object.keys(config.realtime ?? {}).sort(compareCodepoints);
-  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)) {
-        const definition = registry[event];
-        if (!definition)
-          continue;
-        const argsInput = schemaDigest(definition.args, "input");
-        const argsOutput = schemaDigest(definition.args, "output");
-        if (!argsInput || !argsOutput)
-          throw new Error("Realtime args schema digest missing");
-        let acknowledgement = null;
-        if (definition.ack) {
-          const input = schemaDigest(definition.ack, "input");
-          const output = schemaDigest(definition.ack, "output");
-          if (!input || !output)
-            throw new Error("Realtime ack schema digest missing");
-          acknowledgement = { input, output };
-        }
-        realtime.push({
-          contract: contractName,
-          direction,
-          event,
-          args: { input: argsInput, output: argsOutput },
-          acknowledgement
-        });
-      }
-    }
-  }
-  const cliOnly = (config.cliCommands ?? []).map((command) => ({
-    name: command.name,
-    description: command.description,
-    input: schemaDigest(command.input, "input") ?? digestValue({}),
-    output: schemaDigest(command.output, "output")
-  })).sort((left, right) => compareCodepoints(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));
-  }
-  return SurfaceManifestSchema.parse({
-    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 ?? "")),
-    realtimeContracts,
-    realtime,
-    cliOnly,
-    extensions: [...config.extensions ?? []].sort((left, right) => compareCodepoints(left.transport, right.transport) || compareCodepoints(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) {
-    throw new Error(`Surface manifest diverged from its committed snapshot
-expected: ${expected}
-actual: ${actual}`);
-  }
-}
-
-// src/testing/surface-conformance.ts
-var RealtimeRejectionObservationSchema = z3.object({
-  direction: RealtimeRejectDirectionSchema,
-  phase: RealtimeRejectPhaseSchema,
-  reason: RealtimeRejectReasonSchema,
-  fault: RealtimeRejectFaultSchema
-});
-var ObservationFields = {
-  code: z3.string().optional(),
-  data: z3.unknown().optional(),
-  diagnostic: z3.string().optional(),
-  handlerCalls: z3.number().int().nonnegative().optional()
-};
-var RealtimeDisconnectObservationSchema = z3.object({
-  phase: z3.enum(["before-invoke", "in-flight"])
-});
-var TransportObservationSchema = z3.discriminatedUnion("outcome", [
-  z3.object({ outcome: z3.literal("success"), ...ObservationFields }),
-  z3.object({ outcome: z3.literal("validation_error"), ...ObservationFields }),
-  z3.object({ outcome: z3.literal("domain_error"), ...ObservationFields }),
-  z3.object({ outcome: z3.literal("aborted"), ...ObservationFields }),
-  z3.object({
-    outcome: z3.literal("realtime_rejected"),
-    ...ObservationFields,
-    rejection: RealtimeRejectionObservationSchema
-  }),
-  z3.object({
-    outcome: z3.literal("disconnected"),
-    ...ObservationFields,
-    disconnect: RealtimeDisconnectObservationSchema
-  }),
-  z3.object({ outcome: z3.literal("timeout"), ...ObservationFields })
-]);
-function scenarioOutcome(scenario) {
-  if (scenario === "event" || scenario === "acknowledgement")
-    return "success";
-  if (scenario === "invalid_arguments" || scenario === "invalid_acknowledgement" || scenario === "peer_rejection") {
-    return "realtime_rejected";
-  }
-  if (scenario === "disconnected" || scenario === "in_flight_disconnect") {
-    return "disconnected";
-  }
-  return "timeout";
-}
-function assertScenarioExpectation(scenario, expected) {
-  const outcome = scenarioOutcome(scenario);
-  if (expected.outcome !== outcome) {
-    throw new TypeError(`Realtime probe scenario "${scenario}" requires outcome "${outcome}"`);
-  }
-  if (expected.outcome === "realtime_rejected" && (scenario === "invalid_arguments" && expected.rejection.phase !== "arguments" || scenario === "invalid_acknowledgement" && expected.rejection.phase !== "acknowledgement")) {
-    throw new TypeError(`Realtime probe scenario "${scenario}" has incompatible rejection phase`);
-  }
-  if (scenario === "invalid_arguments" && expected.handlerCalls !== 0) {
-    throw new TypeError('Realtime probe scenario "invalid_arguments" requires handlerCalls: 0');
-  }
-  if (scenario === "peer_rejection" && (expected.outcome !== "realtime_rejected" || expected.rejection.reason !== "rejected-by-peer")) {
-    throw new TypeError('Realtime probe scenario "peer_rejection" requires a rejected-by-peer outcome');
-  }
-  if (expected.outcome === "disconnected") {
-    const phase = scenario === "disconnected" ? "before-invoke" : "in-flight";
-    if (expected.disconnect.phase !== phase) {
-      throw new TypeError(`Realtime probe scenario "${scenario}" requires disconnect phase "${phase}"`);
-    }
-  }
-}
-function defineRealtimeProbe(config) {
-  const expected = TransportObservationSchema.parse(config.expected);
-  assertScenarioExpectation(config.scenario, expected);
-  return {
-    name: config.name,
-    fixture: { scenario: config.scenario, value: config.fixture },
-    transports: ["REALTIME"],
-    expected: { REALTIME: expected },
-    setup: config.setup,
-    teardown: config.teardown
-  };
-}
-function rejectionObservation(rejected) {
-  return RealtimeRejectionObservationSchema.parse(rejected);
-}
-function createRealtimeProbeDriver({
-  bind,
-  handlerCalls
-}) {
-  return {
-    async invoke(fixture, signal) {
-      let rejected;
-      const currentRejection = () => rejected;
-      const adapter = bind((event) => {
-        rejected = event;
-      }, fixture);
-      const connectedBefore = adapter.connected();
-      const callsBefore = handlerCalls?.();
-      const withCalls = (observation) => {
-        if (callsBefore === undefined || !handlerCalls)
-          return observation;
-        return { ...observation, handlerCalls: handlerCalls() - callsBefore };
-      };
-      try {
-        signal.throwIfAborted();
-        const data = await adapter.invoke(fixture, signal);
-        const observedRejection = currentRejection();
-        if (observedRejection) {
-          return withCalls({
-            outcome: "realtime_rejected",
-            code: observedRejection.error.code,
-            rejection: rejectionObservation(observedRejection)
-          });
-        }
-        return withCalls({
-          outcome: "success",
-          ...data !== undefined && { data }
-        });
-      } catch (error) {
-        const observedRejection = currentRejection();
-        if (observedRejection) {
-          return withCalls({
-            outcome: "realtime_rejected",
-            code: error instanceof RealtimeRequestInvalidAcknowledgementError ? error.code : observedRejection.error.code,
-            rejection: rejectionObservation(observedRejection)
-          });
-        }
-        if (error instanceof RealtimeRequestInvalidAcknowledgementError) {
-          return withCalls({
-            outcome: "realtime_rejected",
-            code: error.code,
-            rejection: {
-              direction: "client-inbound",
-              phase: "acknowledgement",
-              reason: "invalid-acknowledgement-value",
-              fault: "peer"
-            }
-          });
-        }
-        if (error instanceof RealtimeRequestDisconnectedError) {
-          return withCalls({
-            outcome: "disconnected",
-            code: error.code,
-            disconnect: {
-              phase: connectedBefore ? "in-flight" : "before-invoke"
-            }
-          });
-        }
-        if (error instanceof RealtimeRequestTimeoutError) {
-          return withCalls({ outcome: "timeout", code: error.code });
-        }
-        if (signal.aborted && error === signal.reason) {
-          return withCalls({ outcome: "aborted" });
-        }
-        const parsedRejection = RealtimeRejectionObservationSchema.safeParse(typeof error === "object" && error !== null && "details" in error ? error.details : undefined);
-        if (parsedRejection.success) {
-          const code2 = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "REALTIME_CONTRACT_VIOLATION";
-          return withCalls({
-            outcome: "realtime_rejected",
-            code: code2,
-            rejection: parsedRejection.data
-          });
-        }
-        const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : undefined;
-        return withCalls({
-          outcome: "domain_error",
-          ...code !== undefined && { code },
-          diagnostic: error instanceof Error ? error.message : String(error)
-        });
-      } finally {
-        await adapter.dispose?.();
-      }
-    }
-  };
-}
-function sorted(values) {
-  return [...values].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
-}
-function assertSameSet(label, expectedValues, actualValues) {
-  const expected = sorted(expectedValues);
-  const actual = sorted(actualValues);
-  if (serializeSurfaceValue(expected) === serializeSurfaceValue(actual))
-    return;
-  throw new Error(`${label} mismatch
-expected: ${expected.join(", ") || "(empty)"}
-actual: ${actual.join(", ") || "(empty)"}`);
-}
-function openApiOperations(document) {
-  return Object.entries(document.paths).flatMap(([path, item]) => Object.keys(item).filter((method) => ["get", "post", "put", "patch", "delete", "head"].includes(method)).map((method) => `${method.toUpperCase()}:${path}`));
-}
-function expectedToolNames(manifest, transport, surface) {
-  const projection = manifest.toolSurfaces.find((candidate) => candidate.transport === transport && candidate.surface === surface);
-  if (!projection) {
-    throw new Error(`${transport} surface "${surface ?? "(default)"}" is not declared in the manifest`);
-  }
-  return projection.tools.map((tool) => tool.name);
-}
-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"]) {
-    const names = observed[transport];
-    if (names) {
-      assertSameSet(`${transport} discovery`, expectedToolNames(manifest, transport, null), names);
-    }
-  }
-  for (const projection of observed.toolSurfaces ?? []) {
-    assertSameSet(`${projection.transport} surface "${projection.surface ?? "(default)"}" discovery`, expectedToolNames(manifest, projection.transport, projection.surface ?? null), projection.names);
-  }
-  for (const [contract, topology] of Object.entries(observed.realtime ?? {})) {
-    if (!manifest.realtimeContracts.includes(contract)) {
-      throw new Error(`REALTIME contract "${contract}" is not declared in the manifest`);
-    }
-    for (const direction of ["serverToClient", "clientToServer"]) {
-      assertSameSet(`REALTIME ${contract}.${direction} discovery`, manifest.realtime.filter((entry) => entry.contract === contract && entry.direction === direction).map((entry) => entry.event), topology[direction]);
-    }
-  }
-  if (observed.cliOnly) {
-    assertSameSet("CLI-only discovery", manifest.cliOnly.map((command) => command.name), observed.cliOnly);
-  }
-  for (const transport of [
-    "HTTP",
-    "MCP",
-    "AGENT",
-    "CLI",
-    "REALTIME"
-  ]) {
-    const names = observed.extensions?.[transport];
-    if (!names)
-      continue;
-    assertSameSet(`${transport} extension discovery`, manifest.extensions.filter((extension) => extension.transport === transport).map((extension) => extension.name), names);
-  }
-}
-function boundedObservation(observation, maxDiagnosticBytes) {
-  const parsed = TransportObservationSchema.parse(observation);
-  if (!parsed.diagnostic)
-    return parsed;
-  const bytes = new TextEncoder().encode(parsed.diagnostic);
-  if (bytes.byteLength <= maxDiagnosticBytes)
-    return parsed;
-  return {
-    ...parsed,
-    diagnostic: new TextDecoder().decode(bytes.slice(0, maxDiagnosticBytes))
-  };
-}
-async function runBounded(run, signal) {
-  if (signal.aborted) {
-    Promise.resolve().then(run).catch(() => {
-      return;
-    });
-    throw signal.reason;
-  }
-  let removeAbortListener = () => {
-    return;
-  };
-  const aborted = new Promise((_resolve, reject) => {
-    const onAbort = () => reject(signal.reason);
-    signal.addEventListener("abort", onAbort, { once: true });
-    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-  });
-  try {
-    return await Promise.race([Promise.resolve().then(run), aborted]);
-  } finally {
-    removeAbortListener();
-  }
-}
-async function runSurfaceProbes({
-  probes,
-  drivers,
-  signal,
-  timeoutMs = 1e4,
-  maxDiagnosticBytes = 4096
-}) {
-  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
-    throw new TypeError("Surface probe timeoutMs must be a positive integer");
-  }
-  if (!Number.isInteger(maxDiagnosticBytes) || maxDiagnosticBytes <= 0) {
-    throw new TypeError("Surface probe maxDiagnosticBytes must be a positive integer");
-  }
-  for (const probe of probes) {
-    const timeoutSignal = AbortSignal.timeout(timeoutMs);
-    const probeSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-    let failed = false;
-    let failure;
-    try {
-      probeSignal.throwIfAborted();
-      if (probe.setup)
-        await runBounded(() => probe.setup?.(probeSignal), probeSignal);
-      for (const transport of probe.transports) {
-        probeSignal.throwIfAborted();
-        const driver = drivers[transport];
-        if (!driver) {
-          throw new Error(`Surface probe "${probe.name}" has no ${transport} driver`);
-        }
-        const actual = boundedObservation(await runBounded(() => driver.invoke(probe.fixture, probeSignal), probeSignal), maxDiagnosticBytes);
-        const expected = probe.expected[transport];
-        if (!expected) {
-          throw new Error(`Surface probe "${probe.name}" has no ${transport} expectation`);
-        }
-        if (serializeSurfaceValue(actual) !== serializeSurfaceValue(expected)) {
-          throw new Error(`Surface probe "${probe.name}" ${transport} mismatch
-expected: ${serializeSurfaceValue(expected)}
-actual: ${serializeSurfaceValue(actual)}`);
-        }
-      }
-    } catch (error) {
-      failed = true;
-      failure = error;
-    }
-    if (probe.teardown) {
-      try {
-        await runBounded(() => probe.teardown?.(probeSignal), probeSignal);
-      } catch (error) {
-        if (!failed) {
-          failed = true;
-          failure = error;
-        }
-      }
-    }
-    if (failed)
-      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,
-  TransportObservationSchema,
-  SurfaceSchemaDigestsSchema,
-  SurfaceRealtimeSchemaPairSchema,
-  SurfaceManifestToolSurfaceSchema,
-  SurfaceManifestToolSchema,
-  SurfaceManifestSchema,
-  SurfaceManifestRealtimeEventSchema,
-  SurfaceManifestOperationSchema,
-  SurfaceManifestOperationMcpSchema,
-  SurfaceManifestExtensionSchema,
-  SURFACE_MANIFEST_VERSION,
-  RealtimeRejectionObservationSchema,
-  RealtimeDisconnectObservationSchema,
-  ManagedResourceConformanceTraceOutcomeSchema,
-  ManagedResourceConformanceTraceEntrySchema,
-  ManagedResourceConformanceScenarioSchema,
-  ManagedResourceConformanceScenarioIdSchema,
-  ManagedResourceConformancePhaseSchema,
-  ManagedResourceConformanceError
-};