@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/canvas/__tests__/render-remote.test.js

@@ -1,243 +0,0 @@
-// render-remote.test.ts — the safe-defaults contract for `render.ts`'s
-// `*FromSource` functions when given a `RemoteCanvasSource`: every field that
-// would require a local disk/SQLite read (viewed, ctx tokens, asks, goal,
-// prompts, lastAssistant) must come back suppressed to its safe default
-// instead of touching this process's local state. `hanging`/`streaming` are
-// not suppressed — they are projected by the REMOTE daemon and arrive on the
-// row, so the contract for them is that the row carries the remote fault and
-// never the local one. Reuses the mock-server harness shape from
-// `remote-canvas-source.test.ts`.
-//
-// This is adversarial, not merely a clean-machine assertion: BEFORE calling
-// the render functions, the test seeds real, CONFLICTING local state for the
-// same node id `a` (a local focus, an active fault, telemetry, a goal file, a
-// session transcript, and a pending human reply) — every historically-broken
-// local read this suppression covers. If the production suppression ever
-// regressed back to consulting local disk/SQLite for a remote source, the
-// assertions below would observe the poisoned values instead of the safe
-// defaults, so a clean-machine run could never mask the regression.
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { createServer } from 'node:http';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { atomicWriteJson, pageManifestPath } from '#core/human/convention';
-import { RemoteCanvasSource } from '../remote-canvas-source.js';
-import { dashboardRowsAllFromSource, enrichRowsFromSource, loadPreviewFromSource, renderForestFromSource } from '../render-source.js';
-import { createNode } from '../canvas.js';
-import { closeDb, migrate, openDb } from '../db.js';
-import { openFocusRow } from '../focuses.js';
-import { jobDir, contextDir, nodeDir } from '../paths.js';
-import { recordFault } from '../recovery.js';
-function startMockCrtrServer(route) {
-    return new Promise((resolve) => {
-        const server = createServer((req, res) => {
-            const chunks = [];
-            req.on('data', (c) => chunks.push(c));
-            req.on('end', () => {
-                const bodyText = Buffer.concat(chunks).toString('utf8');
-                const parsed = JSON.parse(bodyText);
-                const result = route(parsed.args);
-                res.writeHead(result.status ?? 200, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({ ok: true, exitCode: 0, stdout: JSON.stringify(result.body), stderr: '' }));
-            });
-        });
-        server.listen(0, '127.0.0.1', () => {
-            const addr = server.address();
-            const port = typeof addr === 'object' && addr !== null ? addr.port : 0;
-            resolve({
-                url: `http://127.0.0.1:${port}`,
-                close: () => new Promise((res) => server.close(() => res())),
-            });
-        });
-    });
-}
-function meta(id, extra) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...extra,
-    };
-}
-function row(id, fault) {
-    return {
-        ...(fault === undefined ? {} : { fault }),
-        node_id: id,
-        name: id,
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        cwd: '/tmp/work',
-        host_kind: null,
-        profile_id: null,
-        parent: null,
-        created: new Date().toISOString(),
-        intent: null,
-        waiting_for: null,
-        pi_pid: null,
-        pi_pid_identity: null,
-        window: null,
-        tmux_session: null,
-        pane: null,
-    };
-}
-let home;
-let localCwd;
-let sessionFile;
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-render-remote-'));
-    localCwd = mkdtempSync(join(tmpdir(), 'crtr-render-remote-cwd-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    rmSync(nodeDir('poison-ask'), { recursive: true, force: true });
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    rmSync(localCwd, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-/** Seed conflicting local state for node id `a` — every local read
- *  `*FromSource`'s remote suppression is supposed to bypass. Returns the
- *  poisoned session-file path so the mocked `node inspect show` response can
- *  point `pi_session_file` at it (the vector a regression would follow). */
-function seedPoisonedLocalState() {
-    // A local node row + a pending ticket under its cwd — poisons `ticketCountsForNodes`.
-    createNode(meta('a', { cwd: localCwd }));
-    const askDir = nodeDir('poison-ask');
-    mkdirSync(askDir, { recursive: true });
-    atomicWriteJson(pageManifestPath(askDir), {
-        schema: 'crtr.page/v2',
-        dialect: 'jsx',
-        title: 'poison',
-        subtitle: 'This local ticket must not affect the remote rendering.',
-        delivery: { placement: 'inline', inbox: true, reply: true },
-        document: 'page.tsx',
-        steps: 1,
-        slots: [],
-    });
-    // A local focus + broker viewer — poison both `viewed` signals.
-    openFocusRow('poison-focus', null, null, 'a');
-    writeFileSync(join(jobDir('a'), 'attach.json'), JSON.stringify({ viewers: 1 }));
-    // A local active fault — poisons `hanging`.
-    recordFault('a', {
-        link: 'viewer↔broker',
-        op: 'poison',
-        kind: 'other',
-        retry: { disposition: 'manual' },
-        message: 'POISON FAULT — local read leaked into remote render',
-    });
-    // Local telemetry — poisons `ctx_tokens`.
-    writeFileSync(join(jobDir('a'), 'telemetry.json'), JSON.stringify({ tokens_in: 999999 }));
-    // A local goal file — poisons `goal`.
-    writeFileSync(join(contextDir('a'), 'initial-prompt.md'), 'POISON GOAL — local read leaked into remote render');
-    // A local session transcript — poisons `prompts`/`lastAssistant`.
-    const sf = join(home, 'poison-session.jsonl');
-    writeFileSync(sf, [
-        JSON.stringify({ type: 'message', message: { role: 'user', content: 'POISON PROMPT' } }),
-        JSON.stringify({ type: 'message', message: { role: 'assistant', content: 'POISON ASSISTANT REPLY' } }),
-    ].join('\n'));
-    return sf;
-}
-/** What the remote daemon projected onto its own row — the only fault a remote
- *  row may ever show. */
-const remoteFault = {
-    link: 'daemon→node',
-    op: 'remote turn',
-    kind: 'wedged',
-    retry: { disposition: 'manual' },
-    message: 'remote daemon fault',
-    since: new Date().toISOString(),
-    operation_id: '44444444444444444444444444444444',
-};
-test('dashboardRowsAllFromSource / enrichRowsFromSource / loadPreviewFromSource suppress every local-read field to its safe default for a RemoteCanvasSource, even with conflicting local state for the same node id', async (t) => {
-    sessionFile = seedPoisonedLocalState();
-    const server = await startMockCrtrServer((args) => {
-        if (args[1] === 'node' && args[2] === 'inspect' && args[3] === 'list') {
-            return { body: { nodes: [row('a', remoteFault)] } };
-        }
-        if (args[1] === 'node' && args[2] === 'inspect' && args[3] === 'show') {
-            return {
-                body: {
-                    // pi_session_file points at the poisoned local transcript above — if
-                    // the remote suppression regressed and read it anyway, `prompts`/
-                    // `lastAssistant` below would come back non-empty.
-                    node: meta(args[4], { pi_session_file: sessionFile }),
-                    reports: [],
-                    managers: [],
-                    artifacts: { report: 0, doc: 0, roadmap: 0 },
-                    pending_crons: 0,
-                    paths: { context_dir: '/tmp/context', reports_dir: '/tmp/reports', session_file: null },
-                    follow_up: '',
-                },
-            };
-        }
-        return { status: 500, body: {} };
-    });
-    // Register the close BEFORE any assertion runs — a listening server left
-    // open by a thrown assertion keeps this test file's process alive forever.
-    t.after(() => server.close());
-    const source = new RemoteCanvasSource(server.url, 'tok');
-    const rows = await dashboardRowsAllFromSource(source);
-    assert.equal(rows.length, 1);
-    const r = rows[0];
-    assert.equal(r.hanging?.message, 'remote daemon fault', 'the remote row must carry the fault its own daemon projected');
-    assert.equal(r.streaming, false);
-    assert.equal(r.viewed, false, 'local focus must not leak into a remote row');
-    await enrichRowsFromSource(source, rows);
-    assert.equal(r.ctx_tokens, 0, 'local telemetry must not leak into a remote row');
-    assert.equal(r.asks, 0, 'a local pending ask for the same node id must not leak into a remote row');
-    assert.equal(r.enriched, true);
-    const previewed = await loadPreviewFromSource(source, r);
-    assert.equal(previewed.goal, undefined, 'a local goal file must not leak into a remote preview');
-    assert.equal(previewed.prompts, undefined, 'a local session transcript must not leak into a remote preview');
-    assert.equal(previewed.lastAssistant, undefined, 'a local session transcript must not leak into a remote preview');
-    assert.equal(previewed.previewLoaded, true);
-});
-// `renderForestFromSource` is a separate path from
-// `dashboardRowsAllFromSource`/`enrichRowsFromSource`/`loadPreviewFromSource`
-// above, with its own remote suppression in `renderTreeFromSource`/
-// `nodeLineFromSource` (render.ts). The poisoned-state test above never
-// exercises it, so a regression that reintroduced local telemetry/ask/fault
-// reads into the static forest renderer would still leak poisoned local state.
-test('renderForestFromSource suppresses local-read fields (ctx, asks, hanging) for a RemoteCanvasSource, even with conflicting local state for the same node id', async (t) => {
-    const sf = seedPoisonedLocalState();
-    const server = await startMockCrtrServer((args) => {
-        if (args[1] === 'node' && args[2] === 'inspect' && args[3] === 'list') {
-            return { body: { nodes: [row('a')] } };
-        }
-        if (args[1] === 'node' && args[2] === 'inspect' && args[3] === 'show') {
-            return {
-                body: {
-                    node: meta(args[4], { pi_session_file: sf }),
-                    reports: [],
-                    managers: [],
-                    artifacts: { report: 0, doc: 0, roadmap: 0 },
-                    pending_crons: 0,
-                    paths: { context_dir: '/tmp/context', reports_dir: '/tmp/reports', session_file: null },
-                    follow_up: '',
-                },
-            };
-        }
-        return { status: 500, body: {} };
-    });
-    t.after(() => server.close());
-    const source = new RemoteCanvasSource(server.url, 'tok');
-    const out = await renderForestFromSource(source);
-    assert.match(out, /ctx 0k/, 'the remote node must render with the suppressed ctx default, not a real token read');
-    assert.doesNotMatch(out, /⚑/, 'no ask badge — local asks must not leak into the static forest render');
-    assert.doesNotMatch(out, /POISON FAULT/, 'a local active fault must not leak into the static forest render');
-    assert.doesNotMatch(out, /POISON/, 'no poisoned local telemetry/goal/session text may appear anywhere in the output');
-});

package/dist/core/canvas/__tests__/session-window.test.d.ts

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

package/dist/core/canvas/__tests__/session-window.test.js

@@ -1,70 +0,0 @@
-// session-window.test.ts — the preview readers see the ends of a huge session
-// without slurping the middle.
-//
-// A pi session file grows without bound (67 MB on a real canvas), and reading one
-// whole to show a few turns is what stalled the browse preview panel. The readers
-// now take a head and a tail window, which introduces the one thing worth pinning:
-// each cut lands in the MIDDLE of a jsonl record, so the fragment on the inside
-// edge must be dropped rather than parsed. Get that wrong and the newest turn
-// silently disappears — a rendering bug that looks like a node with no history.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readSessionParts, readTranscript } from '../render-source.js';
-/** One pi-shaped jsonl message record. */
-function rec(role, text) {
-    return JSON.stringify({ type: 'message', message: { role, content: [{ type: 'text', text }] } });
-}
-/** A session whose bulk sits between the first and last turns, big enough that the
- *  4 MiB transcript tail and 1 MiB parts head cannot both reach the same records. */
-function hugeSession(dir) {
-    const filler = rec('assistant', 'x'.repeat(64 * 1024));
-    const lines = [rec('user', 'FIRST-PROMPT')];
-    for (let i = 0; i < 120; i++)
-        lines.push(filler);
-    lines.push(rec('user', 'LAST-PROMPT'), rec('assistant', 'LAST-REPLY'));
-    const file = join(dir, 'huge.jsonl');
-    writeFileSync(file, `${lines.join('\n')}\n`);
-    return file;
-}
-test('a small session reads exactly as it did before windowing', () => {
-    const dir = mkdtempSync(join(tmpdir(), 'session-window-'));
-    try {
-        const file = join(dir, 'small.jsonl');
-        writeFileSync(file, `${[rec('user', 'hello'), rec('assistant', 'hi there')].join('\n')}\n`);
-        const parts = readSessionParts(file);
-        assert.equal(parts.prompts, 'hello');
-        assert.equal(parts.lastAssistant, 'hi there');
-        assert.deepEqual(readTranscript(file).map((t) => t.text), ['hello', 'hi there']);
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test('a huge session still yields its newest turns', () => {
-    const dir = mkdtempSync(join(tmpdir(), 'session-window-'));
-    try {
-        const file = hugeSession(dir);
-        // The tail window lands mid-record; the newest turns must survive it intact.
-        const turns = readTranscript(file);
-        assert.equal(turns.at(-1)?.text, 'LAST-REPLY');
-        assert.equal(turns.at(-2)?.text, 'LAST-PROMPT');
-        // Nothing partial got through: every turn is a whole record's text.
-        for (const t of turns)
-            assert.ok(t.text.length > 0);
-        const parts = readSessionParts(file);
-        assert.ok(parts.prompts?.includes('FIRST-PROMPT'), 'head window keeps the opening prompt');
-        assert.equal(parts.lastAssistant, 'LAST-REPLY');
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test('a missing session file is empty, not a throw', () => {
-    assert.deepEqual(readSessionParts(join(tmpdir(), 'nope-does-not-exist.jsonl')), {});
-    assert.deepEqual(readTranscript(join(tmpdir(), 'nope-does-not-exist.jsonl')), []);
-    assert.deepEqual(readSessionParts(null), {});
-    assert.deepEqual(readTranscript(undefined), []);
-});

package/dist/core/feed/__tests__/inbox-migrate.test.d.ts

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

package/dist/core/feed/__tests__/inbox-migrate.test.js

@@ -1,49 +0,0 @@
-// Retained legacy mailbox import: the SQL cutover preserves historical inbox
-// bytes by importing them into messages and deliveries without leaving a
-// runtime filesystem reader.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { DatabaseSync } from 'node:sqlite';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { migrateMessagingState } from '../../canvas/deliveries.js';
-import { inboxPath, nodeDir } from '../../canvas/paths.js';
-test('legacy inbox rows and cursor import once into acknowledged and pending SQL deliveries', () => {
-    const home = mkdtempSync(join(tmpdir(), 'crtr-inboxmigrate-'));
-    const orig = process.env['CRTR_HOME'];
-    process.env['CRTR_HOME'] = home;
-    const nodeId = 'mrtest01-aabbccdd';
-    const db = new DatabaseSync(join(home, 'canvas.db'));
-    try {
-        db.exec('CREATE TABLE nodes (node_id TEXT PRIMARY KEY, waiting_for TEXT, waiting_for_generation INTEGER)');
-        db.prepare('INSERT INTO nodes (node_id, waiting_for, waiting_for_generation) VALUES (?, NULL, 0)').run(nodeId);
-        db.exec('CREATE TABLE human_action_deliveries (request_id TEXT, state TEXT, attempt INTEGER, argv_json TEXT, cwd TEXT, completion_json TEXT, next_attempt_at INTEGER, claimed_at INTEGER, claim_owner TEXT, accepted_at INTEGER, permanent_failed_at INTEGER, last_failure_json TEXT, created_at INTEGER, updated_at INTEGER)');
-        db.exec('CREATE TABLE node_outcome_deliveries (node_id TEXT, state TEXT, attempt INTEGER, action_name TEXT, argv_json TEXT, cwd TEXT, config_origin TEXT, payload_json TEXT, document_json TEXT, next_attempt_at INTEGER, claimed_at INTEGER, claim_owner TEXT, accepted_at INTEGER, permanent_failed_at INTEGER, last_failure_json TEXT, created_at INTEGER, updated_at INTEGER)');
-        mkdirSync(nodeDir(nodeId), { recursive: true });
-        const lines = [
-            '{"entry_id":"11111111111111111111111111111111","operation_id":"22222222222222222222222222222222","ts":"2026-07-09T22:54:06.294Z","from":"mrpeer1-00000001","tier":"normal","kind":"final","label":"one"}',
-            '{"entry_id":"33333333333333333333333333333333","operation_id":"44444444444444444444444444444444","ts":"2026-07-10T01:00:00.000Z","from":"mrpeer1-00000001","tier":"normal","kind":"update","label":"two"}',
-        ];
-        writeFileSync(inboxPath(nodeId), `${lines.join('\n')}\n`, 'utf8');
-        writeFileSync(`${inboxPath(nodeId)}.cursor`, '11111111111111111111111111111111', 'utf8');
-        migrateMessagingState(db);
-        const deliveries = db.prepare(`SELECT m.message_id, m.created_at, d.state, d.acknowledged_at
-         FROM deliveries d JOIN messages m ON m.message_id = d.message_id
-        WHERE d.destination_kind = 'node_inbox' AND d.destination_id = ? ORDER BY m.seq`).all(nodeId);
-        assert.deepEqual(deliveries.map(({ message_id, state }) => ({ message_id, state })), [
-            { message_id: '11111111111111111111111111111111', state: 'acknowledged' },
-            { message_id: '33333333333333333333333333333333', state: 'pending' },
-        ], 'the retained file rows become ordered SQL message/delivery facts and the legacy cursor becomes acknowledgement');
-        assert.equal(deliveries[0].acknowledged_at, Date.parse('2026-07-09T22:54:06.294Z'));
-        assert.equal(deliveries[1].created_at, '2026-07-10T01:00:00.000Z');
-    }
-    finally {
-        db.close();
-        if (orig === undefined)
-            delete process.env['CRTR_HOME'];
-        else
-            process.env['CRTR_HOME'] = orig;
-        rmSync(home, { recursive: true, force: true });
-    }
-});

package/dist/core/human/__tests__/page-catalog.test.d.ts

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

package/dist/core/human/__tests__/page-catalog.test.js

@@ -1,20 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { normalizePageComponents, pageComponentKinds } from '../page-catalog.js';
-test('page component registrations accept legacy names and documented objects', () => {
-    const components = normalizePageComponents([
-        'approval',
-        { kind: 'approval-card', description: 'Approval card', useWhen: 'Use for an approval.', doc: 'Product contract.', display: true },
-    ]);
-    assert.deepEqual(components, [
-        { kind: 'approval' },
-        { kind: 'approval-card', description: 'Approval card', useWhen: 'Use for an approval.', doc: 'Product contract.', display: true },
-    ]);
-    assert.deepEqual(pageComponentKinds(components), ['approval', 'approval-card']);
-    assert.throws(() => normalizePageComponents([{ kind: 'approval', display: 'yes' }]), /page_components\[0\]\.display must be a boolean/);
-    assert.throws(() => normalizePageComponents([{ kind: 'approval', unexpected: true }]), /unknown field\(s\): unexpected/);
-});
-test('page component registrations reserve derived built-in and product JSX tags', () => {
-    assert.throws(() => normalizePageComponents(['user-question']), /derives JSX tag "UserQuestion", which collides with a built-in page component/);
-    assert.throws(() => normalizePageComponents(['foo-bar', 'foo--bar']), /derives JSX tag "FooBar", which duplicates another product page component/);
-});

package/dist/core/human/__tests__/page-html-markdown.test.d.ts

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

package/dist/core/human/__tests__/page-html-markdown.test.js

@@ -1,48 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { projectHtmlDocumentMarkdown } from '../page-html-markdown.js';
-test('an authored HTML page projects to readable markdown', () => {
-    const markdown = projectHtmlDocumentMarkdown(`<!doctype html>
-<html><head><title>Deploy sign-off</title><style>body{color:red}</style></head>
-<body>
-<h1>Deploy sign-off</h1>
-<p>Staging has been green for <strong>6 hours</strong>; the risk is the <em>migration</em>.</p>
-<ul><li>Smoke suite passed</li><li>Rollback rehearsed &mdash; 90s</li><li>See <a href="https://ci.example.com/42">run 42</a></li></ul>
-<table><tr><th>Step</th><th>Duration</th></tr><tr><td>Migrate</td><td>4m 10s</td></tr></table>
-<pre><code>kubectl rollout status deploy/orders</code></pre>
-<blockquote>Waiting on your call.</blockquote>
-<script>console.log('nope')</script>
-</body></html>`);
-    assert.equal(markdown, [
-        '# Deploy sign-off',
-        '',
-        'Staging has been green for **6 hours**; the risk is the *migration*.',
-        '',
-        '- Smoke suite passed',
-        '- Rollback rehearsed — 90s',
-        '- See [run 42](https://ci.example.com/42)',
-        '',
-        '| Step | Duration |',
-        '| --- | --- |',
-        '| Migrate | 4m 10s |',
-        '',
-        '```',
-        'kubectl rollout status deploy/orders',
-        '```',
-        '',
-        '> Waiting on your call.',
-    ].join('\n'));
-});
-test('the projection survives malformed markup rather than losing the document', () => {
-    // A stray </style> must not reopen the head, and a stray <script> must not
-    // swallow the rest of the page: both are common in hand-written HTML.
-    assert.match(projectHtmlDocumentMarkdown('</style><p>Body text</p>'), /Body text/);
-    assert.equal(projectHtmlDocumentMarkdown('<p>Before</p><script>x=1;</script><p>After</p>'), 'Before\n\nAfter');
-    assert.equal(projectHtmlDocumentMarkdown('<p>Alone<'), 'Alone\\<');
-    assert.equal(projectHtmlDocumentMarkdown(''), '');
-    // Ordered lists number themselves, and a link with no label leaves no husk.
-    assert.equal(projectHtmlDocumentMarkdown('<ol><li>First</li><li>Second</li></ol>'), '1. First\n2. Second');
-    assert.equal(projectHtmlDocumentMarkdown('<p>Read <a href="https://x.test"></a>this</p>'), 'Read this');
-    // Markdown structure in authored prose is escaped, not obeyed.
-    assert.equal(projectHtmlDocumentMarkdown('<p># not a heading</p>'), '\\# not a heading');
-});

package/dist/core/human/__tests__/page.test.d.ts

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

package/dist/core/human/__tests__/page.test.js

@@ -1,92 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { derivePageManifestFromDocument } from '../page.js';
-import { isResponseBearingSlot, validatePageManifest, validatePageResponses, validatePartialPageResponses } from '../page-schema.js';
-const OPTIONS = '<UserQuestion id="choice" label="Choose an option" body="One of these ships tonight." mode="single" options={[{ id: "yes", label: "Yes" }]} />';
-function page(body, props = 'title="Test"') {
-    return `export default function Page_() {\n  return (\n    <Page ${props}>\n      ${body}\n    </Page>\n  );\n}\n`;
-}
-test('jsx pages derive page props, steps, and document-order slots', () => {
-    const manifest = derivePageManifestFromDocument(page(`<Step>${OPTIONS}</Step>\n      <Step><Chart kind="bar" x="day" y={[{ field: "count" }]} /></Step>`, 'title="JSX" subtitle="Two steps"'));
-    assert.equal(manifest.title, 'JSX');
-    assert.equal(manifest.subtitle, 'Two steps');
-    assert.deepEqual(manifest.delivery, { placement: 'inline', inbox: false, reply: false });
-    assert.equal(manifest.steps, 2);
-    assert.deepEqual(manifest.slots.map(({ kind, step, id }) => ({ kind, step, id })), [
-        { kind: 'options', step: 0, id: 'choice' },
-        { kind: 'chart', step: 1, id: undefined },
-    ]);
-});
-test('a page without steps is one step, and a slot config computed at render time still reaches the manifest', () => {
-    const manifest = derivePageManifestFromDocument(page('<UserText id="note" label="Add a note" initialText="" />'));
-    assert.equal(manifest.steps, 1);
-    assert.deepEqual(manifest.slots, [{ id: 'note', kind: 'text', step: 0, config: { label: 'Add a note', initialText: '' } }]);
-    // The manifest is harvested by rendering the page, so mapped data, helper components,
-    // and hook state are all present; handlers are dropped because a manifest is JSON.
-    const computed = derivePageManifestFromDocument(`const ROWS = [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }];
-function Pick({ rows }) { return <UserQuestion id="picks" label="Pick" body="Rows come from data." mode="single" options={rows.map((r) => ({ id: r.id, label: r.label }))} onSelect={() => 1} />; }
-export default function Computed() { const [title] = React.useState('Computed'); return <Page title={title}><Pick rows={ROWS} /></Page>; }
-`);
-    assert.equal(computed.title, 'Computed');
-    assert.deepEqual(computed.slots, [{ id: 'picks', kind: 'options', step: 0, config: { label: 'Pick', body: 'Rows come from data.', mode: 'single', options: [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }] } }]);
-});
-test('a page that cannot render is rejected with the reason', () => {
-    assert.throws(() => derivePageManifestFromDocument(page(OPTIONS, 'title=""')), /nonempty title prop/);
-    assert.throws(() => derivePageManifestFromDocument(page(OPTIONS, 'title="T" placement="drawer"')), /placement is not authored/);
-    assert.throws(() => derivePageManifestFromDocument('function Page_() { return <Page title="T" />; }\n'), /must `export default` a component function/);
-    assert.throws(() => derivePageManifestFromDocument('export default function Page_() { return (<><Page title="A" /><Page title="B" /></>); }'), /exactly one is allowed/);
-    assert.throws(() => derivePageManifestFromDocument('export default () => <Page title="T"><Mystery /></Page>;'), /Mystery is not defined/);
-    assert.throws(() => derivePageManifestFromDocument('export default async () => <Page title="T" />;'), /async/);
-});
-test('module plumbing is rejected with the in-scope teaching', () => {
-    const importing = `import React from 'react';\n${page(OPTIONS)}`;
-    assert.throws(() => derivePageManifestFromDocument(importing), /page source uses import: .*already in scope/s);
-    const requiring = `const x = require('./data.json');\n${page(OPTIONS)}`;
-    assert.throws(() => derivePageManifestFromDocument(requiring), /page source uses require\(\)/);
-});
-test('a page that does not compile is reported with its location', () => {
-    assert.throws(() => derivePageManifestFromDocument('export default function Page_() { return (<Page title="Broken">; }'), /page does not compile: .*page\.tsx:\d+:\d+/s);
-});
-test('the response-bearing predicate handles table selection and catalog edges', () => {
-    const slot = (kind, config, unvalidated) => ({ kind, step: 0, config, ...(unvalidated ? { unvalidated } : {}) });
-    assert.equal(isResponseBearingSlot(slot('table', { columns: [{ id: 'c', label: 'C' }], rowSelect: 'none', columnSelect: 'none' })), false);
-    assert.equal(isResponseBearingSlot(slot('table', { columns: [{ id: 'c', label: 'C' }], rowSelect: 'single', columnSelect: 'none' })), true);
-    assert.equal(isResponseBearingSlot(slot('chart', { kind: 'bar', x: 'x', y: [{ field: 'y' }] })), false);
-    assert.equal(isResponseBearingSlot(slot('product-kind', {}, true)), true);
-});
-test('product components are authored under their PascalCase tag', () => {
-    const displayComponent = [{ kind: 'nl-thread', display: true }];
-    const manifest = derivePageManifestFromDocument(page('<NlThread messages={[]} />'), displayComponent);
-    assert.deepEqual(manifest.slots, [{ kind: 'nl-thread', step: 0, config: { messages: [] }, unvalidated: true, display: true }]);
-    assert.deepEqual(validatePageManifest(manifest).slots, manifest.slots);
-    assert.equal(isResponseBearingSlot(manifest.slots[0]), false);
-    assert.throws(() => derivePageManifestFromDocument(page('<ProductInput />'), [{ kind: 'product-input' }]), /product slot kind "product-input" at slot #0 requires an id prop/);
-});
-test('a question requires its label and body at authoring time', () => {
-    assert.throws(() => derivePageManifestFromDocument(page('<UserQuestion id="choice" body="Context." mode="single" options={[{ id: "yes", label: "Yes" }]} />')), /slot "choice" \(options\): label is required/);
-    assert.throws(() => derivePageManifestFromDocument(page('<UserQuestion id="choice" label="Choose" mode="single" options={[{ id: "yes", label: "Yes" }]} />')), /slot "choice" \(options\): body is required/);
-});
-test('multi-response pages require a label on every response-bearing slot', () => {
-    assert.throws(() => derivePageManifestFromDocument(page(`<UserText id="first" initialText="" />\n      <UserText id="note" label="Add a note" initialText="" />`)), /response-bearing slot "first" requires a nonempty config\.label/);
-    assert.throws(() => derivePageManifestFromDocument(page(`${OPTIONS}\n      <UserTable id="table" label="Pick a row" columns={[{ id: "name", label: "Name" }]} rows={[{ id: "one", cells: { name: "One" } }]} rowSelect="single" caption="old" />`)), /invalid config for slot "table"/);
-});
-test('final and partial response validation share slot-addressed rules', () => {
-    const manifest = derivePageManifestFromDocument(page(`${OPTIONS}\n      <UserText id="note" label="Add a note" initialText="" />`));
-    assert.deepEqual(validatePartialPageResponses(manifest, { choice: { selectedOptionIds: ['yes'], comments: [] } }), { choice: { selectedOptionIds: ['yes'], comments: [] } });
-    assert.throws(() => validatePageResponses(manifest, { choice: { selectedOptionIds: ['yes'], comments: [] } }), /missing response-bearing slot id "note"/);
-    assert.deepEqual(validatePageResponses(manifest, { choice: { selectedOptionIds: ['yes'], comments: [] }, note: { text: '', edited: false } }), { choice: { selectedOptionIds: ['yes'], comments: [] }, note: { text: '', edited: false } });
-    assert.throws(() => validatePartialPageResponses(manifest, { choice: { selectedOptionIds: ['maybe'], comments: [] } }), /unknown option id "maybe"/);
-    assert.throws(() => validatePartialPageResponses(manifest, { extra: {} }), /unknown or non-response-bearing slot id "extra"/);
-});
-// Which questions have a minimum is the author's call, and both defaults matter to a
-// renderer mirroring this rule: pick-many is answered by ticking nothing, pick-one is not.
-test('an empty answer is refused only where the question is required', () => {
-    const manifest = derivePageManifestFromDocument(page(`<UserQuestion id="risks" label="Tick everything that applies" body="Skip it if none do." mode="multi" options={[{ id: "data", label: "Data" }]} />
-      <UserQuestion id="lane" label="Which lane?" body="Ships tonight." mode="single" required={false} options={[{ id: "now", label: "Now" }]} />
-      <UserText id="window" label="Maintenance window" initialText="" required />`));
-    const empty = { risks: { selectedOptionIds: [], comments: [] }, lane: { selectedOptionIds: [], comments: [] }, window: { text: 'Sunday 02:00', edited: true } };
-    assert.deepEqual(validatePageResponses(manifest, empty), empty);
-    assert.throws(() => validatePageResponses(manifest, { ...empty, window: { text: '  ', edited: true } }), /slot "window" is required and was left empty/);
-    const required = derivePageManifestFromDocument(page('<UserQuestion id="risks" label="Tick everything that applies" body="At least one." mode="multi" required options={[{ id: "data", label: "Data" }]} />'));
-    assert.throws(() => validatePageResponses(required, { risks: { selectedOptionIds: [], comments: [] } }), /multi-select slot "risks" requires a selection/);
-});

package/dist/core/keybindings/__tests__/resolve.test.d.ts

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