stitchkit 0.93.0 → 0.94.1

package/dist/entrypoints/testing.js

@@ -0,0 +1,1377 @@
+import {
+  createApplication
+} from "../index-w906953s.js";
+import"../index-3gye9wzb.js";
+import"../index-2k4yrqkc.js";
+import"../index-3z73fh2c.js";
+import {
+  RealtimeRejectDirectionSchema,
+  RealtimeRejectFaultSchema,
+  RealtimeRejectPhaseSchema,
+  RealtimeRejectReasonSchema
+} from "../index-p7hgdyhb.js";
+import {
+  createClient,
+  createClients
+} from "../index-ham5sz8m.js";
+import {
+  RealtimeRequestDisconnectedError,
+  RealtimeRequestInvalidAcknowledgementError,
+  RealtimeRequestTimeoutError
+} from "../index-dce5wxcq.js";
+import"../index-48ffdxgk.js";
+import"../index-wqgjfstn.js";
+import"../index-v260df89.js";
+import {
+  TOOL_TRANSPORTS
+} from "../index-k30h66yd.js";
+import {
+  joinRoutePath
+} from "../index-4gcnakhx.js";
+import"../index-zcgf3gqf.js";
+import {
+  mcpProjectionCandidate,
+  prepareProjectedMcpTools,
+  projectToolSurface,
+  staticInputRounds
+} from "../index-np4m8hd3.js";
+import {
+  toJsonSchema
+} 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-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");
+  }
+  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);
+}
+// 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 { z as z2 } from "zod";
+
+// src/testing/surface-manifest-digest.ts
+import { createHash } from "node:crypto";
+function digestValue(value) {
+  return createHash("sha256").update(serializeCanonicalJson(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) => compareCodeUnits(String(left), String(right))) : entries;
+  }
+  if (!isRecord(value))
+    return value;
+  const result = {};
+  for (const key of Object.keys(value).sort(compareCodeUnits)) {
+    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),
+    ...toolViewEntry(source),
+    http: []
+  };
+}
+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"
+  };
+}
+function operationFingerprint(source) {
+  const mcp = mcpRoundsOf(source);
+  return serializeCanonicalJson({
+    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(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,
+    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) => compareCodeUnits(left.name, right.name) || compareCodeUnits(left.service, right.service) || compareCodeUnits(left.action, right.action) || compareCodeUnits(left.kind, right.kind));
+}
+function runtimeOperationSource(source) {
+  return {
+    definitionToken: source,
+    method: source.identity.method,
+    serviceName: source.identity.serviceName,
+    key: source.identity.action,
+    desc: source.description,
+    ...source.identity.scope !== undefined && { scope: source.identity.scope },
+    inputSchema: source.input,
+    ...source.output !== undefined && { outputSchema: source.output },
+    toolName: source.name,
+    expose: source.transports,
+    ...source.annotations !== undefined && { annotations: source.annotations },
+    ...source.ui !== undefined && { ui: source.ui },
+    ...source.identity.meta !== undefined && { meta: source.identity.meta },
+    ...source.mcp !== undefined && { mcp: source.mcp }
+  };
+}
+
+// src/testing/surface-manifest.ts
+var SURFACE_MANIFEST_VERSION = 3;
+var HttpMethodSchema = z2.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+var ToolTransportSchema = z2.enum(TOOL_TRANSPORTS);
+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 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(),
+  action: z2.string(),
+  method: HttpMethodSchema,
+  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({
+  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 realtimeEvents(config, realtimeContracts) {
+  const realtime = [];
+  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(compareCodeUnits)) {
+        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
+        });
+      }
+    }
+  }
+  return realtime;
+}
+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 : runtimeOperationSource(entry.source);
+      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(compareCodeUnits)) {
+      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 realtimeContracts = Object.keys(config.realtime ?? {}).sort(compareCodeUnits);
+  const realtime = realtimeEvents(config, realtimeContracts);
+  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) => compareCodeUnits(left.name, right.name));
+  for (const operation of operations.values()) {
+    operation.http.sort((left, right) => compareCodeUnits(left.path, right.path) || compareCodeUnits(left.method, right.method));
+  }
+  return SurfaceManifestSchema.parse({
+    manifestVersion: SURFACE_MANIFEST_VERSION,
+    digestVersion: 1,
+    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) => 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) {
+    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 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 TOOL_TRANSPORTS) {
+    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/realtime-probe.ts
+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?.();
+      }
+    }
+  };
+}
+export {
+  serializeSurfaceValue,
+  runSurfaceProbes,
+  runManagedResourceConformance,
+  defineRealtimeProbe,
+  createRealtimeProbeDriver,
+  createHandlerTestClients,
+  createHandlerTestClient,
+  buildSurfaceManifest,
+  assertSurfaceManifestSnapshot,
+  assertSurfaceDiscovery,
+  TransportObservationSchema,
+  SurfaceSchemaDigestsSchema,
+  SurfaceRealtimeSchemaPairSchema,
+  SurfaceManifestToolSurfaceSchema,
+  SurfaceManifestToolSchema,
+  SurfaceManifestSchema,
+  SurfaceManifestRealtimeEventSchema,
+  SurfaceManifestOperationToolViewSchema,
+  SurfaceManifestOperationSchema,
+  SurfaceManifestOperationMcpSchema,
+  SurfaceManifestExtensionSchema,
+  SURFACE_MANIFEST_VERSION,
+  RealtimeRejectionObservationSchema,
+  RealtimeDisconnectObservationSchema,
+  ManagedResourceConformanceTraceOutcomeSchema,
+  ManagedResourceConformanceTraceEntrySchema,
+  ManagedResourceConformanceScenarioSchema,
+  ManagedResourceConformanceScenarioIdSchema,
+  ManagedResourceConformancePhaseSchema,
+  ManagedResourceConformanceError
+};