@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/__tests__/fixtures/fake-pi-host.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/core/__tests__/fixtures/fake-pi-host.js

@@ -1,311 +0,0 @@
-#!/usr/bin/env node
-// fake-pi-host.ts — a deterministic stand-in for the pi LLM vehicle.
-//
-// This is NOT an LLM and NOT a mock of the extensions. It is the real pi
-// vehicle's place in the system, occupied by a tiny event driver that loads the
-// REAL canvas extensions (the `-e <path>` modules the runtime put in our argv)
-// and fires REAL lifecycle events under harness control, so the real hooks
-// drive real canvas state across the process boundary.
-//
-// The runtime execs us exactly where it would exec `pi`, via the CRTR_PI_BINARY
-// seam in piCommand (src/core/runtime/tmux-driver.ts). We therefore receive:
-//   • argv:  -e <ext> … -n <label> [--session <path>] [--model …] [--tools …]
-//            [--append-system-prompt <file>] [<kickoff prompt>]   (buildPiArgv)
-//   • env:   CRTR_NODE_ID, CRTR_KIND, CRTR_MODE, CRTR_LIFECYCLE, CRTR_HOME,
-//            CRTR_PARENT_NODE_ID, CRTR_ROOT_SESSION, CRTR_FRONT_DOOR  (tmux -e)
-//
-// Run under tsx (so the `-e` paths resolve to the same .ts modules the CLI
-// referenced when launched via `node --import tsx/esm src/cli.ts`).
-//
-// Control channel (one-way, polled file under the node dir):
-//   <CRTR_HOME>/nodes/<id>/fake-pi.cmd   — harness writes one JSON command
-//   <CRTR_HOME>/nodes/<id>/fake-pi.ack   — host appends an ack per command
-// Proof / observability the harness reads:
-//   <CRTR_HOME>/nodes/<id>/fake-pi.boot.json     — argv + env + loaded exts (latest boot)
-//   <CRTR_HOME>/nodes/<id>/fake-pi.boots.jsonl    — append-only, one line per boot
-//   <CRTR_HOME>/nodes/<id>/fake-pi.events.jsonl   — append-only, one line per fired event
-//   <CRTR_HOME>/nodes/<id>/fake-pi.injected.jsonl — every sendUserMessage
-//   <CRTR_HOME>/nodes/<id>/fake-pi.error          — any boot/import failure
-import { writeFileSync, readFileSync, existsSync, mkdirSync, appendFileSync, unlinkSync, } from 'node:fs';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-const env = process.env;
-const nodeId = (env['CRTR_NODE_ID'] ?? '').trim();
-const home = (env['CRTR_HOME'] ?? '').trim();
-const rawArgv = process.argv.slice(2); // everything after `node host.ts`
-function recordError(msg) {
-    try {
-        if (home && nodeId) {
-            const dir = join(home, 'nodes', nodeId);
-            mkdirSync(dir, { recursive: true });
-            appendFileSync(join(dir, 'fake-pi.error'), msg + '\n');
-        }
-    }
-    catch {
-        /* best effort */
-    }
-    try {
-        process.stderr.write('[fake-pi] ' + msg + '\n');
-    }
-    catch {
-        /* ignore */
-    }
-}
-function fail(msg) {
-    recordError(msg);
-    process.exit(17);
-}
-if (nodeId === '')
-    fail('CRTR_NODE_ID missing in env');
-if (home === '')
-    fail('CRTR_HOME missing in env');
-const nodeDir = join(home, 'nodes', nodeId);
-mkdirSync(nodeDir, { recursive: true });
-// parse the argv the runtime built (buildPiArgv → piCommand)
-const extPaths = [];
-let sessionArg;
-let label;
-let prompt;
-for (let i = 0; i < rawArgv.length; i++) {
-    const a = rawArgv[i];
-    if (a === '-e')
-        extPaths.push(rawArgv[++i]);
-    else if (a === '-n')
-        label = rawArgv[++i];
-    else if (a === '--session')
-        sessionArg = rawArgv[++i];
-    else if (a === '--model' || a === '--tools' || a === '--append-system-prompt' || a === '--fork')
-        i++;
-    else if (!a.startsWith('-'))
-        prompt = a; // positional kickoff (fresh start only)
-}
-const resuming = sessionArg !== undefined;
-const sessionId = sessionArg ?? `fake-sess-${nodeId}-${Date.now()}`;
-const sessionFile = join(nodeDir, 'fake-session.jsonl');
-if (!existsSync(sessionFile))
-    writeFileSync(sessionFile, '');
-const handlers = {};
-let shutdownRequested = false;
-let streaming = false;
-const injected = [];
-function recordInjected(rec) {
-    injected.push(rec);
-    try {
-        appendFileSync(join(nodeDir, 'fake-pi.injected.jsonl'), JSON.stringify({ ...rec, ts: Date.now() }) + '\n');
-    }
-    catch {
-        /* best effort */
-    }
-}
-// The faithful pi vehicle surface — the union of every method the 7 canvas
-// extensions call at register time. `on` + `sendUserMessage` carry the
-// lifecycle behavior under test; the rest are recording stubs so the chrome
-// extensions (context-intro renderer, commands/nav slash-commands, goal-capture
-// session name) register without throwing, exactly as they would against real pi.
-const pi = {
-    on(event, h) {
-        (handlers[event] ??= []).push(h);
-    },
-    sendUserMessage(content, options) {
-        recordInjected({ content, deliverAs: options?.deliverAs });
-    },
-    sendMessage(message, options) {
-        recordInjected({ content: JSON.stringify(message), deliverAs: options?.deliverAs });
-    },
-    registerMessageRenderer(_customType, _renderer) {
-        /* spike: no-op recording stub */
-    },
-    registerCommand(_name, _options) {
-        /* spike: no-op recording stub */
-    },
-    registerShortcut(_shortcut, _options) {
-        /* spike: no-op recording stub */
-    },
-    setSessionName(_name) {
-        /* spike: no-op recording stub */
-    },
-};
-let eventSeq = 0;
-// Append a durable record of every fired event BEFORE its handlers run. This is
-// the harness's robust "the host received my command and is dispatching it"
-// signal — it survives even when a handler tears the process down mid-flight
-// (e.g. agent_end on a refresh/done node drives the broker shutdown), which is
-// exactly the case where an after-the-fact ack would be lost.
-function recordEvent(event, ev) {
-    try {
-        const reason = ev?.reason;
-        appendFileSync(join(nodeDir, 'fake-pi.events.jsonl'), JSON.stringify({ seq: ++eventSeq, event, reason: reason ?? null, ts: Date.now() }) + '\n');
-    }
-    catch {
-        /* best effort */
-    }
-}
-async function fire(event, ev, ctx) {
-    recordEvent(event, ev);
-    for (const h of handlers[event] ?? []) {
-        try {
-            await h(ev, ctx);
-        }
-        catch (e) {
-            recordError(`handler ${event} threw: ${String(e)}`);
-        }
-    }
-}
-// The minimum fake-ctx shape (union across both focus extensions), all
-// dereferenced defensively by the hooks (ctx?.x?.()).
-const ctx = {
-    sessionManager: {
-        getSessionId: () => sessionId,
-        getSessionFile: () => sessionFile,
-    },
-    getContextUsage: () => ({ tokens: 1000 }),
-    shutdown: () => {
-        shutdownRequested = true;
-    },
-    isIdle: () => !streaming,
-    abort: () => {
-        /* spike: no-op */
-    },
-};
-// load the REAL extension modules from the -e paths
-const loaded = [];
-const failedExt = [];
-for (const p of extPaths) {
-    try {
-        const mod = await import(pathToFileURL(p).href);
-        const reg = (mod['default'] ?? mod['register']);
-        if (typeof reg === 'function') {
-            reg(pi);
-            loaded.push(p);
-        }
-        else {
-            failedExt.push(`${p} (no default export fn)`);
-        }
-    }
-    catch (e) {
-        failedExt.push(`${p} :: ${String(e)}`);
-        recordError(`import ${p} failed: ${String(e)}`);
-    }
-}
-// session_start: the real boot-confirm hook captures session id + pid
-await fire('session_start', { reason: resuming ? 'resume' : 'startup' }, ctx);
-// the boot proof the harness asserts on
-const boot = {
-    pid: process.pid,
-    nodeId,
-    home,
-    rawArgv,
-    extPaths,
-    loaded,
-    failedExt,
-    sessionId,
-    sessionFile,
-    resuming,
-    label: label ?? null,
-    prompt: prompt ?? null,
-    env: {
-        CRTR_NODE_ID: env['CRTR_NODE_ID'] ?? null,
-        CRTR_KIND: env['CRTR_KIND'] ?? null,
-        CRTR_MODE: env['CRTR_MODE'] ?? null,
-        CRTR_LIFECYCLE: env['CRTR_LIFECYCLE'] ?? null,
-        CRTR_NODE_CWD: env['CRTR_NODE_CWD'] ?? null,
-        CRTR_HOME: env['CRTR_HOME'] ?? null,
-        CRTR_PARENT_NODE_ID: env['CRTR_PARENT_NODE_ID'] ?? null,
-        CRTR_ROOT_SESSION: env['CRTR_ROOT_SESSION'] ?? null,
-        CRTR_SUBTREE: env['CRTR_SUBTREE'] ?? null,
-        CRTR_FRONT_DOOR: env['CRTR_FRONT_DOOR'] ?? null,
-    },
-    injectedDuringBoot: injected.slice(),
-};
-writeFileSync(join(nodeDir, 'fake-pi.boot.json'), JSON.stringify(boot, null, 2));
-// Append-only boot log so the harness can count re-boots (a resume after an
-// idle-release wake, or a fresh pi after a refresh-yield).
-try {
-    appendFileSync(join(nodeDir, 'fake-pi.boots.jsonl'), JSON.stringify(boot) + '\n');
-}
-catch {
-    /* best effort */
-}
-// control loop: poll for one harness command at a time
-const cmdFile = join(nodeDir, 'fake-pi.cmd');
-const ackFile = join(nodeDir, 'fake-pi.ack');
-function ack(id, body) {
-    try {
-        appendFileSync(ackFile, JSON.stringify({ id, ...body, ts: Date.now() }) + '\n');
-    }
-    catch {
-        /* best effort */
-    }
-}
-async function doShutdown() {
-    // A clean pi /quit. The stophook's session_shutdown handler resolves a still-
-    // active node to done (markCleanExitDone → finalize). Mirrors real pi exiting.
-    await fire('session_shutdown', { reason: 'quit' }, ctx);
-    ack('shutdown', { ok: true });
-    clearInterval(timer);
-    process.exit(0);
-}
-async function dispatch(cmd) {
-    const id = cmd.id ?? cmd.cmd ?? 'cmd';
-    switch (cmd.cmd) {
-        case 'shutdown':
-            await doShutdown();
-            break;
-        case 'stop':
-            streaming = false;
-            await fire('agent_end', {
-                messages: [
-                    {
-                        role: 'assistant',
-                        stopReason: cmd.reason ?? 'stop',
-                        // A real engine attaches errorMessage on a stopReason:'error' turn;
-                        // the stophook classifies it (connection/rate-limit/…) for the
-                        // active-fault marker. Forward it so a test can drive a CONNECTION
-                        // stall faithfully.
-                        ...(cmd.errorMessage === undefined ? {} : { errorMessage: cmd.errorMessage }),
-                        content: [{ type: 'text', text: cmd.text ?? '' }],
-                    },
-                ],
-            }, ctx);
-            ack(id, { ok: true });
-            break;
-        case 'turn':
-            streaming = true;
-            await fire('agent_start', {}, ctx);
-            streaming = false;
-            await fire('turn_end', { message: { role: 'assistant', usage: { input: 10, output: 5 }, model: 'fake' } }, ctx);
-            await fire('agent_end', { messages: [{ role: 'assistant', stopReason: 'stop', content: [{ type: 'text', text: cmd.text ?? '' }] }] }, ctx);
-            ack(id, { ok: true });
-            break;
-        default:
-            ack(id, { ok: false, error: `unknown cmd: ${String(cmd.cmd)}` });
-    }
-}
-async function step() {
-    if (shutdownRequested) {
-        await doShutdown();
-        return;
-    }
-    if (!existsSync(cmdFile))
-        return;
-    let cmd = null;
-    try {
-        cmd = JSON.parse(readFileSync(cmdFile, 'utf8'));
-    }
-    catch {
-        cmd = null;
-    }
-    try {
-        unlinkSync(cmdFile);
-    }
-    catch {
-        /* ignore */
-    }
-    if (cmd)
-        await dispatch(cmd);
-    if (shutdownRequested)
-        await doShutdown();
-}
-const timer = setInterval(() => {
-    void step().catch((e) => recordError(`step: ${String(e)}`));
-}, 100);

