@anureo/conformance 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,409 +0,0 @@
-// packages/conformance/src/fake.ts
-import {
-  negotiateVersion
-} from "@anureo/protocol";
-import { HarnessSdkError } from "@anureo/sdk";
-var FAKE_CAPABILITIES = {
-  session: { resume: true, fork: ["before", "through"], revert: ["conversation", "files", "both"], history: true },
-  turn: { steer: true, interrupt: true, outputSchema: true, inputModalities: ["text", "image", "file"], overrides: ["model"] },
-  goal: { actions: ["set", "clear"] },
-  compact: true,
-  review: true,
-  interactions: ["approval", "userInput", "elicitation", "dynamicTool"],
-  config: { options: [{ id: "model", scope: "session", schema: { type: "string" } }] }
-};
-
-class ScriptedHarnessAdapter {
-  options;
-  calls = [];
-  opened = [];
-  sinks = new Map;
-  backends = new Map;
-  disposeCount = 0;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  get capabilities() {
-    return structuredClone(this.options.capabilities ?? FAKE_CAPABILITIES);
-  }
-  async initialize(params) {
-    negotiateVersion(params.protocolVersions);
-    return { protocolVersion: 1, runtime: { name: "scripted", version: "1.0.0", adapter: "conformance/0.1.0" }, capabilities: this.capabilities };
-  }
-  async openSession(params, sink) {
-    this.opened.push(structuredClone(params));
-    this.sinks.set(params.binding.sessionId, sink);
-    const backend = new ScriptedBackendSession(this, params, sink);
-    this.backends.set(params.binding.sessionId, backend);
-    if (params.mode === "fork" && params.fork) {
-      const source = this.backends.get(params.fork.sourceSessionId);
-      if (!source)
-        throw new HarnessSdkError("SESSION_NOT_FOUND");
-      const boundaryIndex = source.history.findIndex((entry) => entry.turnId === params.fork.boundary.turnId);
-      if (boundaryIndex < 0)
-        throw new HarnessSdkError("TURN_NOT_FOUND");
-      const retained = params.fork.boundary.relation === "before" ? boundaryIndex : boundaryIndex + 1;
-      backend.history.push(...structuredClone(source.history.slice(0, retained)));
-    }
-    await this.options.onOpen?.(params, sink);
-    return backend;
-  }
-  async dispose() {
-    this.disposeCount++;
-  }
-}
-
-class ScriptedBackendSession {
-  adapter;
-  sink;
-  binding;
-  capabilities;
-  history = [];
-  disposeCount = 0;
-  state;
-  constructor(adapter, params, sink) {
-    this.adapter = adapter;
-    this.sink = sink;
-    this.binding = { ...params.binding, nativeRef: { provider: "scripted", value: `native:${params.binding.sessionId}` } };
-    this.capabilities = adapter.capabilities;
-    this.state = { binding: this.binding, capabilities: this.capabilities, status: "ready", config: params.config ?? {}, capabilityRevision: 1 };
-  }
-  async emit(payload, turnId) {
-    await this.sink.emit(payload, { turnId });
-  }
-  async execute(method, params) {
-    const call = { method, params };
-    this.adapter.calls.push(call);
-    const custom = await this.adapter.options.execute?.(call, this.sink);
-    if (custom !== undefined)
-      return custom;
-    let result;
-    switch (method) {
-      case "turn/start": {
-        const start = params;
-        await this.emit({ type: "turn/started", payload: { turnId: start.turnId } });
-        const item = { id: "native-reused", type: "agentMessage", text: start.input.filter((part) => part.type === "text").map((part) => part.text).join(`
-`), phase: "final" };
-        await this.emit({ type: "item/started", payload: { item: { ...item, text: "" } } }, start.turnId);
-        await this.emit({ type: "item/delta", payload: { itemId: item.id, kind: "text", text: "preview " } }, start.turnId);
-        await this.emit({ type: "item/completed", payload: { item } }, start.turnId);
-        this.history.push({ turnId: start.turnId, item });
-        await this.emit({ type: "turn/completed", payload: { turnId: start.turnId, status: "completed" } });
-        result = { turnId: start.turnId, accepted: true };
-        break;
-      }
-      case "turn/steer":
-        result = { turnId: params.expectedTurnId, accepted: true };
-        break;
-      case "turn/interrupt": {
-        const id = params.turnId;
-        await this.emit({ type: "turn/completed", payload: { turnId: id, status: "interrupted" } });
-        result = { accepted: true, turnId: id };
-        break;
-      }
-      case "session/config/set":
-        this.state = { ...this.state, config: { ...this.state.config, ...params.patch }, capabilityRevision: this.state.capabilityRevision + 1 };
-        result = this.state;
-        break;
-      case "session/revert": {
-        const request = params;
-        if (request.scope !== "files") {
-          const index = this.history.findIndex((entry) => entry.turnId === request.boundary.turnId);
-          if (index < 0)
-            throw new HarnessSdkError("TURN_NOT_FOUND");
-          this.history.splice(request.boundary.relation === "before" ? index : index + 1);
-        }
-        result = { appliedScope: request.scope, boundary: request.boundary };
-        break;
-      }
-      case "history/read":
-        result = { items: this.history, snapshotToken: "fake-snapshot", source: this.binding.nativeRef };
-        break;
-      case "goal/set":
-        result = { goal: params.goal, status: "active" };
-        break;
-      case "goal/clear":
-        result = { goal: null, status: "cleared" };
-        break;
-      case "compact/start":
-        result = { maintenanceId: "fake-maintenance", status: "completed" };
-        break;
-      case "review/start": {
-        const id = params.turnId;
-        await this.emit({ type: "turn/started", payload: { turnId: id } });
-        await this.emit({ type: "turn/completed", payload: { turnId: id, status: "completed" } });
-        result = { accepted: true, turnId: id };
-        break;
-      }
-      case "session/close":
-        result = { closed: true };
-        break;
-      case "interaction/respond":
-      case "interaction/cancel":
-        throw new Error("Interactions must be handled by the SDK registry");
-    }
-    return result;
-  }
-  async dispose() {
-    this.disposeCount++;
-  }
-}
-function createScriptedAdapter(options) {
-  return new ScriptedHarnessAdapter(options);
-}
-function createScriptedConformanceFactory(capabilities) {
-  return (scenario) => {
-    const adapter = createScriptedAdapter({ capabilities, execute: async (call, sink) => {
-      if (call.method !== "turn/start")
-        return;
-      const { turnId } = call.params;
-      if (["interrupt", "steer", "disconnect", "backpressure"].includes(scenario)) {
-        await sink.emit({ type: "turn/started", payload: { turnId } });
-        if (scenario === "backpressure")
-          sink.tryEmit({ type: "notice", payload: { severity: "info", code: "FLOOD", message: "Conformance overflow" } });
-        return { accepted: true, turnId };
-      }
-      const interaction = {
-        approval: { interactionId: "conformance-approval", kind: "approval", turnId, options: [{ id: "deny", label: "Deny", semantic: "deny" }] },
-        userInput: { interactionId: "conformance-input", kind: "userInput", turnId, questions: [{ id: "q", prompt: "Value" }] },
-        elicitation: { interactionId: "conformance-elicitation", kind: "elicitation", turnId, mode: "form" },
-        dynamicTool: { interactionId: "conformance-tool", kind: "dynamicTool", turnId, toolName: "conformance", arguments: {} }
-      };
-      if (interaction[scenario] || scenario === "unknown-item") {
-        await sink.emit({ type: "turn/started", payload: { turnId } });
-        if (interaction[scenario])
-          await sink.requestInteraction(interaction[scenario], async () => {});
-        else
-          await sink.emit({ type: "item/completed", payload: { item: { id: "unknown", type: "toolCall", kind: "other", title: "Unknown", nativeType: "futureNativeType", raw: { safe: "value" } } } }, { turnId });
-        await sink.emit({ type: "turn/completed", payload: { turnId, status: "completed" } });
-        return { accepted: true, turnId };
-      }
-      return;
-    } });
-    return {
-      adapter,
-      openParams: { requestId: "conformance-open", mode: "new", binding: { sessionId: "conformance-session", adapterId: "scripted", runtimeConfigId: "conformance-runtime" }, cwd: "/tmp" },
-      ...scenario === "backpressure" ? { runtimeOptions: { queue: { maxEvents: 2 } } } : {},
-      ...scenario === "disconnect" ? { afterStart: async () => {
-        await adapter.sinks.get("conformance-session").fail(new HarnessSdkError("CONNECTION_CLOSED", "Conformance disconnection", false, true));
-      } } : {}
-    };
-  };
-}
-// packages/conformance/src/suite.ts
-import { createHarnessRuntime } from "@anureo/sdk";
-import { supportsCapability } from "@anureo/protocol";
-var CONFORMANCE_SCENARIOS = ["lifecycle", "immediate", "identity", "approval", "userInput", "elicitation", "dynamicTool", "interrupt", "steer", "fork", "revert", "history", "unknown-item", "disconnect", "backpressure"];
-function requireCondition(value, message) {
-  if (!value)
-    throw new Error(message);
-}
-function deadline(promise, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error("Conformance timed out")), timeoutMs);
-    promise.then((result) => {
-      clearTimeout(timer);
-      resolve(result);
-    }, (cause) => {
-      clearTimeout(timer);
-      reject(cause);
-    });
-  });
-}
-function applicable(scenario, capabilities) {
-  if (["approval", "userInput", "elicitation", "dynamicTool"].includes(scenario))
-    return capabilities.interactions?.includes(scenario) ?? false;
-  if (scenario === "interrupt" || scenario === "steer")
-    return supportsCapability(capabilities, `turn.${scenario}`);
-  if (scenario === "fork")
-    return !!capabilities.session?.fork?.length;
-  if (scenario === "revert")
-    return !!capabilities.session?.revert?.length;
-  if (scenario === "history")
-    return !!capabilities.session?.history;
-  return true;
-}
-function defaultAnswer(request) {
-  switch (request.kind) {
-    case "approval":
-      return { kind: "approval", optionId: request.options[0].id };
-    case "userInput":
-      return { kind: "userInput", answers: Object.fromEntries(request.questions.map((question) => [question.id, question.options?.[0]?.id ?? "conformance"])) };
-    case "elicitation":
-      return { kind: "elicitation", action: "decline" };
-    case "dynamicTool":
-      return { kind: "dynamicTool", content: [{ type: "text", text: "conformance" }] };
-  }
-}
-async function runConformance(factory, options = {}) {
-  const cases = [];
-  for (const scenario of options.scenarios ?? CONFORMANCE_SCENARIOS) {
-    let runtime;
-    let reader;
-    try {
-      const fixture = await factory(scenario);
-      runtime = createHarnessRuntime(fixture.adapter, fixture.runtimeOptions);
-      const initialized = await runtime.initialize({ protocolVersions: [1], clientInfo: { name: "harness-conformance", version: "0.1.0" }, clientCapabilities: { interactions: ["approval", "userInput", "elicitation", "dynamicTool"] } });
-      if (!applicable(scenario, initialized.capabilities)) {
-        cases.push({ scenario, status: "not-applicable" });
-        continue;
-      }
-      const session = await runtime.openSession(fixture.openParams);
-      const sessionId = session.binding.sessionId;
-      reader = session.events()[Symbol.asyncIterator]();
-      const events = [];
-      let interactionSeen = false;
-      const collect = async (turnId) => {
-        for (let count = 0;count < 1e4; count++) {
-          const entry = await reader.next();
-          requireCondition(!entry.done, "Source ended before a terminal event");
-          const event = entry.value;
-          events.push(event);
-          if (event.type === "interaction/requested") {
-            interactionSeen = true;
-            await session.respond({ requestId: `respond:${event.payload.interactionId}`, sessionId, interactionId: event.payload.interactionId, response: (fixture.answer ?? defaultAnswer)(event.payload) });
-          }
-          if (event.type === "turn/completed" && event.payload.turnId === turnId)
-            return event;
-        }
-        throw new Error("Too many events without completion");
-      };
-      const run = async (turnId) => {
-        const request = session.startTurn({ requestId: `start:${turnId}`, sessionId, turnId, input: [{ type: "text", text: "conformance" }] });
-        request.catch(() => {});
-        if (scenario === "backpressure") {
-          await request;
-          await fixture.afterStart?.(session);
-        } else if (scenario === "interrupt" || scenario === "steer" || scenario === "disconnect") {
-          await request;
-          if (scenario === "steer")
-            await session.steer({ requestId: "steer", sessionId, expectedTurnId: turnId, input: [{ type: "text", text: "redirect" }] });
-          if (scenario !== "disconnect")
-            await session.interrupt({ requestId: "interrupt", sessionId, turnId });
-          await fixture.afterStart?.(session);
-        }
-        const terminal = await collect(turnId);
-        await request;
-        return terminal;
-      };
-      const terminal = await deadline(run("conformance-turn-1"), options.timeoutMs ?? 3000);
-      requireCondition(events.filter((event) => event.type === "turn/started").length === 1, "Turn must start once");
-      requireCondition(events.filter((event) => event.type === "turn/completed").length === 1, "Turn must end once");
-      requireCondition(events.every((event, index) => event.seq === index + 1 && event.sessionId === sessionId && event.streamId === events[0].streamId), "Source identity/sequence must be contiguous");
-      if (["approval", "userInput", "elicitation", "dynamicTool"].includes(scenario))
-        requireCondition(interactionSeen && events.some((event) => event.type === "interaction/resolved"), "Declared interaction was not exercised");
-      if (scenario === "disconnect" || scenario === "backpressure")
-        requireCondition(terminal.payload.status === "failed", "Lost/overflowed source must fail explicitly");
-      else if (scenario === "interrupt" || scenario === "steer")
-        requireCondition(terminal.payload.status === "interrupted", "Interrupt must produce interrupted status");
-      else
-        requireCondition(terminal.payload.status === "completed", "Unexpected failed turn");
-      if (scenario === "lifecycle" || scenario === "immediate")
-        requireCondition(events.some((event) => event.type === "item/completed" && event.payload.item.type === "agentMessage" && event.payload.item.text === (fixture.expectedText ?? "conformance")), "Missing authoritative completed text");
-      if (scenario === "unknown-item")
-        requireCondition(events.some((event) => event.type === "item/completed" && event.payload.item.type === "toolCall" && event.payload.item.kind === "other" && !!event.payload.item.nativeType), "Unknown native item was discarded");
-      if (scenario === "identity") {
-        await deadline(run("conformance-turn-2"), options.timeoutMs ?? 3000);
-        const items = events.filter((event) => event.type === "item/completed");
-        requireCondition(items.some((event) => event.turnId === "conformance-turn-1") && items.some((event) => event.turnId === "conformance-turn-2"), "Turn-scoped item identities were lost");
-      }
-      if (scenario === "history") {
-        const history = await session.readHistory({ requestId: "history", sessionId });
-        requireCondition(history.items.length > 0 && history.items.every((entry) => !!entry.turnId && !!entry.item.id), "Declared history did not return the completed turn");
-      }
-      if (scenario === "fork") {
-        for (const relation of initialized.capabilities.session.fork) {
-          const fork = await runtime.openSession({ ...fixture.openParams, requestId: `fork:${relation}`, mode: "fork", binding: { ...session.binding, sessionId: `${sessionId}:fork:${relation}` }, fork: { sourceSessionId: sessionId, nativeRef: session.binding.nativeRef, boundary: { turnId: "conformance-turn-1", relation } } });
-          requireCondition(fork.binding.sessionId !== sessionId && fork.binding.adapterId === session.binding.adapterId, "Fork must create an independent same-adapter session");
-          if (initialized.capabilities.session?.history) {
-            const history = await fork.readHistory({ requestId: "fork-history", sessionId: fork.binding.sessionId });
-            requireCondition(relation === "before" ? !history.items.some((entry) => entry.turnId === "conformance-turn-1") : history.items.some((entry) => entry.turnId === "conformance-turn-1"), "Fork boundary was not preserved");
-          }
-          await fork.close();
-        }
-      }
-      if (scenario === "revert") {
-        const scope = initialized.capabilities.session.revert[0];
-        const result = await session.revert({ requestId: "revert", sessionId, scope, boundary: { turnId: "conformance-turn-1", relation: "before" } });
-        requireCondition(result.appliedScope === scope && result.boundary.turnId === "conformance-turn-1", "Revert did not report the actual requested scope/boundary");
-        if (scope !== "files" && initialized.capabilities.session?.history) {
-          const history = await session.readHistory({ requestId: "reverted-history", sessionId });
-          requireCondition(!history.items.some((entry) => entry.turnId === "conformance-turn-1"), "Conversation boundary was not reverted");
-        }
-      }
-      cases.push({ scenario, status: "passed" });
-    } catch (cause) {
-      cases.push({ scenario, status: "failed", message: cause instanceof Error ? cause.message : "Conformance failure" });
-    } finally {
-      await reader?.return?.();
-      await runtime?.dispose().catch(() => {});
-    }
-  }
-  return { passed: cases.every((entry) => entry.status !== "failed"), cases };
-}
-// packages/conformance/src/fake-claude.ts
-import { BoundedEventQueue } from "@anureo/sdk";
-
-class ScriptedClaudeQuery {
-  script;
-  calls = [];
-  queue = new BoundedEventQueue;
-  closed = false;
-  constructor(script) {
-    this.script = script;
-    for (const message of script.messages)
-      this.queue.push(structuredClone(message));
-  }
-  [Symbol.asyncIterator]() {
-    return this.queue[Symbol.asyncIterator]();
-  }
-  async streamInput(stream) {
-    for await (const input of stream) {
-      this.calls.push({ method: "input", value: input });
-      await this.script.onInput?.(input, (message) => this.queue.write(message));
-    }
-  }
-  async interrupt() {
-    this.calls.push({ method: "interrupt" });
-  }
-  async setModel(model) {
-    this.calls.push({ method: "setModel", ...model ? { value: model } : {} });
-  }
-  async setPermissionMode(mode) {
-    this.calls.push({ method: "setPermissionMode", value: mode });
-  }
-  async setMaxThinkingTokens(tokens) {
-    this.calls.push({ method: "setMaxThinkingTokens", value: tokens });
-  }
-  async rewindFiles(id) {
-    this.calls.push({ method: "rewindFiles", value: id });
-    return this.script.canRewind ? { canRewind: true } : { canRewind: false, error: "No checkpoint" };
-  }
-  async supportedModels() {
-    return this.script.models ?? [{ value: "fake-model", displayName: "Fake", description: "Fixture" }];
-  }
-  finish() {
-    this.queue.end();
-  }
-  close() {
-    if (!this.closed) {
-      this.closed = true;
-      this.calls.push({ method: "close" });
-      this.queue.end();
-    }
-  }
-}
-function createFakeClaudeQuery(script) {
-  return new ScriptedClaudeQuery(script);
-}
-export {
-  CONFORMANCE_SCENARIOS,
-  FAKE_CAPABILITIES,
-  ScriptedBackendSession,
-  ScriptedClaudeQuery,
-  ScriptedHarnessAdapter,
-  createFakeClaudeQuery,
-  createScriptedAdapter,
-  createScriptedConformanceFactory,
-  runConformance
-};

