stitchkit 0.104.1 → 0.105.0

package/dist/entrypoints/testing.js

@@ -1,5 +1,4 @@
-import"../index-yex7eg1v.js";
-import"../index-ywppsaby.js";
+import"../index-kfjkb396.js";
 import {
   joinRoutePath
 } from "../index-m38ej7e5.js";
@@ -7,12 +6,14 @@ import"../index-h2fhjqy7.js";
 import {
   createClient2,
   createClients2
-} from "../index-kemm0ej5.js";
-import"../index-x928baz2.js";
+} from "../index-1pwwan01.js";
+import"../index-yex7eg1v.js";
+import"../index-n1nszyk0.js";
+import"../index-j9gxbztg.js";
 import"../index-q0th8q0z.js";
 import {
   createApplication2
-} from "../index-r4r70zmh.js";
+} from "../index-12zsej7b.js";
 import"../index-w5s3xftz.js";
 import {
   RealtimeRequestTimeoutError2,
@@ -21,7 +22,7 @@ import {
 } from "../index-4s0fep5q.js";
 import {
   TOOL_TRANSPORTS2
-} from "../index-ck71tbcf.js";
+} from "../index-fsw1ybf3.js";
 import {
   RealtimeRejectDirectionSchema,
   RealtimeRejectPhaseSchema,
@@ -36,8 +37,8 @@ import {
   projectToolSurface,
   mcpProjectionCandidate,
   prepareProjectedMcpTools
-} from "../index-77nxk6ay.js";
-import"../index-kb8styz3.js";
+} from "../index-r393tnfp.js";
+import"../index-rpzewktb.js";
 import {
   compareCodeUnits,
   serializeCanonicalJson
@@ -648,78 +649,397 @@ async function runManagedResourceConformance(config) {
   }
 }
 // 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);
+var RealtimeRejectionObservationSchema = z2.object({
+  direction: RealtimeRejectDirectionSchema,
+  phase: RealtimeRejectPhaseSchema,
+  reason: RealtimeRejectReasonSchema,
+  fault: RealtimeRejectFaultSchema
+});
+var ObservationFields = {
+  code: z2.string().optional(),
+  data: z2.unknown().optional(),
+  diagnostic: z2.string().optional(),
+  handlerCalls: z2.number().int().nonnegative().optional()
+};
+var RealtimeDisconnectObservationSchema = z2.object({
+  phase: z2.enum(["before-invoke", "in-flight"])
+});
+var TransportObservationSchema = z2.discriminatedUnion("outcome", [
+  z2.object({ outcome: z2.literal("success"), ...ObservationFields }),
+  z2.object({ outcome: z2.literal("validation_error"), ...ObservationFields }),
+  z2.object({ outcome: z2.literal("domain_error"), ...ObservationFields }),
+  z2.object({ outcome: z2.literal("aborted"), ...ObservationFields }),
+  z2.object({
+    outcome: z2.literal("realtime_rejected"),
+    ...ObservationFields,
+    rejection: RealtimeRejectionObservationSchema
+  }),
+  z2.object({
+    outcome: z2.literal("disconnected"),
+    ...ObservationFields,
+    disconnect: RealtimeDisconnectObservationSchema
+  }),
+  z2.object({ outcome: z2.literal("timeout"), ...ObservationFields })
+]);
+function sorted(values) {
+  return [...values].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
 }
