@termwright/conformance 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@termwright/conformance",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "generic/semantic/adversarial fixtures + adapter contract tests",
   "license": "MIT",
   "repository": {
@@ -10,7 +10,7 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=22"
+    "node": "^22.0.0 || ^24.0.0"
   },
   "exports": {
     ".": {
@@ -24,22 +24,24 @@
   ],
   "dependencies": {
     "@xterm/headless": "^6.0.0",
-    "@termwright/driver": "0.2.0",
-    "@termwright/protocol": "0.2.0"
+    "@termwright/protocol": "0.3.1",
+    "@termwright/resource-broker": "0.3.1",
+    "@termwright/driver": "0.3.1"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@types/react": "^19.2.18",
     "ink": "^7.1.1",
     "react": "^19.2.8",
-    "@termwright/logs": "0.2.0",
-    "@termwright/ink": "0.2.0",
-    "@termwright/probe-tview": "0.2.0",
-    "@termwright/mcp": "0.2.0",
-    "@termwright/probe-ink": "0.2.0"
+    "@termwright/ink": "0.3.1",
+    "@termwright/logs": "0.3.1",
+    "@termwright/mcp": "0.3.1",
+    "@termwright/probe-ink": "0.3.1",
+    "@termwright/probe-tview": "0.3.1",
+    "@termwright/test": "0.3.1"
   },
   "peerDependencies": {
-    "vitest": ">=3.2.0"
+    "vitest": "4.1.11"
   },
   "peerDependenciesMeta": {
     "vitest": {
@@ -47,10 +49,10 @@
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --sourcemap",
+    "build": "tsup src/index.ts --format esm --dts --sourcemap --clean",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:hostile": "vitest run --config vitest.hostile.config.ts src/suites/adversarial.test.ts src/suites/mcp-sessions.test.ts",
+    "test": "pnpm --dir ../.. test -- -- --run packages/conformance",
+    "test:hostile": "pnpm --dir ../.. test -- -- --run packages/conformance/src/suites/adversarial.test.ts packages/conformance/src/suites/mcp-sessions.test.ts",
     "conformance": "node scripts/conformance.mjs"
   }
 }

package/src/fixtures/adversarial-peer.mjs

@@ -86,16 +86,6 @@ const MAX_LOG_RECORD_BYTES = 32 * 1024;
 /** Scenarios that need the log channel negotiated in the handshake. */
 const NEEDS_LOGS = new Set(['log-seq-duplicate', 'log-seq-gap', 'log-oversized', 'log-flood']);
 
-/** Scenarios that announce `tree-diffs` and push deltas instead of whole trees. */
-const NEEDS_DELTAS = new Set([
-  'delta-sequence',
-  'delta-bad-base',
-  'delta-cursor-clear',
-  'delta-flood',
-  'delta-removed-missing',
-  'delta-before-snapshot',
-]);
-
 let logSeq = 0;
 let logBudget = null;
 
@@ -148,27 +138,62 @@ function marker(revision, forSession = sessionId, terminator = '\x07') {
 
 function tree(revision, nodes, overrides = {}) {
   return {
-    v: 1,
+    v: 2,
     sessionId,
     revision,
     columns: 80,
     rows: 24,
     rootIds: ['n1'],
     nodes,
+    coordinateSpace: {
+      status: 'known',
+      value: 'viewport-cells',
+      evidence: evidence('adversarial-peer'),
+    },
+    hitGrid: {
+      status: 'unsupported',
+      capability: 'pointer-hit-grid',
+      reason: 'framework-unobservable',
+    },
     ...overrides,
   };
 }
 
+function evidence(providerId) {
+  return { source: 'framework', method: 'native', strength: 'authoritative', providerId };
+}
+
+function geometry(rect) {
+  return {
+    displayed: { status: 'known', value: true, evidence: evidence('adversarial-peer') },
+    intendedRect: { status: 'known', value: { ...rect }, evidence: evidence('adversarial-peer') },
+    visibleRect: { status: 'known', value: { ...rect }, evidence: evidence('adversarial-peer') },
+  };
+}
+
+function unknownGeometry() {
+  return {
+    displayed: { status: 'unknown', reason: 'awaiting-revision-pair' },
+    intendedRect: { status: 'unknown', reason: 'awaiting-revision-pair' },
+    visibleRect: { status: 'unknown', reason: 'awaiting-revision-pair' },
+  };
+}
+
 function validNodes(label) {
   return [
-    { id: 'n1', role: 'region', name: 'Peer', bounds: { row: 0, column: 0, width: 20, height: 2 } },
+    {
+      id: 'n1',
+      role: 'region',
+      name: 'Peer',
+      geometry: geometry({ row: 0, column: 0, width: 20, height: 2 }),
+    },
     {
       id: 'n2',
       parentId: 'n1',
       role: 'button',
       name: label,
       testId: 'peer-button',
-      bounds: { row: 1, column: 0, width: 10, height: 1 },
+      geometry: geometry({ row: 1, column: 0, width: 10, height: 1 }),
       actions: ['activate', 'focus'],
     },
   ];
@@ -217,28 +242,34 @@ const SCENARIOS = {
   cycle: () => {
     send(
       tree(2, [
-        { id: 'n1', role: 'region', name: 'Peer' },
-        { id: 'n2', parentId: 'n3', role: 'button', name: 'A' },
-        { id: 'n3', parentId: 'n2', role: 'button', name: 'B' },
+        { id: 'n1', role: 'region', name: 'Peer', geometry: unknownGeometry() },
+        { id: 'n2', parentId: 'n3', role: 'button', name: 'A', geometry: unknownGeometry() },
+        { id: 'n3', parentId: 'n2', role: 'button', name: 'B', geometry: unknownGeometry() },
       ]),
     );
   },
   'missing-parent': () => {
     send(
       tree(2, [
-        { id: 'n1', role: 'region', name: 'Peer' },
-        { id: 'n2', parentId: 'ghost', role: 'button', name: 'Orphan' },
+        { id: 'n1', role: 'region', name: 'Peer', geometry: unknownGeometry() },
+        {
+          id: 'n2',
+          parentId: 'ghost',
+          role: 'button',
+          name: 'Orphan',
+          geometry: unknownGeometry(),
+        },
       ]),
     );
   },
-  'impossible-bounds': () => {
+  'impossible-geometry': () => {
     send(
       tree(2, [
         {
           id: 'n1',
           role: 'region',
           name: 'Peer',
-          bounds: { row: 9_000, column: 9_000, width: 5, height: 5 },
+          geometry: geometry({ row: 9_000, column: 9_000, width: 5, height: 5 }),
         },
       ]),
     );
@@ -260,18 +291,24 @@ const SCENARIOS = {
   flood: () => {
     const noise = `${'x'.repeat(4096)}\r\n`;
     for (let chunk = 0; chunk < 512; chunk += 1) process.stdout.write(noise);
+    say('PEER FLOOD OUTPUT COMPLETE');
     for (let revision = 2; revision <= 100; revision += 1) {
-      socket.write(frame({ type: 'snapshot', snapshot: tree(revision, validNodes(`Flood${revision}`)) }));
+      socket.write(
+        frame({ type: 'snapshot', snapshot: tree(revision, validNodes(`Flood${revision}`)) }),
+      );
     }
   },
   'disconnect-mid-render': () => {
-    socket.write(frame({ type: 'snapshot', snapshot: tree(2, validNodes('Torn')) }));
-    socket.destroy();
+    socket.end(frame({ type: 'snapshot', snapshot: tree(2, validNodes('Torn')) }));
   },
   'hostile-unicode': () => {
     // A lone high surrogate survives JSON.stringify as an escape, so the bytes
     // on the wire are ASCII and the receiver is the one that has to fail closed.
-    send(tree(2, [{ id: 'n1', role: 'region', name: 'lone \ud800 surrogate' }]));
+    send(
+      tree(2, [
+        { id: 'n1', role: 'region', name: 'lone \ud800 surrogate', geometry: unknownGeometry() },
+      ]),
+    );
   },
   'foreign-session': () => {
     send(tree(2, validNodes('Foreign'), { sessionId: 'someone-elses-session' }));
@@ -291,9 +328,15 @@ const SCENARIOS = {
     socket.write(frame({ type: 'snapshot', snapshot: value }));
   },
   'too-many-nodes': () => {
-    const nodes = [{ id: 'n1', role: 'region', name: 'Peer' }];
+    const nodes = [{ id: 'n1', role: 'region', name: 'Peer', geometry: unknownGeometry() }];
     for (let index = 2; index <= MAX_NODES + 1_000; index += 1) {
-      nodes.push({ id: `n${index}`, parentId: 'n1', role: 'text', name: `t${index}` });
+      nodes.push({
+        id: `n${index}`,
+        parentId: 'n1',
+        role: 'text',
+        name: `t${index}`,
+        geometry: unknownGeometry(),
+      });
     }
     send(tree(2, nodes));
   },
@@ -345,32 +388,6 @@ const SCENARIOS = {
     // Far past any sane per-second budget, sent in one turn.
     for (let seq = 1; seq <= 500; seq += 1) sendLog(seq, `flood ${seq}`);
   },
-  'delta-sequence': () => {
-    sendDelta(renameDelta(1, 2, 'Second'));
-    sendDelta(renameDelta(2, 3, 'Third'));
-    sendDelta(renameDelta(3, 4, 'Fourth'));
-  },
-  'delta-bad-base': () => {
-    // Base 999 was never held, so this cannot be patched onto anything.
-    sendDelta(renameDelta(999, 1000, 'Impossible'));
-  },
-  'delta-cursor-clear': () => {
-    // A delta can set a cursor but never clear it. `c` sends the full tree that
-    // clears it, so the two halves are separate steps rather than a race.
-    sendDelta(renameDelta(1, 2, 'Cursor', { cursor: { row: 3, column: 7, visible: true } }));
-  },
-  'delta-flood': () => {
-    for (let revision = 2; revision <= 200; revision += 1) {
-      sendDelta(renameDelta(revision - 1, revision, `Rev${revision}`));
-    }
-  },
-  'delta-removed-missing': () => {
-    sendDelta({ baseRevision: 1, revision: 2, changed: [], removed: ['ghost'] });
-  },
-  'delta-before-snapshot': () => {
-    // Handled specially at handshake time: nothing was published first.
-    sendDelta(renameDelta(1, 2, 'Premature'));
-  },
   'marker-st-terminator': () => {
     // ST rather than BEL. The tree must pair exactly as it does with BEL.
     socket.write(frame({ type: 'snapshot', snapshot: tree(2, validNodes('Terminated')) }));
@@ -390,14 +407,13 @@ const SCENARIOS = {
 };
 
 function hello(overrides = {}) {
-  const capabilities = ['tree', 'bounds', 'states', 'actions', 'render-revisions'];
+  const capabilities = ['tree', 'states', 'actions', 'render-revisions'];
   // `log-no-negotiation` deliberately does NOT announce it: the point of that
   // scenario is sending records the driver never invited.
   if (NEEDS_LOGS.has(scenario)) capabilities.push('logs');
-  if (NEEDS_DELTAS.has(scenario)) capabilities.push('tree-diffs');
   return {
     type: 'hello',
-    protocol: 'termwright/1',
+    protocol: 'termwright/2',
     token,
     adapter: { name: 'adversarial-peer', version: '0.1.0' },
     capabilities,
@@ -415,41 +431,7 @@ function sendLog(seq, message) {
   logSeq = Math.max(logSeq, seq);
 }
 
-/**
- * Sends a delta and its marker. The peer keeps no model of its own beyond the
- * revision counter: composing is the receiver's job, and a producer that also
- * composed would only prove it agrees with itself.
- */
-function sendDelta(delta) {
-  // The delta is the message: the body sits beside the discriminator rather
-  // than nested under it.
-  socket.write(frame({ type: 'tree-delta', ...delta }));
-  process.stdout.write(REPAINT + marker(delta.revision));
-  published = Math.max(published, delta.revision);
-}
-
-/** A delta that renames the button, so a composed tree is observable on screen. */
-function renameDelta(baseRevision, revision, label, overrides = {}) {
-  return {
-    baseRevision,
-    revision,
-    changed: [
-      {
-        id: 'n2',
-        parentId: 'n1',
-        role: 'button',
-        name: label,
-        testId: 'peer-button',
-        bounds: { row: 1, column: 0, width: 10, height: 1 },
-        actions: ['activate', 'focus'],
-      },
-    ],
-    removed: [],
-    ...overrides,
-  };
-}
-
-/** Sends a snapshot together with its marker, so only the tree can be at fault. */
+/** Sends a deliberately chosen snapshot together with its marker. */
 function send(snapshot) {
   socket.write(frame({ type: 'snapshot', snapshot }));
   process.stdout.write(marker(snapshot.revision));
@@ -467,8 +449,6 @@ function fire() {
     attack();
     say('PEER FIRED');
   } catch (error) {
-    // A peer that cannot even build its attack must say so rather than die
-    // silently and leave the suite waiting on a timeout.
     say(`PEER FAILED ${String(error && error.message ? error.message : error)}`);
   }
 }
@@ -483,9 +463,6 @@ process.stdin.on('data', (chunk) => {
   }
   if (text.includes('g')) fire();
   if (text.includes('p')) publish(published + 1, `Manual${published + 1}`);
-  // The cursor-clearing half of `delta-cursor-clear`: only a full tree can do
-  // it, and `tree()` builds one without a cursor.
-  if (text.includes('c')) publish(published + 1, 'NoCursor');
 });
 
 say(`PEER START ${scenario}`);
@@ -540,26 +517,11 @@ if (endpoint === undefined || token === undefined) {
       if (message.type === 'hello-ack') {
         sessionId = message.sessionId;
         logBudget = message.logs ?? null;
-        say(`PEER LOGS ${logBudget === null ? 'denied' : `enabled ${logBudget.maxRecordsPerSecond}/s`}`);
-        // `delta-before-snapshot` deliberately skips the opening tree: its
-        // whole point is a delta with nothing to compose onto.
-        if (scenario !== 'delta-before-snapshot') publish(1);
-        say(`PEER READY ${scenario}`);
-      }
-      if (message.type === 'get-tree') {
-        // Answering is what makes a resync observable end to end: the driver
-        // asks, the peer supplies, the session returns to a known tree.
-        const revision = published + 1;
-        socket.write(
-          frame({
-            type: 'get-tree-result',
-            requestId: message.requestId,
-            snapshot: tree(revision, validNodes('Resynced')),
-          }),
+        say(
+          `PEER LOGS ${logBudget === null ? 'denied' : `enabled ${logBudget.maxRecordsPerSecond}/s`}`,
         );
-        published = revision;
-        process.stdout.write(marker(revision));
-        say(`PEER SENT FULL TREE ${revision}`);
+        publish(1);
+        say(`PEER READY ${scenario}`);
       }
       if (message.type === 'error') say(`PEER GOT ERROR ${message.code}`);
     }

package/src/fixtures/generic-app.mjs

@@ -65,7 +65,9 @@ function draw() {
     out(index === selected ? `\x1b[1;32m> ${item}\x1b[0m\r\n` : `  ${item}\r\n`);
   }
   out('\x1b[31mRED\x1b[0m \x1b[4mUNDER\x1b[0m \x1b[44mONBLUE\x1b[0m\r\n');
-  out(`modes: mouse=${mouse} paste=${bracketed ? 'on' : 'off'} focus=${focusReporting ? 'on' : 'off'}`);
+  out(
+    `modes: mouse=${mouse} paste=${bracketed ? 'on' : 'off'} focus=${focusReporting ? 'on' : 'off'}`,
+  );
   out(` alt=${alternate ? 'on' : 'off'}\r\n`);
   out(`size: ${process.stdout.columns}x${process.stdout.rows}\r\n`);
   out(`activated: ${activated}\r\n`);
@@ -88,7 +90,8 @@ function draw() {
     .map((name) => `${name}=${process.env[name] === undefined ? 'no' : 'yes'}`)
     .join(' ');
   out(`allow: ${allow}\r\n`);
-  if (unicode) out('U: \u{1F600} \u{1F469}\u200D\u{1F469}\u200D\u{1F467} e\u0301 \u65E5\u672C\u8A9E ok\r\n');
+  if (unicode)
+    out('U: \u{1F600} \u{1F469}\u200D\u{1F469}\u200D\u{1F467} e\u0301 \u65E5\u672C\u8A9E ok\r\n');
   if (wide) out(`W: ${'0123456789'.repeat(12)} END\r\n`);
 }
 

package/src/fixtures/ink-probe-app.mjs

@@ -1,23 +1,23 @@
 /** Small normal-render Ink process used only by cross-package readiness tests. */
 
-import {createElement, useEffect, useRef} from 'react';
-import {Box, Text, render, useApp} from 'ink';
-import {useSemantic} from '@termwright/ink';
+import { createElement, useEffect, useRef } from 'react';
+import { Box, Text, render, useApp } from 'ink';
+import { useSemantic } from '@termwright/ink';
 
 function App() {
-  const {exit} = useApp();
+  const { exit } = useApp();
   const status = useRef(null);
-  useSemantic(status, {role: 'status', name: 'Ready', testId: 'status'});
+  useSemantic(status, { role: 'status', name: 'Ready', testId: 'status' });
   useEffect(() => {
     const timer = setTimeout(exit, 2_000);
     return () => clearTimeout(timer);
   }, [exit]);
   return createElement(
     Box,
-    {ref: status, flexDirection: 'column'},
+    { ref: status, flexDirection: 'column' },
     createElement(Text, null, 'Termwright Conformance'),
   );
 }
 
-const app = render(createElement(App), {alternateScreen: true, interactive: true});
+const app = render(createElement(App), { alternateScreen: true, interactive: true });
 await app.waitUntilExit();