package/dist/core/__tests__/fixtures/memory-slash-live-probe.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/fixtures/memory-slash-live-probe.js

@@ -1,75 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { DefaultResourceLoader, ExtensionRunner, } from '@earendil-works/pi-coding-agent';
-import { buildRefInventory } from '../../memory/inline-ref-inventory.js';
-import { gatewayCommandRows, gatewayMemoryRows } from '../../runtime/chat-inventory-rows.js';
-import { captureChatCapabilities, registrationChatSurface } from '../../runtime/command-surface.js';
-import { runProspectiveInventory } from '../../runtime/prospective-inventory.js';
-async function main() {
-    const extensionPath = process.argv[2];
-    const invocations = JSON.parse(process.argv[3] ?? '[]');
-    if (extensionPath === undefined)
-        throw new Error('extension path is required');
-    const cwd = process.cwd();
-    const home = process.env['CRTR_HOME'];
-    if (home === undefined || home === '')
-        throw new Error('CRTR_HOME is required');
-    const stateBeforeProspective = existsSync(home);
-    const prospective = await runProspectiveInventory({ cwd, profileId: null, extensions: [extensionPath] });
-    const stateAfterProspective = existsSync(home);
-    const nodeId = process.env['CRTR_NODE_ID'];
-    if (nodeId === undefined || nodeId === '')
-        throw new Error('CRTR_NODE_ID is required');
-    mkdirSync(join(home, 'nodes', nodeId), { recursive: true });
-    const loader = new DefaultResourceLoader({
-        cwd,
-        agentDir: join(cwd, '.pi'),
-        additionalExtensionPaths: [extensionPath],
-        noContextFiles: true,
-    });
-    await loader.reload();
-    const loaded = loader.getExtensions();
-    if (loaded.errors.length > 0)
-        throw new Error(JSON.stringify(loaded.errors));
-    const sent = [];
-    let activeName = '';
-    loaded.runtime.sendMessage = (message, options) => sent.push({ name: activeName, message, options });
-    const runner = new ExtensionRunner(loaded.extensions, loaded.runtime, cwd, undefined, undefined);
-    const registered = runner.getRegisteredCommands();
-    captureChatCapabilities({ commands: registered, templates: [] });
-    const commands = gatewayCommandRows(registered.map((command) => {
-        const expansion = command.expansion;
-        return {
-            name: command.invocationName,
-            description: command.description ?? '',
-            source: 'command',
-            ...(expansion === undefined ? {} : { expansion }),
-            ...registrationChatSurface(command),
-        };
-    }));
-    const memoryRefs = gatewayMemoryRows(buildRefInventory().refs);
-    const notifications = [];
-    for (const invocation of invocations) {
-        const command = runner.getCommand(invocation.name);
-        if (command === undefined)
-            throw new Error(`command not registered: ${invocation.name}`);
-        activeName = invocation.name;
-        await command.handler(invocation.args, {
-            cwd,
-            ui: { notify: (...args) => notifications.push(args) },
-        });
-    }
-    writeFileSync(3, JSON.stringify({
-        prospective,
-        stateBeforeProspective,
-        stateAfterProspective,
-        commands,
-        memoryRefs,
-        sent,
-        notifications,
-    }));
-}
-main().catch((error) => {
-    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
-    process.exitCode = 1;
-});

