@termwright/conformance 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,49 +1,111 @@
 // src/adapter-conformance.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join3 } from "path";
-import { ADAPTER_CAPABILITIES, validateSnapshot, DEFAULT_LIMITS as DEFAULT_LIMITS3 } from "@termwright/protocol";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join4 } from "path";
+import {
+  ADAPTER_CAPABILITIES,
+  validateSnapshot,
+  DEFAULT_LIMITS as DEFAULT_LIMITS3,
+  PROTOCOL_ID as PROTOCOL_ID2
+} from "@termwright/protocol";
 
 // src/support/probe.ts
-import { createServer } from "net";
+import "net";
 import { readFileSync } from "fs";
-import { mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join2 } from "path";
-import { randomBytes, randomUUID } from "crypto";
+import { rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join3 } from "path";
+import { randomBytes as randomBytes2, randomUUID } from "crypto";
 import {
   DEFAULT_LIMITS as DEFAULT_LIMITS2,
   ENV_ENDPOINT as ENV_ENDPOINT2,
-  ENV_PROTOCOL,
   ENV_TOKEN as ENV_TOKEN2,
   MARKER_OSC_CODE,
   MARKER_OSC_PREFIX,
   parseAdapterMessage,
   PROTOCOL_ID,
-  PROTOCOL_VERSION,
-  applyTreeDelta,
   createFrameDecoder,
   encodeFrame,
   generateToken,
   verifyMarkerPayload
 } from "@termwright/protocol";