package/dist/suite.d.ts

@@ -1,28 +0,0 @@
-import { type HarnessAdapter, type HarnessSession, type RuntimeOptions } from "@anureo/sdk";
-import { type InteractionRequested, type InteractionResponse, type SessionOpenParams } from "@anureo/protocol";
-export declare const CONFORMANCE_SCENARIOS: readonly ["lifecycle", "immediate", "identity", "approval", "userInput", "elicitation", "dynamicTool", "interrupt", "steer", "fork", "revert", "history", "unknown-item", "disconnect", "backpressure"];
-export type ConformanceScenario = typeof CONFORMANCE_SCENARIOS[number];
-export interface ConformanceDriver {
-    adapter: HarnessAdapter;
-    openParams: SessionOpenParams;
-    runtimeOptions?: RuntimeOptions;
-    /** Deterministic fake-source trigger, called after a turn has been accepted. */
-    afterStart?: (session: HarnessSession) => Promise<void>;
-    expectedText?: string;
-    answer?: (request: InteractionRequested) => InteractionResponse;
-}
-export type ConformanceFactory = (scenario: ConformanceScenario) => Promise<ConformanceDriver> | ConformanceDriver;
-export interface ConformanceCaseResult {
-    scenario: ConformanceScenario;
-    status: "passed" | "failed" | "not-applicable";
-    message?: string;
-}
-export interface ConformanceReport {
-    passed: boolean;
-    cases: ConformanceCaseResult[];
-}
-/** Every declared optional capability must pass its scenario; missing fixtures are failures. */
-export declare function runConformance(factory: ConformanceFactory, options?: {
-    timeoutMs?: number;
-    scenarios?: readonly ConformanceScenario[];
-}): Promise<ConformanceReport>;