-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;
+function assertSameSet(label, expectedValues, actualValues) {
+  const expected = sorted(expectedValues);
+  const actual = sorted(actualValues);
+  if (serializeCanonicalJson(expected) === serializeCanonicalJson(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`);
   }
-  if (!isRecord(value))
-    return value;
-  const result = {};
-  for (const key of Object.keys(value).sort(compareCodeUnits)) {
-    result[key] = canonicalSchemaValue(value[key], key);
+  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_TRANSPORTS2) {
+    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);
   }
-  return result;
 }
-function schemaDigest(schema, io) {
-  if (!schema)
-    return null;
-  return digestValue(canonicalSchemaValue(toJsonSchema(schema, io, "any")));
+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))
+  };
 }
-function presentationDigest(schema) {
-  return digestValue(canonicalSchemaValue(schema));
+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();
+  }
 }
-function multipartDigest(value) {
-  return value === undefined ? null : digestValue(value);
+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 (serializeCanonicalJson(actual) !== serializeCanonicalJson(expected)) {
+          throw new Error(`Surface probe "${probe.name}" ${transport} mismatch
+expected: ${serializeCanonicalJson(expected)}
+actual: ${serializeCanonicalJson(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;
+  }
 }
-function operationKey(kind, service, action) {
-  return `${kind}\x00${service}\x00${action}`;
+
+// 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 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 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 toolViewOf(source) {
-  const view = source.toolView;
-  if (!view)
-    return null;
+function defineRealtimeProbe(config) {
+  const expected = TransportObservationSchema.parse(config.expected);
+  assertScenarioExpectation(config.scenario, expected);
   return {
-    defaults: view.defaults === undefined || Object.keys(view.defaults).length === 0 ? null : digestValue(view.defaults),
-    output: schemaDigest(view.output, "output"),
-    project: view.project !== undefined
+    name: config.name,
+    fixture: { scenario: config.scenario, value: config.fixture },
+    transports: ["REALTIME"],
+    expected: { REALTIME: expected },
+    setup: config.setup,
+    teardown: config.teardown
   };
 }
-function toolViewEntry(source) {
-  const toolView = toolViewOf(source);
-  return toolView ? { toolView } : {};
+function rejectionObservation(rejected) {
+  return RealtimeRejectionObservationSchema.parse(rejected);
 }
-function mcpRoundsOf(source) {
-  if (!source.mcp)
+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 RealtimeRequestInvalidAcknowledgementError2 ? error.code : observedRejection.error.code,
+            rejection: rejectionObservation(observedRejection)
+          });
+        }
+        if (error instanceof RealtimeRequestInvalidAcknowledgementError2) {
+          return withCalls({
+            outcome: "realtime_rejected",
+            code: error.code,
+            rejection: {
+              direction: "client-inbound",
+              phase: "acknowledgement",
+              reason: "invalid-acknowledgement-value",
+              fault: "peer"
+            }
+          });
+        }
+        if (error instanceof RealtimeRequestDisconnectedError2) {
+          return withCalls({
+            outcome: "disconnected",
+            code: error.code,
+            disconnect: {
+              phase: connectedBefore ? "in-flight" : "before-invoke"
+            }
+          });
+        }
+        if (error instanceof RealtimeRequestTimeoutError2) {
+          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 code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "REALTIME_CONTRACT_VIOLATION";
+          return withCalls({
+            outcome: "realtime_rejected",
+            code,
+            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?.();
+      }
+    }
+  };
+}
+// src/testing/surface-manifest.ts
+import { z as z3 } 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 {
@@ -785,82 +1105,81 @@ function runtimeOperationSource(source) {
 
 // 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_TRANSPORTS2);
-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 HttpMethodSchema = z3.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+var ToolTransportSchema = z3.enum(TOOL_TRANSPORTS2);
+var SurfaceTransportSchema = z3.enum(["HTTP", "MCP", "AGENT", "CLI", "REALTIME"]);
+var SurfaceSchemaDigestsSchema = z3.object({
+  params: z3.string().nullable(),
+  input: z3.string().nullable(),
+  output: z3.string().nullable(),
+  multipart: z3.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")
+var SurfaceManifestOperationMcpSchema = z3.object({
+  inputRequired: z3.union([
+    z3.array(z3.object({ key: z3.string(), message: z3.string(), schema: z3.string().nullable() })),
+    z3.literal("resolved-per-call")
   ])
 }).nullable();
-var SurfaceManifestOperationToolViewSchema = z2.object({
-  defaults: z2.string().nullable(),
-  output: z2.string().nullable(),
-  project: z2.boolean()
+var SurfaceManifestOperationToolViewSchema = z3.object({
+  defaults: z3.string().nullable(),
+  output: z3.string().nullable(),
+  project: z3.boolean()
 });
-var SurfaceManifestOperationSchema = z2.object({
-  kind: z2.enum(["contract", "runtime"]),
-  service: z2.string(),
-  action: z2.string(),
+var SurfaceManifestOperationSchema = z3.object({
+  kind: z3.enum(["contract", "runtime"]),
+  service: z3.string(),
+  action: z3.string(),
   method: HttpMethodSchema,
-  scope: z2.string().nullable(),
-  description: z2.string(),
+  scope: z3.string().nullable(),
+  description: z3.string(),
   schemas: SurfaceSchemaDigestsSchema,
   mcp: SurfaceManifestOperationMcpSchema,
   toolView: SurfaceManifestOperationToolViewSchema.optional(),
-  http: z2.array(z2.object({ method: HttpMethodSchema, path: z2.string() }))
+  http: z3.array(z3.object({ method: HttpMethodSchema, path: z3.string() }))
 });
-var SurfaceManifestToolSchema = z2.object({
-  kind: z2.enum(["contract", "runtime"]),
-  service: z2.string(),
-  action: z2.string(),
-  name: z2.string(),
-  input: z2.string()
+var SurfaceManifestToolSchema = z3.object({
+  kind: z3.enum(["contract", "runtime"]),
+  service: z3.string(),
+  action: z3.string(),
+  name: z3.string(),
+  input: z3.string()
 });
-var SurfaceManifestToolSurfaceSchema = z2.object({
+var SurfaceManifestToolSurfaceSchema = z3.object({
   transport: ToolTransportSchema,
-  surface: z2.string().nullable(),
-  tools: z2.array(SurfaceManifestToolSchema)
+  surface: z3.string().nullable(),
+  tools: z3.array(SurfaceManifestToolSchema)
 });
-var SurfaceManifestCliCommandSchema = z2.object({
-  name: z2.string(),
-  description: z2.string(),
-  input: z2.string(),
-  output: z2.string().nullable()
+var SurfaceManifestCliCommandSchema = z3.object({
+  name: z3.string(),
+  description: z3.string(),
+  input: z3.string(),
+  output: z3.string().nullable()
 });
-var SurfaceManifestExtensionSchema = z2.object({
-  name: z2.string(),
+var SurfaceManifestExtensionSchema = z3.object({
+  name: z3.string(),
   transport: SurfaceTransportSchema
 });
-var SurfaceRealtimeSchemaPairSchema = z2.object({
-  input: z2.string(),
-  output: z2.string()
+var SurfaceRealtimeSchemaPairSchema = z3.object({
+  input: z3.string(),
+  output: z3.string()
 });
-var SurfaceManifestRealtimeEventSchema = z2.object({
-  contract: z2.string(),
-  direction: z2.enum(["serverToClient", "clientToServer"]),
-  event: z2.string(),
+var SurfaceManifestRealtimeEventSchema = z3.object({
+  contract: z3.string(),
+  direction: z3.enum(["serverToClient", "clientToServer"]),
+  event: z3.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 SurfaceManifestSchema = z3.object({
+  manifestVersion: z3.literal(SURFACE_MANIFEST_VERSION),
+  digestVersion: z3.literal(1),
+  operations: z3.array(SurfaceManifestOperationSchema),
+  toolSurfaces: z3.array(SurfaceManifestToolSurfaceSchema),
+  realtimeContracts: z3.array(z3.string()),
+  realtime: z3.array(SurfaceManifestRealtimeEventSchema),
+  cliOnly: z3.array(SurfaceManifestCliCommandSchema),
+  extensions: z3.array(SurfaceManifestExtensionSchema)
 });
-var serializeSurfaceValue = serializeCanonicalJson;
 function realtimeEvents(config, realtimeContracts) {
   const realtime = [];
   for (const contractName of realtimeContracts) {
@@ -1009,336 +1328,14 @@ function assertSurfaceManifestSnapshot(manifest, snapshot) {
   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));
+  const actual = serializeCanonicalJson(SurfaceManifestSchema.parse(manifest));
+  const expected = serializeCanonicalJson(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_TRANSPORTS2) {
-    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 RealtimeRequestInvalidAcknowledgementError2 ? error.code : observedRejection.error.code,
-            rejection: rejectionObservation(observedRejection)
-          });
-        }
-        if (error instanceof RealtimeRequestInvalidAcknowledgementError2) {
-          return withCalls({
-            outcome: "realtime_rejected",
-            code: error.code,
-            rejection: {
-              direction: "client-inbound",
-              phase: "acknowledgement",
-              reason: "invalid-acknowledgement-value",
-              fault: "peer"
-            }
-          });
-        }
-        if (error instanceof RealtimeRequestDisconnectedError2) {
-          return withCalls({
-            outcome: "disconnected",
-            code: error.code,
-            disconnect: {
-              phase: connectedBefore ? "in-flight" : "before-invoke"
-            }
-          });
-        }
-        if (error instanceof RealtimeRequestTimeoutError2) {
-          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 code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "REALTIME_CONTRACT_VIOLATION";
-          return withCalls({
-            outcome: "realtime_rejected",
-            code,
-            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 {
   ManagedResourceConformanceError,
   ManagedResourceConformancePhaseSchema,
@@ -1368,6 +1365,5 @@ export {
   createRealtimeProbeDriver,
   defineRealtimeProbe,
   runManagedResourceConformance,
-  runSurfaceProbes,
-  serializeSurfaceValue
+  runSurfaceProbes
 };