package/dist/core/__tests__/fixtures/metadata-migration-race.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/fixtures/metadata-migration-race.js

@@ -1,49 +0,0 @@
-// Controlled helper for migration-vs-update concurrency tests.
-//
-// This fixture intentionally holds the node-meta lock, captures a "legacy" metadata
-// snapshot, and only applies legacy-prefix normalization after the parent test signals
-// with a go-file. It proves that updateNode must not read/merge metadata outside the
-// same lock used for migration writes.
-import { mkdirSync, readFileSync, rmSync, renameSync, writeFileSync } from 'node:fs';
-import { customExtensionPaths } from '../../canvas/extensions.js';
-const [, , metaPath, readyPath] = process.argv;
-if (metaPath === undefined || readyPath === undefined) {
-    process.stderr.write('[migration-race] expected args: <metaPath> <readyPath>\n');
-    process.exit(1);
-}
-const lock = `${metaPath}.lock`;
-const waitFor = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-(async () => {
-    mkdirSync(lock, { recursive: true });
-    const raw = readFileSync(metaPath, 'utf8');
-    const meta = JSON.parse(raw);
-    const launch = meta.launch;
-    const extensions = Array.isArray(launch?.extensions)
-        ? launch.extensions
-        : [];
-    const normalized = {
-        ...meta,
-        launch: {
-            ...launch,
-            extensions: customExtensionPaths(extensions),
-        },
-    };
-    writeFileSync(readyPath, 'ready');
-    // Give the concurrent updateNode caller time to reach the lock. An old
-    // read-outside-lock implementation would have captured stale metadata by now.
-    await waitFor(100);
-    const tmp = `${metaPath}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(normalized, null, 2));
-    renameSync(tmp, metaPath);
-    rmSync(lock, { force: true, recursive: true });
-    process.exit(0);
-})().catch((error) => {
-    try {
-        rmSync(lock, { force: true, recursive: true });
-    }
-    catch {
-        /* best effort */
-    }
-    process.stderr.write(`[migration-race] ${String(error.message)}\n`);
-    process.exit(1);
-});

package/dist/core/__tests__/focuses.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/focuses.test.js

@@ -1,113 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/focuses.test.ts
-//
-// The `focuses` table (canvas.db, migration v6) + its canvas setters + the
-// placement reads that compose over them. The table is the CANONICAL focus store
-// — there is no focus.ptr file and no dual-write bridge. Covers:
-//   - migration v6 adds `focuses` to a fresh db
-//   - canvas setters/reads round-trip: open / setOccupant / setPane / close;
-//     getFocusByNode / getFocusByPane / getFocusById / listFocuses
-//   - independent focus rows don't contend
-//   - placement focusOf / isFocused / focusByPane / focusedNodes / listFocuses
-//     GC dead-pane viewer rows on read (liveOrPrune), and pass null-pane rows
-//     through (broker-host cut: placement reads self-heal the viewer registry)
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { openFocusRow, setFocusOccupant, setFocusPane, closeFocusRow, getFocusByNode, getFocusByPane, getFocusById, listFocuses, } from '../canvas/focuses.js';
-import { openDb, closeDb, migrate, MIGRATIONS } from '../canvas/db.js';
-import { focusOf, isFocused, focusByPane, focusedNodes, listFocuses as placementListFocuses, } from '../runtime/placement.js';
-let home;
-function userVersion(db) {
-    return db.prepare('PRAGMA user_version').get().user_version;
-}
-function tableNames(db) {
-    return db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((r) => r.name);
-}
-function freshDb() {
-    const db = openDb();
-    migrate(db);
-    return db;
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-focuses-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-// Migration v6 — the additive `focuses` table.
-test('a fresh db migrates to the latest version and has the focuses table', () => {
-    const db = freshDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    assert.ok(tableNames(db).includes('focuses'), 'focuses table exists on a fresh db');
-});
-// Canvas setters / reads — open / setOccupant / setPane / close round-trip.
-test('open / setOccupant / close round-trip with the reads', () => {
-    freshDb();
-    openFocusRow('f1', '%a', 'Sa', 'A');
-    // getFocusByNode / getFocusByPane / getFocusById all resolve the same row.
-    const byNode = getFocusByNode('A');
-    assert.deepEqual(byNode, { focus_id: 'f1', pane: '%a', session: 'Sa', node_id: 'A' });
-    assert.deepEqual(getFocusByPane('%a'), byNode);
-    assert.deepEqual(getFocusById('f1'), byNode);
-    assert.deepEqual(listFocuses(), [byNode]);
-    // setFocusOccupant hot-swaps the occupant in place (same focus_id/pane).
-    setFocusOccupant('f1', 'B');
-    assert.equal(getFocusByNode('A'), null, 'A no longer occupies the focus');
-    assert.deepEqual(getFocusByNode('B'), { focus_id: 'f1', pane: '%a', session: 'Sa', node_id: 'B' });
-    // setFocusPane re-points the pane + session cache after a viewer move.
-    setFocusPane('f1', '%a2', 'Sa2');
-    assert.deepEqual(getFocusById('f1'), { focus_id: 'f1', pane: '%a2', session: 'Sa2', node_id: 'B' });
-    assert.equal(getFocusByPane('%a'), null, 'the old pane no longer resolves');
-    assert.deepEqual(getFocusByPane('%a2')?.node_id, 'B');
-    // closeFocusRow deletes the viewport.
-    closeFocusRow('f1');
-    assert.equal(getFocusByNode('B'), null);
-    assert.equal(getFocusById('f1'), null);
-    assert.deepEqual(listFocuses(), []);
-});
-test('independent focus rows do not contend', () => {
-    freshDb();
-    openFocusRow('f1', '%a', 'Sa', 'A');
-    openFocusRow('f2', '%b', 'Sb', 'B');
-    // Mutating one viewport leaves the other entirely intact.
-    setFocusOccupant('f1', 'C');
-    setFocusPane('f1', '%a2', 'Sa2');
-    assert.deepEqual(getFocusByNode('B'), { focus_id: 'f2', pane: '%b', session: 'Sb', node_id: 'B' });
-    closeFocusRow('f1');
-    assert.deepEqual(getFocusByNode('B'), { focus_id: 'f2', pane: '%b', session: 'Sb', node_id: 'B' });
-    assert.deepEqual(listFocuses().map((f) => f.focus_id), ['f2']);
-});
-// Placement reads — focusOf / isFocused / focusByPane / focusedNodes /
-// listFocuses GC dead-pane viewer rows on read (broker-host cut: liveOrPrune).
-// A row whose viewer pane no longer exists is pruned the next time it is read,
-// so the registry self-heals without a sweeper; a row with a null pane (a
-// registered-but-not-yet-realized viewer) is passed through. A live tmux pane
-// can't be fabricated in the ordinary suite, so we cover the prune + null-pane paths
-// here; the live-pane read is covered in the compiled-seam broker lifecycle suite.
-test('placement reads GC dead-pane viewer rows and keep null-pane rows', () => {
-    freshDb();
-    openFocusRow('f1', '%a', 'Sa', 'A'); // %a is not a live tmux pane → pruned on read
-    openFocusRow('f2', null, 'Sb', 'B'); // null pane (not realized yet) → kept
-    // The dead-pane row is GC'd on read: placement returns null AND the row is
-    // removed from the canvas table (self-healing registry).
-    assert.equal(focusOf('A'), null, 'a viewer whose pane is gone is pruned on read');
-    assert.equal(getFocusByNode('A'), null, 'the pruned row is closed in the db');
-    assert.equal(isFocused('A'), false);
-    assert.equal(focusByPane('%a'), null, 'focusByPane prunes the dead pane too');
-    // The null-pane row survives (liveOrPrune only prunes a non-null dead pane).
-    assert.deepEqual(focusOf('B'), { focus_id: 'f2', pane: null, session: 'Sb', node_id: 'B' });
-    assert.equal(isFocused('B'), true);
-    assert.equal(focusOf('Z'), null, 'an unfocused node has no focus');
-    assert.equal(isFocused('Z'), false);
-    assert.deepEqual(focusedNodes(), new Set(['B']));
-    assert.deepEqual(placementListFocuses().map((f) => f.node_id), ['B']);
-});

package/dist/core/__tests__/fs-utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/__tests__/fs-utils.test.js

@@ -1,50 +0,0 @@
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { atomicWriteJson, atomicWriteText, readJson } from '../fs-utils.js';
-let dir;
-before(() => {
-    dir = mkdtempSync(join(tmpdir(), 'crtr-fs-utils-'));
-});
-after(() => {
-    rmSync(dir, { recursive: true, force: true });
-});
-test('atomicWriteText defaults a new file to 0o600', () => {
-    const path = join(dir, 'new-file.txt');
-    atomicWriteText(path, 'hello');
-    const mode = statSync(path).mode & 0o777;
-    assert.equal(mode, 0o600);
-});
-test('atomicWriteText preserves an existing file\'s mode on rewrite', () => {
-    const path = join(dir, 'existing-file.txt');
-    writeFileSync(path, 'first', { mode: 0o640 });
-    atomicWriteText(path, 'second');
-    const mode = statSync(path).mode & 0o777;
-    assert.equal(mode, 0o640);
-});
-test('atomicWriteText opts.mode forces a mode regardless of the existing file', () => {
-    const path = join(dir, 'forced-mode.txt');
-    writeFileSync(path, 'first', { mode: 0o640 });
-    atomicWriteText(path, 'second', { mode: 0o600 });
-    const mode = statSync(path).mode & 0o777;
-    assert.equal(mode, 0o600);
-});
-test('atomicWriteJson round-trips data and leaves no temp file after success', () => {
-    const path = join(dir, 'data.json');
-    atomicWriteJson(path, { hello: 'world' });
-    assert.deepEqual(readJson(path), { hello: 'world' });
-    const leftovers = readdirSync(dir).filter((name) => name.includes('.tmp'));
-    assert.deepEqual(leftovers, []);
-});
-test('atomicWriteText leaves no temp file behind after a forced rename failure', () => {
-    // Target an existing directory as the write path so ensureDir succeeds, the
-    // temp file is actually created, and only the rename step fails (EISDIR),
-    // exercising the finally-block cleanup path.
-    const path = join(dir, 'a-directory');
-    mkdirSync(path);
-    assert.throws(() => atomicWriteText(path, 'nope'));
-    const leftovers = readdirSync(dir).filter((name) => name.includes('.tmp'));
-    assert.deepEqual(leftovers, []);
-});

package/dist/core/__tests__/helpers/broker-clients.d.ts

@@ -1,43 +0,0 @@
-import { type Socket } from 'node:net';
-import type { Harness } from './harness.js';
-import { BrokerClient } from '../../broker-client/index.js';
-import { type BrokerToClient, type ClientToBroker, type ClientRole, type WelcomeFrame } from '../../runtime/broker-protocol.js';
-export declare const delay: (ms: number) => Promise<void>;
-export declare const tok: (s: string) => string;
-export declare const frameHas: (f: BrokerToClient, token: string) => boolean;
-export declare function brokerLogText(h: Harness, id: string): string;
-export interface Attached {
-    client: BrokerClient;
-    frames: BrokerToClient[];
-    welcome: WelcomeFrame;
-    send(frame: ClientToBroker): void;
-    waitFrame(pred: (f: BrokerToClient) => boolean, label: string, timeoutMs?: number): Promise<BrokerToClient>;
-    close(): void;
-}
-export interface RawClient {
-    socket: Socket;
-    frames: BrokerToClient[];
-    closed: () => boolean;
-    send(frame: ClientToBroker): void;
-    writeRaw(data: Buffer | string): void;
-    waitClosed(label: string, timeoutMs?: number): Promise<void>;
-    close(): void;
-}
-export interface AttachKit {
-    /** Connect a BrokerClient to a node's running broker, hello, await welcome. */
-    attach(id: string, role: ClientRole, clientId: string, opts?: {
-        snapshotTail?: number;
-        attends?: boolean;
-    }): Promise<Attached>;
-    /** Attach (as `role`) and retry until the welcome satisfies `pred`. */
-    attachUntil(id: string, role: ClientRole, clientId: string, pred: (a: Attached) => boolean, label: string): Promise<Attached>;
-    /** A raw node:net peer. read:false leaves the socket PAUSED (G8 stalled viewer). */
-    connectRaw(id: string, opts: {
-        read: boolean;
-    }): Promise<RawClient>;
-    /** Close every client opened since the last closeAll — wire into afterEach. */
-    closeAll(): void;
-}
-/** Build the attach kit against a lazily-resolved harness (the harness is
- *  created in the file's before() hook, after the kit is constructed). */
-export declare function createAttachKit(getH: () => Harness): AttachKit;