package/examples/standalone.mjs

@@ -1,53 +0,0 @@
-import { validateRequest } from '@anureo/protocol'
-import { createHarnessRuntime } from '@anureo/sdk'
-import { createScriptedConformanceFactory, runConformance } from '@anureo/conformance'
-import { fileURLToPath } from 'node:url'
-if (!validateRequest('turn/start', { requestId: 'start', sessionId: 's', turnId: 't', input: [{ type: 'text', text: 'standalone' }] })) throw new Error('Schema failed')
-const report = await runConformance(createScriptedConformanceFactory(), { scenarios: ['lifecycle','approval','interrupt','history'] })
-if (!report.passed) throw new Error(JSON.stringify(report))
-const adapters = process.argv.slice(2)
-const loaders = { codex: () => import('@anureo/adapter-codex'), claude: () => import('@anureo/adapter-claude'), acp: () => import('@anureo/adapter-acp'), ahp: () => import('@anureo/adapter-ahp') }
-for (const name of adapters) {
-  const module = await loaders[name]()
-  if (typeof module['create' + name[0].toUpperCase() + name.slice(1) + 'Adapter'] !== 'function') throw new Error('Missing adapter export ' + name)
-}
-const nativeExamples = []
-async function exercise(name, create, executable, text, interrupt) {
-  const runtime = createHarnessRuntime(create({ command: process.execPath, args: [fileURLToPath(new URL(executable, import.meta.url))] }))
-  let timeout
-  try {
-    await runtime.initialize({ protocolVersions: [1], clientInfo: { name: 'clean-install-example', version: '1.0.0' }, clientCapabilities: { interactions: ['approval','userInput','elicitation','dynamicTool'] } })
-    const session = await runtime.openSession({ requestId: 'open', mode: 'new', cwd: process.cwd(), binding: { sessionId: 'example-' + name, adapterId: name, runtimeConfigId: 'clean' } })
-    let sawApproval = false
-    const observing = (async () => {
-      for await (const event of session.events()) {
-        if (event.type === 'interaction/requested') {
-          sawApproval = true
-          if (event.payload.kind !== 'approval') throw new Error('Unexpected interaction')
-          const option = event.payload.options.find(option => option.semantic === 'deny') ?? event.payload.options.find(option => option.id === 'deny')
-          if (!option) throw new Error('No non-authorizing option')
-          await session.respond({ requestId: 'respond', sessionId: session.binding.sessionId, interactionId: event.payload.interactionId, response: { kind: 'approval', optionId: option.id } })
-        }
-        if (event.type === 'turn/completed') return event.payload
-      }
-      throw new Error('No terminal event')
-    })()
-    void observing.catch(() => {})
-    await session.startTurn({ requestId: 'start', sessionId: session.binding.sessionId, turnId: 'example-turn', input: [{ type: 'text', text }] })
-    if (interrupt) await session.interrupt({ requestId: 'interrupt', sessionId: session.binding.sessionId, turnId: 'example-turn' })
-    const terminal = await Promise.race([observing, new Promise((_, reject) => { timeout = setTimeout(() => reject(new Error('Standalone example timed out')), 5000) })])
-    if (terminal.status !== (interrupt ? 'interrupted' : 'completed')) throw new Error('Wrong terminal status: ' + terminal.status)
-    if (text === '/approval' && !sawApproval) throw new Error('Approval not exercised')
-    await session.close()
-    return { adapter: name, input: text, status: terminal.status, approval: sawApproval }
-  } finally { clearTimeout(timeout); await runtime.dispose() }
-}
-if (adapters.includes('acp')) {
-  const { createAcpAdapter } = await import('@anureo/adapter-acp')
-  for (const text of ['hello','/approval','/wait']) nativeExamples.push(await exercise('acp', createAcpAdapter, './acp-agent.mjs', text, text === '/wait'))
-}
-if (adapters.includes('ahp')) {
-  const { createAhpAdapter } = await import('@anureo/adapter-ahp')
-  for (const text of ['hello','/approval','/wait']) nativeExamples.push(await exercise('ahp', createAhpAdapter, './ahp-reference.mjs', text, text === '/wait'))
-}
-console.log(JSON.stringify({ status: 'passed', schema: true, conformance: report.cases, adapters, nativeExamples }))