-import xh from "@xterm/headless";
-import { createNodePtyBackend as createNodePtyBackend2 } from "@termwright/driver";
+import { createNativePtyBackend, VtScreen } from "@termwright/driver/experimental";
 
 // src/support/pty.ts
 import { spawnSync } from "child_process";
 import { existsSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { launchTerminal, createNodePtyBackend } from "@termwright/driver";
+import { launchTerminal } from "@termwright/driver";
+import { nativePtyAvailable } from "@termwright/driver/experimental";
 
-// ../probe-ink/dist/chunk-4KCXY7SI.js
+// ../probe-ink/dist/chunk-SLKX554P.js
+var certified_instrumentation_default = {
+  framework: "ink",
+  profiles: [
+    {
+      coreSha256: "f632f6176e593183f0c0bb6e4a6e8a28d65f1c3899a33a84d4a95d26e1a82a58",
+      rendererSha256: "9e72b27731c38daac7e9f978e24f7bf1210c5cc26bf973e30f08c3ad4a9fe374",
+      version: "7.1.1"
+    }
+  ],
+  schemaVersion: 1
+};
+var BUILTIN_PROFILES = certified_instrumentation_default.profiles;
+var INK_VERSION = BUILTIN_PROFILES.at(-1)?.version ?? "unsupported";
+
+// ../probe-ink/dist/chunk-5ZU7V4OQ.js
 import { validateProbeAnnotations } from "@termwright/protocol";
 
+// ../pty/dist/index.js
+import { parseConPtyHostCursorResponse } from "@termwright/protocol";
+var ESC = 27;
+var bytes = (...values) => Buffer.from(values);
+var DA1 = bytes(ESC, 91, 99);
+var WINDOW_DEICONIFY = bytes(ESC, 91, 49, 116);
+var WINDOW_ICONIFY = bytes(ESC, 91, 50, 116);
+var FOCUS_ON = bytes(ESC, 91, 63, 49, 48, 48, 52, 104);
+var FOCUS_OFF = bytes(ESC, 91, 63, 49, 48, 48, 52, 108);
+var WIN32_ON = bytes(ESC, 91, 63, 57, 48, 48, 49, 104);
+var WIN32_OFF = bytes(ESC, 91, 63, 57, 48, 48, 49, 108);
+var RIS = bytes(ESC, 99);
+var HOST_CURSOR_REQUEST_PREFIX = Buffer.from("\x1B]8488;twh-cpr-v1:q:", "ascii");
+var HOST_CURSOR_REPLY_NAMESPACE = Buffer.from("\x1B]8488;twh-cpr-v1:r:", "ascii");
+var STARTUP_REWRITES = [
+  {
+    // VtIo's ordinary startup handshake.
+    input: Buffer.concat([DA1, FOCUS_ON, WIN32_ON]),
+    output: DA1,
+    hostQueries: ["primary-device-attributes"]
+  }
+];
+var HOST_REWRITES = [
+  // AdaptDispatch reinjects these immediately after the child reset that
+  // caused them. Keeping the reset preserves the child's original bytes.
+  { input: Buffer.concat([FOCUS_OFF, FOCUS_ON]), output: FOCUS_OFF },
+  { input: Buffer.concat([WIN32_OFF, WIN32_ON]), output: WIN32_OFF },
+  { input: Buffer.concat([RIS, FOCUS_ON, WIN32_ON]), output: RIS }
+];
+var signalNumbers = Object.freeze({
+  HUP: 1,
+  INT: 2,
+  KILL: 9,
+  TERM: 15
+});
+var signalNames = Object.freeze({
+  1: "SIGHUP",
+  2: "SIGINT",
+  3: "SIGQUIT",
+  6: "SIGABRT",
+  9: "SIGKILL",
+  13: "SIGPIPE",
+  15: "SIGTERM"
+});
+
 // ../recognizers/dist/index.js
 import {
   DEFAULT_LIMITS,
-  resolveNodeBounds,
+  evidence,
   SEMANTIC_ROLES
 } from "@termwright/protocol";
 var HOST_ROLES = Object.freeze({
@@ -97,10 +159,10 @@ var ROLES = new Set(SEMANTIC_ROLES);
 var UTF8_ENCODER = new TextEncoder();
 var ROLE_MAPS = Object.freeze({ ink: roleForInkHost, opentui: roleForOpenTuiClass });
 
-// ../probe-ink/dist/chunk-IUFXTMZ7.js
+// ../probe-ink/dist/chunk-CLY2SLYH.js
 var INSTRUMENT_URL = new URL("./instrument.js", import.meta.url).href;
 
-// ../probe-ink/dist/chunk-LO7YF74P.js
+// ../probe-ink/dist/chunk-67M2GX5S.js
 import { ENV_ENDPOINT, ENV_TOKEN } from "@termwright/protocol";
 
 // ../probe-ink/dist/index.js
@@ -114,15 +176,13 @@ function withProbe(runtime, argv) {
   const [interpreter, ...rest] = argv;
   const flag = runtime === "bun" ? "--preload" : "--import";
   return {
-    command: [
-      interpreter,
-      flag,
-      pathToFileURL(PROBE_ENTRIES[runtime]).href,
-      ...rest
-    ],
+    command: [interpreter, flag, runtimePreloadSpecifier(runtime, PROBE_ENTRIES[runtime]), ...rest],
     runtime
   };
 }
+function runtimePreloadSpecifier(runtime, entry) {
+  return runtime === "bun" ? entry : pathToFileURL(entry).href;
+}
 
 // src/support/pty.ts
 function fixturePath(name) {
@@ -139,7 +199,9 @@ function packageRoot() {
     }
     const parent = dirname(directory);
     if (parent === directory) {
-      throw new Error("@termwright/conformance: could not locate the package root from this module");
+      throw new Error(
+        "@termwright/conformance: could not locate the package root from this module"
+      );
     }
     directory = parent;
   }
@@ -157,22 +219,7 @@ var CONFORMANCE_FIXTURES = Object.freeze({
 var cachedPty = null;
 function ptyAvailable() {
   if (cachedPty !== null) return cachedPty;
-  if (process.env["TERMWRIGHT_SKIP_PTY"] === "1") {
-    cachedPty = false;
-    return cachedPty;
-  }
-  try {
-    const pty = createNodePtyBackend().spawn({
-      command: [process.execPath, "-e", "process.exit(0)"],
-      env: environment(),
-      columns: 20,
-      rows: 4
-    });
-    pty.dispose();
-    cachedPty = true;
-  } catch {
-    cachedPty = false;
-  }
+  cachedPty = nativePtyAvailable();
   return cachedPty;
 }
 function environment(extra) {
@@ -217,18 +264,21 @@ function createSessionPool() {
   };
 }
 async function waitForStart(terminal, ready, fixture) {
-  let bytes = 0;
+  let bytes2 = 0;
   const off = terminal.events.on("output", ({ data }) => {
-    bytes += data.length;
+    bytes2 += data.length;
   });
   try {
     await terminal.waitForText(ready);
   } catch (error) {
     const exit = await Promise.race([terminal.exit, Promise.resolve(null)]);
-    const detail = bytes === 0 ? `it produced no output at all${exit === null ? " and is still running" : `; it exited ${JSON.stringify(exit)}`}` : `it produced ${bytes} bytes but never drew ${String(ready)}`;
-    throw new Error(`conformance: ${fixture.split("/").pop() ?? fixture} did not start \u2014 ${detail}`, {
-      cause: error
-    });
+    const detail = bytes2 === 0 ? `it produced no output at all${exit === null ? " and is still running" : `; it exited ${JSON.stringify(exit)}`}` : `it produced ${bytes2} bytes but never drew ${String(ready)}`;
+    throw new Error(
+      `conformance: ${fixture.split("/").pop() ?? fixture} did not start \u2014 ${detail}`,
+      {
+        cause: error
+      }
+    );
   } finally {
     off();
   }
@@ -242,7 +292,7 @@ function commandAvailable(command, options = {}) {
       ...options.cwd === void 0 ? {} : { cwd: options.cwd },
       timeout: options.timeoutMs ?? 12e4,
       encoding: "utf8",
-      env: environment()
+      env: environment(options.env)
     });
     if (result.status === 0) return true;
     if (options.quiet === true) return false;
@@ -264,6 +314,304 @@ ${(result.stderr ?? "").trim().split("\n").slice(-3).join("\n")}
   }
 }
 
+// src/support/probe-peer-owner.ts
+var ProbePeerOwner = class {
+  #sockets = /* @__PURE__ */ new Set();
+  #pending = [];
+  #handler = null;
+  #closing = false;
+  #closePromise = null;
+  admit(socket) {
+    socket.pause();
+    this.#sockets.add(socket);
+    socket.on("error", () => socket.destroy());
+    socket.once("close", () => {
+      this.#sockets.delete(socket);
+      const pending = this.#pending.indexOf(socket);
+      if (pending >= 0) this.#pending.splice(pending, 1);
+    });
+    if (this.#closing) {
+      socket.destroy();
+      return false;
+    }
+    if (this.#handler === null) this.#pending.push(socket);
+    else this.#deliver(socket);
+    return true;
+  }
+  activate(handler) {
+    if (this.#handler !== null) throw new Error("probe peer owner is already active");
+    this.#handler = handler;
+    for (const socket of this.#pending.splice(0)) this.#deliver(socket);
+  }
+  close(server) {
+    this.#closePromise ??= this.#close(server);
+    return this.#closePromise;
+  }
+  async #close(server) {
+    this.#closing = true;
+    const closed = new Promise((resolve, reject) => {
+      server.close((error) => error === void 0 ? resolve() : reject(error));
+    });
+    this.#pending.length = 0;
+    for (const socket of this.#sockets) socket.destroy();
+    await closed;
+  }
+  #deliver(socket) {
+    this.#handler?.(socket);
+    socket.resume();
+  }
+};
+
+// src/support/probe-process-shutdown.ts
+var DEFAULT_WATCHDOG_MS = 1e4;
+var ProbeProcessShutdown = class {
+  #resources;
+  #exit;
+  #resolveExit;
+  #exitStatus = null;
+  #stopPromise = null;
+  constructor(resources) {
+    this.#resources = resources;
+    let resolveExit;
+    this.#exit = new Promise((resolve) => {
+      resolveExit = resolve;
+    });
+    this.#resolveExit = resolveExit;
+  }
+  observeExit(status) {
+    if (this.#exitStatus !== null) return;
+    this.#exitStatus = Object.freeze({ ...status });
+    this.#resolveExit(this.#exitStatus);
+  }
+  stop() {
+    this.#stopPromise ??= this.#stop();
+    return this.#stopPromise;
+  }
+  async #stop() {
+    const failures = [];
+    let admissionClosedSuccessfully = false;
+    let admissionClosed;
+    try {
+      admissionClosed = this.#resources.closeAdmission().then(
+        () => {
+          admissionClosedSuccessfully = true;
+        },
+        (error) => {
+          failures.push(error);
+        }
+      );
+    } catch (error) {
+      failures.push(error);
+      admissionClosed = Promise.resolve();
+    }
+    const controller = new AbortController();
+    let causalBoundaryReached = false;
+    try {
+      await this.#withWatchdog(this.#reachCausalBoundary(controller.signal), controller);
+      causalBoundaryReached = true;
+    } catch (error) {
+      failures.push(error);
+    }
+    try {
+      this.#resources.closeTerminalResponseAdmission();
+    } catch (error) {
+      failures.push(error);
+    }
+    for (const dispose of [
+      () => this.#resources.pty.dispose(),
+      () => this.#resources.disposeParser()
+    ]) {
+      try {
+        dispose();
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    try {
+      await admissionClosed;
+    } catch (error) {
+      failures.push(error);
+    }
+    if (admissionClosedSuccessfully && causalBoundaryReached) {
+      try {
+        await this.#resources.removeArtifacts();
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) throw new AggregateError(failures, "adapter probe cleanup failed");
+  }
+  async #reachCausalBoundary(signal) {
+    const { pty } = this.#resources;
+    const initialTree = pty.treeState?.() ?? "unsupported";
+    if (initialTree === "alive") {
+      if (pty.hardKillTree === void 0) {
+        throw new Error(
+          `adapter probe cannot prove teardown of process ${String(pty.pid)}: the PTY exposes no owned-tree kill operation`
+        );
+      }
+      this.#resources.closeTerminalResponseAdmission();
+      await pty.hardKillTree(signal);
+    } else if (initialTree === "unsupported") {
+      throw new Error(
+        `adapter probe cannot prove teardown of process ${String(pty.pid)}: the PTY exposes no authoritative owned-tree state`
+      );
+    }
+    const outputEnded = pty.outputEnded;
+    if (outputEnded === void 0) {
+      throw new Error(
+        `adapter probe cannot prove teardown of process ${String(pty.pid)}: the PTY exposes no output EOF barrier`
+      );
+    }
+    await this.#awaitOrAbort(
+      Promise.all([this.#exit, outputEnded]).then(() => void 0),
+      signal
+    );
+    signal.throwIfAborted();
+    if (pty.sawOutputEnd?.() !== true) {
+      throw new Error(
+        `adapter probe cannot prove teardown of process ${String(pty.pid)}: the PTY output ended without authoritative EOF`
+      );
+    }
+    if (pty.treeState?.() !== "gone") {
+      throw new Error(
+        `adapter probe cannot prove teardown of process ${String(pty.pid)}: the owned process tree was not confirmed gone at EOF`
+      );
+    }
+    await this.#awaitOrAbort(this.#resources.drainParser(), signal);
+    signal.throwIfAborted();
+  }
+  async #awaitOrAbort(operation, signal) {
+    signal.throwIfAborted();
+    let removeAbortListener = () => void 0;
+    const aborted = new Promise((_resolve, reject) => {
+      const onAbort = () => reject(signal.reason);
+      signal.addEventListener("abort", onAbort, { once: true });
+      removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+    });
+    try {
+      await Promise.race([operation, aborted]);
+    } finally {
+      removeAbortListener();
+    }
+  }
+  async #withWatchdog(operation, controller) {
+    const watchdogMs = this.#resources.watchdogMs ?? DEFAULT_WATCHDOG_MS;
+    let timer;
+    const expired = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new Error(
+            `adapter probe teardown did not reach exit, authoritative EOF, and parser drain within its ${String(watchdogMs)} ms watchdog`
+          )
+        );
+        controller.abort();
+      }, watchdogMs);
+    });
+    try {
+      await Promise.race([operation, expired]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+      controller.abort();
+    }
+  }
+};
+
+// src/support/probe-startup.ts
+import { randomBytes } from "crypto";
+import { mkdtemp } from "fs/promises";
+import { createServer } from "net";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+
+// src/support/probe-start-cleanup.ts
+import { rm } from "fs/promises";
+async function rollbackProbeStart(primary, cleanup) {
+  const failures = [primary];
+  let serverClosed = Promise.resolve();
+  if (cleanup.closeAdmission !== void 0) {
+    try {
+      serverClosed = cleanup.closeAdmission();
+    } catch (error) {
+      failures.push(error);
+    }
+  }
+  if (cleanup.disposePty !== void 0) {
+    try {
+      cleanup.disposePty();
+    } catch (error) {
+      failures.push(error);
+    }
+  }
+  try {
+    await serverClosed;
+  } catch (error) {
+    failures.push(error);
+  }
+  for (const path of [cleanup.directory, cleanup.debugFile]) {
+    if (path === void 0 || path === null) continue;
+    try {
+      await rm(path, { recursive: path === cleanup.directory, force: true });
+    } catch (error) {
+      failures.push(error);
+    }
+  }
+  if (failures.length === 1) throw primary;
+  throw new AggregateError(failures, "adapter probe startup and rollback failed", {
+    cause: primary
+  });
+}
+
+// src/support/probe-startup.ts
+var ProbeStartupTransaction = class {
+  peers = new ProbePeerOwner();
+  server = null;
+  directory = null;
+  endpoint = null;
+  debugFile = null;
+  pty = null;
+  async acquireEndpoint(instrument, options = {}) {
+    if (!instrument) return;
+    this.server = createServer();
+    this.server.on("connection", (socket) => this.peers.admit(socket));
+    if (process.platform !== "win32" || options.allocateDirectory === true) {
+      this.directory = await mkdtemp(join2(tmpdir(), "termwright-probe-"));
+    }
+    if (process.platform === "win32") {
+      this.endpoint = `\\\\.\\pipe\\termwright-probe-${randomBytes(16).toString("hex")}`;
+    } else {
+      this.endpoint = join2(this.directory, "semantic.sock");
+    }
+    await (options.listen ?? listenServer)(this.server, this.endpoint);
+  }
+  rollback(primary) {
+    const server = this.server;
+    const pty = this.pty;
+    return rollbackProbeStart(primary, {
+      ...server === null || !server.listening ? {} : { closeAdmission: () => this.peers.close(server) },
+      ...pty === null ? {} : { disposePty: () => pty.dispose() },
+      directory: this.directory,
+      debugFile: this.debugFile
+    });
+  }
+};
+function listenServer(server, endpoint) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.removeListener("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(endpoint);
+  });
+}
+
 // src/support/probe.ts
 var LOG_BUDGET = Object.freeze({ enabled: true, maxRecordsPerSecond: 200, burst: 400 });
 var MARKER_PATTERN = new RegExp(
@@ -276,39 +624,52 @@ var AdapterProbe = class _AdapterProbe {
   #server;
   #directory;
   #pty;
-  #subscribe;
+  #vt;
   #terminal;
+  #detachTerminalResponse;
   #startedAt = performance.now();
   #messages = [];
   #markers = [];
   #faults = [];
   #logs = [];
-  #deltas = [];
-  #composed = null;
-  #compositionError = null;
-  #requestId = 0;
   #chunks = [];
   #bytes = 0;
   #text = "";
   #markerScanFrom = 0;
   #connections = 0;
   #socket = null;
+  #peers;
   #exit = null;
   /** Where the adapter writes its own account of attaching, if it writes one. */
   #debugFile = null;
-  #stopped = false;
-  constructor(identity, server, directory, pty, size, subscribe) {
-    this.#subscribe = subscribe;
+  #shutdown;
+  #changeWaiters = /* @__PURE__ */ new Set();
+  constructor(identity, server, directory, pty, size, peers) {
     this.sessionId = identity.sessionId;
     this.token = identity.token;
     this.#server = server;
     this.#directory = directory;
     this.#pty = pty;
-    this.#terminal = new xh.Terminal({
-      cols: size.columns,
+    this.#peers = peers;
+    this.#vt = new VtScreen({
+      columns: size.columns,
       rows: size.rows,
-      allowProposedApi: true,
-      scrollback: 1e3
+      scrollbackLines: 1e3
+    });
+    this.#terminal = this.#vt.terminal;
+    this.#detachTerminalResponse = this.#vt.onResponse(
+      (response) => this.#writeTerminalResponse(response.data)
+    );
+    this.#shutdown = new ProbeProcessShutdown({
+      pty,
+      closeAdmission: () => this.#server === null ? Promise.resolve() : this.#peers.close(this.#server),
+      closeTerminalResponseAdmission: () => this.#closeTerminalResponseAdmission(),
+      drainParser: () => this.#vt.drain(),
+      disposeParser: () => {
+        this.#notifyChange();
+        this.#vt.dispose();
+      },
+      removeArtifacts: () => this.#removeArtifacts()
     });
   }
   /** Creates the endpoint (unless dormant), then spawns the fixture. */
@@ -316,61 +677,48 @@ var AdapterProbe = class _AdapterProbe {
     const instrument = options.instrument ?? true;
     const sessionId = randomUUID();
     const token = generateToken();
-    let server = null;
-    let directory = null;
-    let endpoint = null;
-    if (instrument) {
-      server = createServer();
-      if (process.platform === "win32") {
-        endpoint = `\\\\.\\pipe\\termwright-probe-${randomBytes(16).toString("hex")}`;
-      } else {
-        directory = await mkdtemp(join2(tmpdir(), "termwright-probe-"));
-        endpoint = join2(directory, "semantic.sock");
+    const startup = new ProbeStartupTransaction();
+    try {
+      await startup.acquireEndpoint(instrument);
+      const { server, directory, endpoint, peers } = startup;
+      const env = environment(command.env);
+      delete env[ENV_ENDPOINT2];
+      delete env[ENV_TOKEN2];
+      if (endpoint !== null) {
+        env[ENV_ENDPOINT2] = endpoint;
+        env[ENV_TOKEN2] = token;
       }
-      const listening = server;
-      const address = endpoint;
-      await new Promise((resolve, reject) => {
-        listening.once("error", reject);
-        listening.listen(address, () => {
-          listening.removeListener("error", reject);
-          resolve();
-        });
+      startup.debugFile = join3(
+        tmpdir2(),
+        `termwright-adapter-debug-${randomBytes2(8).toString("hex")}.log`
+      );
+      env["TERMWRIGHT_DEBUG_FILE"] = startup.debugFile;
+      const size = { columns: options.columns ?? 80, rows: options.rows ?? 24 };
+      startup.pty = createNativePtyBackend().spawn({
+        command: command.command,
+        ...command.cwd === void 0 ? {} : { cwd: command.cwd },
+        env,
+        columns: size.columns,
+        rows: size.rows,
+        // This probe is itself the terminal emulator. Do not inherit a harness
+        // shell's `TERM=dumb`: the child is connected to our xterm-compatible
+        // parser regardless of which terminal launched Vitest.
+        term: "xterm-256color"
       });
+      const pty = startup.pty;
+      const probe = new _AdapterProbe({ sessionId, token }, server, directory, pty, size, peers);
+      probe.#debugFile = startup.debugFile;
+      pty.onData((data) => probe.#onData(data));
+      pty.onExit((status) => {
+        probe.#exit = status;
+        probe.#shutdown.observeExit(status);
+        probe.#notifyChange();
+      });
+      peers.activate((socket) => probe.#onConnection(socket));
+      return probe;
+    } catch (error) {
+      return startup.rollback(error);
     }
-    const env = environment(command.env);
-    delete env[ENV_ENDPOINT2];
-    delete env[ENV_TOKEN2];
-    delete env[ENV_PROTOCOL];
-    if (endpoint !== null) {
-      env[ENV_ENDPOINT2] = endpoint;
-      env[ENV_TOKEN2] = token;
-      env[ENV_PROTOCOL] = String(PROTOCOL_VERSION);
-    }
-    const debugFile = join2(tmpdir(), `termwright-adapter-debug-${randomBytes(8).toString("hex")}.log`);
-    env["TERMWRIGHT_DEBUG_FILE"] = debugFile;
-    const size = { columns: options.columns ?? 80, rows: options.rows ?? 24 };
-    const pty = createNodePtyBackend2().spawn({
-      command: command.command,
-      ...command.cwd === void 0 ? {} : { cwd: command.cwd },
-      env,
-      columns: size.columns,
-      rows: size.rows
-    });
-    const probe = new _AdapterProbe(
-      { sessionId, token },
-      server,
-      directory,
-      pty,
-      size,
-      options.subscribe ?? "snapshots"
-    );
-    probe.#debugFile = debugFile;
-    pty.onData((data) => probe.#onData(data));
-    pty.onExit((status) => {
-      probe.#exit = status;
-    });
-    server?.on("connection", (socket) => probe.#onConnection(socket));
-    return probe;
   }
   /** Everything observed so far. Safe to call at any point. */
   observe() {
@@ -382,10 +730,7 @@ var AdapterProbe = class _AdapterProbe {
       stdout: this.#stdout(),
       text: this.#text,
       screen: this.screenText(),
-      logs: this.#logs.map((entry) => entry),
-      deltas: this.#deltas.map((entry) => entry),
-      composed: this.#composed,
-      compositionError: this.#compositionError
+      logs: this.#logs.map((entry) => entry)
     };
   }
   /** The visible grid as text, trailing whitespace trimmed per row. */
@@ -414,18 +759,23 @@ var AdapterProbe = class _AdapterProbe {
    * cells never emits `focus: reject` as those twelve bytes in a row.
    */
   async waitForText(needle, timeoutMs = 1e4) {
-    const deadline = Date.now() + timeoutMs;
+    const deadline = performance.now() + timeoutMs;
     for (; ; ) {
+      const change = this.#armChange(deadline);
       const screen = this.screenText();
-      if (needle instanceof RegExp ? needle.test(screen) : screen.includes(needle)) return;
-      if (Date.now() >= deadline) {
+      if (needle instanceof RegExp ? needle.test(screen) : screen.includes(needle)) {
+        change.cancel();
+        return;
+      }
+      if (performance.now() >= deadline) {
+        change.cancel();
         throw new Error(
           `adapter conformance: ${String(needle)} never appeared on the fixture's screen
 screen was:
 ${screen}`
         );
       }
-      await delay(20);
+      await change.wait();
     }
   }
   /**
@@ -438,13 +788,18 @@ ${screen}`
    * and only the observation tells them apart.
    */
   async waitFor(predicate, timeoutMs = 1e4, what = "the condition") {
-    const deadline = Date.now() + timeoutMs;
+    const deadline = performance.now() + timeoutMs;
     for (; ; ) {
-      if (predicate(this.observe())) return;
-      if (Date.now() >= deadline) {
+      const change = this.#armChange(deadline);
+      if (predicate(this.observe())) {
+        change.cancel();
+        return;
+      }
+      if (performance.now() >= deadline) {
+        change.cancel();
         throw new Error(`adapter conformance: ${what} never happened \u2014 ${this.describe()}`);
       }
-      await delay(20);
+      await change.wait();
     }
   }
   /** What the probe has seen so far, for a failure that has to explain itself. */
@@ -484,10 +839,18 @@ ${this.#adapterAccount()}`;
   }
   /** Waits for the child to exit and returns its status. */
   async waitForExit(timeoutMs = 1e4) {
-    const deadline = Date.now() + timeoutMs;
+    const deadline = performance.now() + timeoutMs;
     while (this.#exit === null) {
-      if (Date.now() >= deadline) throw new Error("adapter conformance: the fixture never exited");
-      await delay(20);
+      const change = this.#armChange(deadline);
+      if (this.#exit !== null) {
+        change.cancel();
+        break;
+      }
+      if (performance.now() >= deadline) {
+        change.cancel();
+        throw new Error("adapter conformance: the fixture never exited");
+      }
+      await change.wait();
     }
     return this.#exit;
   }
@@ -497,17 +860,29 @@ ${this.#adapterAccount()}`;
     this.#socket = null;
   }
   /** Stops the child and releases the endpoint. Idempotent. */
-  async stop() {
-    if (this.#stopped) return;
-    this.#stopped = true;
-    this.#socket?.destroy();
-    this.#pty.dispose();
-    this.#terminal.dispose();
-    if (this.#server !== null) await new Promise((resolve) => this.#server?.close(() => resolve()));
-    if (this.#directory !== null) await rm(this.#directory, { recursive: true, force: true }).catch(() => {
-    });
-    if (this.#debugFile !== null) await rm(this.#debugFile, { force: true }).catch(() => {
-    });
+  stop() {
+    return this.#shutdown.stop();
+  }
+  async #removeArtifacts() {
+    const failures = [];
+    if (this.#directory !== null) {
+      try {
+        await rm2(this.#directory, { recursive: true, force: true });
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (this.#debugFile !== null) {
+      try {
+        await rm2(this.#debugFile, { force: true });
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    this.#notifyChange();
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1)
+      throw new AggregateError(failures, "adapter probe artifact cleanup failed");
   }
   // -------------------------------------------------------------------------
   #stdout() {
@@ -524,8 +899,23 @@ ${this.#adapterAccount()}`;
     this.#chunks.push(data);
     this.#bytes += data.length;
     this.#text += Buffer.from(data).toString("utf8");
-    this.#terminal.write(data);
+    void this.#vt.write(data).finally(() => this.#notifyChange());
     this.#scanMarkers();
+    this.#notifyChange();
+  }
+  /** Returns emulator-owned replies without presenting them as user input. */
+  #writeTerminalResponse(response) {
+    const data = Buffer.from(response, "utf8");
+    const write = this.#pty.writeTerminalResponse;
+    if (write === void 0) {
+      this.#pty.write(data, "raw");
+      return;
+    }
+    write.call(this.#pty, data);
+  }
+  #closeTerminalResponseAdmission() {
+    this.#detachTerminalResponse?.();
+    this.#detachTerminalResponse = null;
   }
   /** Finds render markers in the byte stream and verifies each against the token. */
   #scanMarkers() {
@@ -536,7 +926,10 @@ ${this.#adapterAccount()}`;
       const payload = match[1] ?? "";
       const verified = verifyMarkerPayload(payload, this.token, this.sessionId);
       if (verified === null) {
-        this.#faults.push({ code: "marker", detail: `marker did not verify: ${JSON.stringify(payload)}` });
+        this.#faults.push({
+          code: "marker",
+          detail: `marker did not verify: ${JSON.stringify(payload)}`
+        });
       } else {
         this.#markers.push({ revision: verified.revision, offset: match.index, atMs: this.#now() });
       }
@@ -546,8 +939,12 @@ ${this.#adapterAccount()}`;
   }
   #onConnection(socket) {
     this.#connections += 1;
+    this.#notifyChange();
     if (this.#socket !== null) {
-      this.#faults.push({ code: "second-connection", detail: "the adapter opened a second channel" });
+      this.#faults.push({
+        code: "second-connection",
+        detail: "the adapter opened a second channel"
+      });
       socket.destroy();
       return;
     }
@@ -558,35 +955,38 @@ ${this.#adapterAccount()}`;
       try {
         frames = decoder.push(chunk);
       } catch (error) {
-        this.#faults.push({ code: "framing", detail: error instanceof Error ? error.message : String(error) });
+        this.#faults.push({
+          code: "framing",
+          detail: error instanceof Error ? error.message : String(error)
+        });
+        this.#notifyChange();
         socket.destroy();
         return;
       }
       for (const frame of frames) this.#onFrame(socket, frame);
     });
-    socket.on("error", () => socket.destroy());
     socket.on("close", () => {
       if (this.#socket === socket) this.#socket = null;
+      this.#notifyChange();
     });
   }
   #onFrame(socket, frame) {
     const parsed = parseAdapterMessage(frame, DEFAULT_LIMITS2);
     if (!parsed.ok) {
       this.#faults.push({ code: parsed.code, detail: parsed.detail });
+      this.#notifyChange();
       return;
     }
     this.#messages.push({ message: parsed.message, stdoutBytes: this.#bytes, atMs: this.#now() });
     if (parsed.message.type === "log") this.#logs.push(parsed.message.record);
-    if (parsed.message.type === "snapshot") this.#composed = parsed.message.snapshot;
-    if (parsed.message.type === "tree-delta") this.#compose(parsed.message);
+    this.#notifyChange();
     if (parsed.message.type !== "hello") return;
     const ack = {
       type: "hello-ack",
       protocol: PROTOCOL_ID,
       sessionId: this.sessionId,
       limits: DEFAULT_LIMITS2,
-      // Deltas are only ever sent to a driver that asked for them.
-      subscribe: this.#subscribe === "diffs" && parsed.message.capabilities.includes("tree-diffs") ? "diffs" : "snapshots",
+      subscribe: "snapshots",
       marker: { enabled: parsed.message.capabilities.includes("render-revisions") },
       // Granted only to an adapter that asked: an adapter that never announced
       // `logs` must not be handed a budget it can then claim it was given.
@@ -594,78 +994,39 @@ ${this.#adapterAccount()}`;
     };
     socket.write(encodeFrame(ack, DEFAULT_LIMITS2.maxFrameBytes));
   }
-  /** Applies one delta to the held tree, recording the first failure. */
-  #compose(delta) {
-    const { type: _type, ...body } = delta;
-    this.#deltas.push(body);
-    const base = this.#composed;
-    if (base === null) {
-      this.#compositionError ??= `delta ${body.baseRevision}\u2192${body.revision} arrived before any full tree`;
-      return;
-    }
-    const result = applyTreeDelta(base, body, DEFAULT_LIMITS2);
-    if (!result.ok) {
-      this.#compositionError ??= `delta ${body.baseRevision}\u2192${body.revision} did not compose (${result.code}): ${result.detail}`;
-      return;
-    }
-    this.#composed = result.snapshot;
-  }
-  /**
-   * Asks the adapter for a full tree and resolves with it.
-   *
-   * This is what turns composition into a check rather than a belief: the
-   * locally composed tree is compared against one the adapter built itself.
-   */
-  async requestTree(timeoutMs = 1e4) {
-    const socket = this.#socket;
-    if (socket === null) return null;
-    this.#requestId += 1;
-    const requestId = this.#requestId;
-    socket.write(encodeFrame({ type: "get-tree", requestId }, DEFAULT_LIMITS2.maxFrameBytes));
-    const deadline = Date.now() + timeoutMs;
-    for (; ; ) {
-      const reply = this.#messages.find(
-        (entry) => entry.message.type === "get-tree-result" && entry.message.requestId === requestId
-      );
-      if (reply !== void 0) {
-        return reply.message.snapshot ?? null;
-      }
-      if (Date.now() >= deadline) return null;
-      await delay(20);
-    }
-  }
   #now() {
     return performance.now() - this.#startedAt;
   }
+  #notifyChange() {
+    for (const resolve of [...this.#changeWaiters]) resolve();
+  }
+  #armChange(deadline) {
+    let settled = false;
+    let resolvePromise;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      this.#changeWaiters.delete(finish);
+      resolvePromise();
+    };
+    const promise = new Promise((resolve) => {
+      resolvePromise = resolve;
+    });
+    const timer = setTimeout(finish, Math.max(0, deadline - performance.now()));
+    timer.unref?.();
+    this.#changeWaiters.add(finish);
+    return { wait: () => promise, cancel: finish };
+  }
 };
 var MARKER_TEXT_PREFIX = `\x1B]${MARKER_OSC_CODE};${MARKER_OSC_PREFIX}`;
-function delay(ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-  });
-}
 
 // src/adapter-conformance.ts
-async function assertDeltasCompose(probe, timeoutMs) {
-  const { expect } = await import("vitest");
-  const observation = probe.observe();
-  expect(observation.compositionError, "the adapter produced a delta nobody could apply").toBeNull();
-  expect(observation.composed).not.toBeNull();
-  expect(observation.deltas.length).toBeGreaterThan(0);
-  const authoritative = await probe.requestTree(timeoutMs);
-  expect(authoritative, "the adapter answered no get-tree").not.toBeNull();
-  const composed = observation.composed;
-  const truth = authoritative;
-  const byId = (nodes) => [...nodes].sort((left, right) => left.id.localeCompare(right.id));
-  expect(byId(truth.nodes)).toEqual(byId(composed.nodes));
-  expect([...truth.rootIds].sort()).toEqual([...composed.rootIds].sort());
-}
-var CONVENTION_SUMMARY_DIR = join3(tmpdir2(), "termwright-conformance-conventions");
+var CONVENTION_SUMMARY_DIR = join4(tmpdir3(), "termwright-conformance-conventions");
 function writeConventionSummary(name, declared, outcomes) {
   try {
     mkdirSync(CONVENTION_SUMMARY_DIR, { recursive: true });
-    const file = join3(CONVENTION_SUMMARY_DIR, `${name.replace(/[^\w.-]+/gu, "_")}.json`);
+    const file = join4(CONVENTION_SUMMARY_DIR, `${name.replace(/[^\w.-]+/gu, "_")}.json`);
     writeFileSync(
       file,
       JSON.stringify(
@@ -688,20 +1049,14 @@ function writeConventionSummary(name, declared, outcomes) {
   } catch {
   }
 }
-function delay2(ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-  });
-}
 async function settle(probe, quietMs = 250, budgetMs = 5e3) {
-  const deadline = Date.now() + budgetMs;
+  const deadline = performance.now() + budgetMs;
   let seen = -1;
   for (; ; ) {
     const length = probe.observe().stdout.length;
     if (length === seen) return;
     seen = length;
-    if (Date.now() >= deadline) return;
+    if (performance.now() >= deadline) return;
     await new Promise((resolve) => {
       setTimeout(resolve, quietMs);
     });
@@ -747,11 +1102,14 @@ var CONTAINER_ROLES = /* @__PURE__ */ new Set([
 ]);
 var snapshotsOf = (observation) => observation.messages.filter((entry) => entry.message.type === "snapshot").map((entry) => entry.message.snapshot);
 async function runAdapterConformance(options) {
-  const { afterAll, beforeAll, describe, expect, it } = await import("vitest");
+  const { afterAll, afterEach, beforeEach, describe, expect } = await import("vitest");
+  const { it: resourceAwareIt } = await import("@termwright/resource-broker/vitest");
+  const it = resourceAwareIt.resources({ terminals: 1, traceWriters: 0 });
   const timeout = options.timeoutMs ?? 1e4;
   const toolchain = options.requires === void 0 || commandAvailable(options.requires.probe, {
     ...options.requires.cwd === void 0 ? {} : { cwd: options.requires.cwd },
-    ...options.requires.timeoutMs === void 0 ? {} : { timeoutMs: options.requires.timeoutMs }
+    ...options.requires.timeoutMs === void 0 ? {} : { timeoutMs: options.requires.timeoutMs },
+    ...options.requires.env === void 0 ? {} : { env: options.requires.env }
   });
   const probeOptions = {
     ...options.columns === void 0 ? {} : { columns: options.columns },
@@ -761,7 +1119,10 @@ async function runAdapterConformance(options) {
   describe.skipIf(!ptyAvailable() || !toolchain)(title, { timeout: timeout * 4 }, () => {
     describe("the dormant rule", () => {
       it("opens nothing and emits no marker without an endpoint", async () => {
-        const probe = await AdapterProbe.start(options.spawn(), { ...probeOptions, instrument: false });
+        const probe = await AdapterProbe.start(options.spawn(), {
+          ...probeOptions,
+          instrument: false
+        });
         try {
           await probe.waitForText(options.ready, timeout);
           await probe.write(options.interaction.input);
@@ -803,7 +1164,7 @@ async function runAdapterConformance(options) {
     describe("an instrumented session", () => {
       let probe;
       let beforeInput;
-      beforeAll(
+      beforeEach(
         async () => {
           probe = await AdapterProbe.start(options.spawn(), probeOptions);
           await probe.waitForText(options.ready, timeout);
@@ -820,7 +1181,7 @@ async function runAdapterConformance(options) {
         // timeout, which makes real adapters flaky under a parallel root run.
         timeout * 4
       );
-      afterAll(async () => {
+      afterEach(async () => {
         await probe?.stop();
       });
       it("completes the handshake before anything else", async () => {
@@ -829,10 +1190,14 @@ async function runAdapterConformance(options) {
         expect(connections).toBe(1);
         expect(first?.message.type).toBe("hello");
         const hello = first?.message;
-        expect(hello.protocol).toBe("termwright/1");
+        expect(hello.protocol).toBe(PROTOCOL_ID2);
         expect(hello.adapter.name.length).toBeGreaterThan(0);
         expect(hello.adapter.version.length).toBeGreaterThan(0);
-        expect(hello.capabilities.every((entry) => ADAPTER_CAPABILITIES.includes(entry))).toBe(true);
+        expect(
+          hello.capabilities.every(
+            (entry) => ADAPTER_CAPABILITIES.includes(entry)
+          )
+        ).toBe(true);
         expect(hello.capabilities).toContain("tree");
         expect(messages.filter((entry) => entry.message.type === "hello")).toHaveLength(1);
         const firstLog = messages.findIndex((entry) => entry.message.type === "log");
@@ -849,7 +1214,10 @@ async function runAdapterConformance(options) {
           const addressable = (latest?.nodes ?? []).filter(
             (node) => node.name.length > 0 || node.testId !== void 0
           );
-          expect(addressable.length, "the tree has no node that a locator could address").toBeGreaterThan(0);
+          expect(
+            addressable.length,
+            "the tree has no node that a locator could address"
+          ).toBeGreaterThan(0);
         }
       );
       it("publishes only valid snapshots, bound to this session", async () => {
@@ -860,7 +1228,7 @@ async function runAdapterConformance(options) {
         for (const snapshot of snapshots) {
           expect(validateSnapshot(snapshot, DEFAULT_LIMITS3)).toMatchObject({ ok: true });
           expect(snapshot.sessionId).toBe(probe.sessionId);
-          expect(snapshot.v).toBe(1);
+          expect(snapshot.v).toBe(2);
           const ids = new Set(snapshot.nodes.map((node) => node.id));
           for (const node of snapshot.nodes) {
             if (node.parentId === void 0) expect(snapshot.rootIds).toContain(node.id);
@@ -870,20 +1238,25 @@ async function runAdapterConformance(options) {
         const revisions = snapshots.map((snapshot) => snapshot.revision);
         expect([...revisions]).toEqual([...new Set(revisions)].sort((left, right) => left - right));
       });
-      it.skipIf(options.expectAbsoluteBounds !== true)("publishes viewport-absolute bounds", () => {
-        const snapshots = snapshotsOf(probe.observe());
-        const latest = snapshots[snapshots.length - 1];
-        expect(latest).toBeDefined();
-        const bounded = latest?.nodes.filter((node) => node.bounds !== void 0) ?? [];
-        expect(bounded.length).toBeGreaterThan(0);
-        for (const node of bounded) {
-          const bounds = node.bounds;
-          expect(bounds.row).toBeGreaterThanOrEqual(0);
-          expect(bounds.column).toBeGreaterThanOrEqual(0);
-          expect(bounds.row).toBeLessThan(latest?.rows ?? 0);
-          expect(bounds.column).toBeLessThan(latest?.columns ?? 0);
+      it.skipIf(options.expectIntendedGeometry !== true)(
+        "publishes intended geometry in viewport cells",
+        () => {
+          const snapshots = snapshotsOf(probe.observe());
+          const latest = snapshots[snapshots.length - 1];
+          expect(latest).toBeDefined();
+          const bounded = latest?.nodes.filter((node) => node.geometry.intendedRect.status === "known") ?? [];
+          expect(bounded.length).toBeGreaterThan(0);
+          for (const node of bounded) {
+            const bounds = node.geometry.intendedRect.status === "known" ? node.geometry.intendedRect.value : void 0;
+            expect(bounds).toBeDefined();
+            if (bounds === void 0) continue;
+            expect(bounds.row).toBeGreaterThanOrEqual(0);
+            expect(bounds.column).toBeGreaterThanOrEqual(0);
+            expect(bounds.row).toBeLessThan(latest?.rows ?? 0);
+            expect(bounds.column).toBeLessThan(latest?.columns ?? 0);
+          }
         }
-      });
+      );
       it("orders every revision as snapshot, then commit, then marker", async () => {
         await probe.write(options.interaction.input);
         await probe.waitForText(options.interaction.expect, timeout);
@@ -952,7 +1325,12 @@ async function runAdapterConformance(options) {
           return;
         }
         if (titles.length > 0) {
-          outcomes.push({ rule, what, status: "documented", detail: `${titles.join("; ")} \u2014 ${failure}` });
+          outcomes.push({
+            rule,
+            what,
+            status: "documented",
+            detail: `${titles.join("; ")} \u2014 ${failure}`
+          });
           return;
         }
         outcomes.push({ rule, what, status: "violation", detail: failure });
@@ -977,7 +1355,7 @@ async function runAdapterConformance(options) {
           const latest = snapshotsOf(beforeInput).at(-1);
           const node = latest?.nodes.find((entry) => entry.testId === wanted);
           if (node === void 0) return `no node carries the test id ${JSON.stringify(wanted)}`;
-          return node.value === "" ? null : `the value is ${JSON.stringify(node.value)}, not an empty string`;
+          return node.value?.status === "known" && node.value.value === "" ? null : `the value is ${JSON.stringify(node.value)}, not an empty known value`;
         });
       });
       it("convention 5: value is derived only for value-bearing roles", () => {
@@ -990,7 +1368,9 @@ async function runAdapterConformance(options) {
           if (offenders.length > 0) {
             return `derived a value outside {textbox, progressbar}: ${offenders.map((node) => `${node.role} ${JSON.stringify(node.name)}`).join(", ")}`;
           }
-          const booleans = nodes.filter((node) => node.value === "true" || node.value === "false");
+          const booleans = nodes.filter(
+            (node) => node.value?.status === "known" && (node.value.value === "true" || node.value.value === "false")
+          );
           return booleans.length === 0 ? null : `published a boolean as a value on ${booleans.map((node) => node.role).join(", ")}`;
         });
       });
@@ -1054,47 +1434,33 @@ async function runAdapterConformance(options) {
           "the adapter sent log records without announcing the logs capability"
         ).toEqual([]);
       });
-      it.skipIf(options.logs === void 0)("carries a log record without printing it", async () => {
-        const logs = options.logs;
-        const hello = probe.observe().messages[0]?.message;
-        expect(
-          hello.capabilities.includes("logs"),
-          "the registration declares logs, but the adapter never announced the capability"
-        ).toBe(true);
-        const before = probe.observe().logs.length;
-        if (logs.input !== void 0) await probe.write(logs.input);
-        await probe.waitFor(
-          (observation2) => observation2.logs.length > (logs.input === void 0 ? 0 : before),
-          timeout,
-          "a log record over the negotiated channel"
-        );
-        const observation = probe.observe();
-        const record = observation.logs.find((entry) => entry.message.includes(logs.expect));
-        expect(record, `no log record matched ${JSON.stringify(logs.expect)}`).toBeDefined();
-        expect(record?.seq).toBeGreaterThanOrEqual(0);
-        const seqs = observation.logs.map((entry) => entry.seq);
-        expect(seqs).toEqual([...seqs].sort((left, right) => left - right));
-        expect(new Set(seqs).size).toBe(seqs.length);
-        expect(observation.screen).not.toContain(logs.expect);
-        expect(observation.text).not.toContain(logs.expect);
-      });
-      it("produces deltas that compose to the tree it would have sent", async () => {
-        const announced = (beforeInput.messages[0]?.message).capabilities;
-        if (!announced.includes("tree-diffs")) return;
-        const diffs = await AdapterProbe.start(options.spawn(), { ...probeOptions, subscribe: "diffs" });
-        try {
-          await diffs.waitForText(options.ready, timeout);
-          await diffs.waitFor((observation) => observation.composed !== null, timeout);
-          for (let press = 0; press < 3; press += 1) {
-            await diffs.write(options.interaction.input);
-            await delay2(150);
-          }
-          await diffs.waitFor((observation) => observation.deltas.length > 0, timeout);
-          await assertDeltasCompose(diffs, timeout);
-        } finally {
-          await diffs.stop();
+      it.skipIf(options.logs === void 0)(
+        "carries a log record without printing it",
+        async () => {
+          const logs = options.logs;
+          const hello = probe.observe().messages[0]?.message;
+          expect(
+            hello.capabilities.includes("logs"),
+            "the registration declares logs, but the adapter never announced the capability"
+          ).toBe(true);
+          const before = probe.observe().logs.length;
+          if (logs.input !== void 0) await probe.write(logs.input);
+          await probe.waitFor(
+            (observation2) => observation2.logs.length > (logs.input === void 0 ? 0 : before),
+            timeout,
+            "a log record over the negotiated channel"
+          );
+          const observation = probe.observe();
+          const record = observation.logs.find((entry) => entry.message.includes(logs.expect));
+          expect(record, `no log record matched ${JSON.stringify(logs.expect)}`).toBeDefined();
+          expect(record?.seq).toBeGreaterThanOrEqual(0);
+          const seqs = observation.logs.map((entry) => entry.seq);
+          expect(seqs).toEqual([...seqs].sort((left, right) => left - right));
+          expect(new Set(seqs).size).toBe(seqs.length);
+          expect(observation.screen).not.toContain(logs.expect);
+          expect(observation.text).not.toContain(logs.expect);
         }
-      });
+      );
       it("keeps the application alive when the channel is cut", async () => {
         const before = probe.observe();
         probe.cutChannel();