@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/canvas-inbox-watcher.test.js

@@ -1,397 +0,0 @@
-// Tests for the canvas-node inbox watcher pi extension.
-//
-// Run with: node --import tsx/esm --test src/core/__tests__/canvas-inbox-watcher.test.ts
-//
-// Focus: a finished node (push final → InboxEntry kind 'final') must STEER a
-// mid-stream subscriber, not queue behind its current turn as a follow-up.
-// Part 2 — the refresh-yield HOLD path and idle delivery — lives in
-// canvas-inbox-watcher-hold.test.ts (split for node:test file-level parallelism).
-import { test, describe, before, after, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import registerCanvasInboxWatcher from '../../pi-extensions/canvas-inbox-watcher.js';
-import { createNode, getNode } from '../canvas/canvas.js';
-import { claimNodeMail } from '../canvas/deliveries.js';
-import { reportsDir } from '../canvas/paths.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { beginExecution } from '../canvas/executions.js';
-import { enqueueNodeMail } from '../feed/messages.js';
-import { coalesce, nodeMailEntry } from '../feed/inbox.js';
-import { appendSituationalContext, SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../runtime/situational-context.js';
-import { parseCard } from '../../shared/generated-context.js';
-import { BROKER_IDLE_TURN_START } from '../runtime/broker/held-deferred-inbox.js';
-import { createApiServer } from '../../daemon/api/server.js';
-// Drive the watcher's injectable cadence seam (CRTR_WATCHER_TICK_MS /
-// CRTR_WATCHER_DEBOUNCE_MS) at a fast tempo so the watcher delivers in tens of
-// milliseconds, not seconds — exactly the resolve+seed tick, read tick, and
-// debounce window it runs against the real 800/1000 cadence. Tests then poll for
-// the delivery with waitFor() rather than sleeping a fixed settle window, so a
-// starved interval tick on a loaded CI runner can't race the assertion.
-const TICK_MS = 20;
-const DEBOUNCE_MS = 25;
-let origHome;
-let origNode;
-let origExecution;
-const homes = [];
-let server;
-const disposers = [];
-/** Point CRTR_HOME at a fresh temp canvas root and bind CRTR_NODE_ID. */
-function freshNode(nodeId) {
-    closeDb();
-    const home = join(tmpdir(), `cw-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(home, { recursive: true });
-    homes.push(home);
-    process.env['CRTR_HOME'] = home;
-    process.env['CRTR_NODE_ID'] = nodeId;
-    migrate(openDb());
-}
-function ensureWatcherNode(nodeId) {
-    if (getNode(nodeId) !== null)
-        return;
-    createNode({
-        node_id: nodeId,
-        name: nodeId,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'resident',
-        status: 'active',
-    });
-}
-function publishMail(nodeId, input) {
-    ensureWatcherNode(nodeId);
-    return enqueueNodeMail(nodeId, {
-        kind: input.kind,
-        label: input.label,
-        senderNodeId: input.from,
-        bodyRef: input.ref,
-        bodyJson: input.data,
-        disposition: input.disposition,
-        urgency: input.tier,
-        wake: 1,
-    });
-}
-function claimedMail(nodeId, input) {
-    publishMail(nodeId, input);
-    const claim = claimNodeMail(nodeId, beginExecution(nodeId, { daemonEpoch: 'test' }), 'wake');
-    assert.equal(claim.action, 'claimed');
-    assert.equal(claim.deliveries.length, 1);
-    return nodeMailEntry(claim.deliveries[0]);
-}
-function makeFakePi() {
-    const handlers = {};
-    const pi = {
-        injected: [],
-        sentMessages: [],
-        on(e, h) { handlers[e] = h; },
-        sendUserMessage(content, options) { this.injected.push({ content, deliverAs: options?.deliverAs }); },
-        sendMessage(message) { this.sentMessages.push(message); },
-        fire(e, ev, ctx) { handlers[e]?.(ev, ctx); },
-    };
-    globalThis[BROKER_IDLE_TURN_START] = (content) => pi.sendUserMessage(content);
-    return pi;
-}
-const wait = (ms) => new Promise((r) => setTimeout(r, ms));
-/** The text of a batch that must coalesce into exactly one delivery. */
-function onlyDelivery(deliveries) {
-    assert.equal(deliveries.length, 1, 'expected a single delivery');
-    return deliveries[0].text;
-}
-// Register the watcher, then fire session_start — the real lifecycle gate
-// that arms its poll interval and initial tick (see canvas-inbox-watcher.ts).
-// registerCanvasInboxWatcher() alone only wires up handlers; without this the
-// watcher never polls or sends anything.
-function registerWatcher(pi) {
-    const nodeId = process.env['CRTR_NODE_ID'];
-    ensureWatcherNode(nodeId);
-    process.env['CRTR_EXECUTION_ID'] = beginExecution(nodeId, { daemonEpoch: 'test' });
-    const dispose = registerCanvasInboxWatcher(pi);
-    server ??= createApiServer();
-    void server.ready.then(() => pi.fire('session_start', { type: 'session_start' }, undefined));
-    return dispose;
-}
-// Poll `predicate` until it holds or `timeoutMs` elapses, then return either
-// way. The watcher delivers on its own setInterval cadence, which competes for
-// the event loop with this test's timers; a fixed sleep before asserting is
-// unreliable on an oversubscribed CI runner (--test-concurrency=4), where an
-// interval tick is starved past the debounce window and the assertion runs
-// before the flush — the observed `0 !== 1` flake. Polling returns the instant
-// delivery lands (fast in the common case) and tolerates scheduling jitter with
-// a generous ceiling; returning on timeout lets the following asserts produce a
-// precise message instead of a generic wait error.
-async function waitFor(predicate, timeoutMs = 3000, stepMs = 10) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (predicate())
-            return;
-        await wait(stepMs);
-    }
-}
-test('coalesce renders one inbox card whose entries inline short report bodies and carry their refs', () => {
-    freshNode('child');
-    const child = createNode({
-        node_id: 'child',
-        name: 'child',
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-    });
-    const reportPath = join(reportsDir(child.node_id), 'short-update.md');
-    mkdirSync(reportsDir(child.node_id), { recursive: true });
-    writeFileSync(reportPath, '---\nnode: child\nkind: update\n---\nshort report body', 'utf8');
-    const digest = onlyDelivery(coalesce([
-        claimedMail('child', { from: 'child', tier: 'normal', kind: 'update', label: 'short report', ref: 'child:reports/short-update.md' }),
-    ]));
-    // The envelope is the whole message: a reader that finds it anywhere else
-    // attributes the digest to the person.
-    assert.equal(digest.startsWith('<runtime kind="inbox"'), true);
-    assert.equal(digest.endsWith('</runtime>'), true);
-    const card = parseCard({ role: 'user', content: digest });
-    assert.notEqual(card, null);
-    assert.equal(card.kind, 'inbox');
-    assert.deepEqual({ ...card.facts }, {});
-    assert.equal(card.senders.length, 1);
-    assert.equal(card.senders[0].id, 'child');
-    // The label is NOT reprinted above the body it duplicates.
-    assert.deepEqual(card.senders[0].entries, [
-        { kind: 'update', disposition: 'report', body: 'short report body\n\nRead this report with `crtr canvas history read child:reports/short-update.md`.', ref: 'child:reports/short-update.md' },
-    ]);
-    assert.equal(reportPath.endsWith('short-update.md'), true);
-    // A report too large to inline (here: absent) keeps its label and its ref.
-    const canonical = parseCard({
-        role: 'user',
-        content: onlyDelivery(coalesce([
-            claimedMail('child', { from: 'child', tier: 'normal', kind: 'final', label: 'done', ref: 'child:reports/final.md' }),
-        ])),
-    });
-    assert.deepEqual(canonical.senders[0].entries, [
-        { kind: 'final', disposition: 'report', body: 'done\n\nRead this report with `crtr canvas history read child:reports/final.md`.', ref: 'child:reports/final.md' },
-    ]);
-    assert.equal(canonical.senders[0].finished, true);
-    const spilled = parseCard({
-        role: 'user',
-        content: onlyDelivery(coalesce([
-            claimedMail('child', { from: 'child', tier: 'normal', kind: 'message', label: 'long', ref: '/tmp/message.md', data: { body: 'long body' } }),
-        ])),
-    });
-    assert.deepEqual(spilled.senders[0].entries, [
-        { kind: 'message', disposition: 'report', body: 'long body\n\nPreview only. Read the full body from file `/tmp/message.md`.', ref: '/tmp/message.md' },
-    ]);
-    closeDb();
-});
-test('a human message coalesces verbatim — a conversation turn, not a digest', () => {
-    // A human typing directly into a node's box is a CONVERSATION TURN, so the
-    // dormant wake path must read identically to the live path: no card, no
-    // `<from>` section. Every other sender is digest content.
-    freshNode('human');
-    const body = 'first line\n\nsecond paragraph';
-    const human = onlyDelivery(coalesce([
-        claimedMail('human', { from: 'human', tier: 'normal', kind: 'message', label: 'first line', data: { body } }),
-    ]));
-    assert.equal(human, body);
-    const agent = onlyDelivery(coalesce([
-        claimedMail('agent', { from: 'mqifzplr-0753bde3', tier: 'normal', kind: 'message', label: 'go', data: { body: 'go' } }),
-    ]));
-    assert.equal(agent.startsWith('<runtime kind="inbox"'), true);
-    assert.match(agent, /<from id="mqifzplr-0753bde3">/);
-});
-test('a mixed batch splits: human words verbatim, node reports in one card, order preserved', () => {
-    // Concatenating the two into one message left `parseCard` unable to see the
-    // envelope, so the whole delivery read as the person's words.
-    freshNode('mixed');
-    const humanEntry = (body) => claimedMail('mixed-human', { from: 'human', tier: 'normal', kind: 'message', label: body, data: { body } });
-    const nodeEntry = (from, body) => claimedMail('mixed-node', { from, tier: 'normal', kind: 'update', label: body, data: { body } });
-    for (const [name, entries] of [
-        ['human first', [humanEntry('do the thing'), nodeEntry('mqifzplr-0753bde3', 'phase one done')]],
-        ['node first', [nodeEntry('mqifzplr-0753bde3', 'phase one done'), humanEntry('do the thing')]],
-    ]) {
-        const deliveries = coalesce([...entries]);
-        assert.equal(deliveries.length, 2, name);
-        // The card lands where its first sender fell.
-        assert.deepEqual(deliveries.map((d) => d.kind), name === 'human first' ? ['human', 'card'] : ['card', 'human'], name);
-        const human = deliveries.find((d) => d.kind === 'human');
-        assert.equal(human.text, 'do the thing', name);
-        assert.doesNotMatch(human.text, /<runtime|<from /, name);
-        const card = deliveries.find((d) => d.kind === 'card');
-        const parsed = parseCard({ role: 'user', content: card.text });
-        assert.notEqual(parsed, null, name);
-        assert.deepEqual(parsed.senders.map((sender) => sender.id), ['mqifzplr-0753bde3'], name);
-        assert.deepEqual(card.entries.map((entry) => entry.from), ['mqifzplr-0753bde3'], name);
-    }
-});
-let origTick;
-let origDebounce;
-before(() => {
-    origHome = process.env['CRTR_HOME'];
-    origNode = process.env['CRTR_NODE_ID'];
-    origExecution = process.env['CRTR_EXECUTION_ID'];
-    origTick = process.env['CRTR_WATCHER_TICK_MS'];
-    origDebounce = process.env['CRTR_WATCHER_DEBOUNCE_MS'];
-    process.env['CRTR_WATCHER_TICK_MS'] = String(TICK_MS);
-    process.env['CRTR_WATCHER_DEBOUNCE_MS'] = String(DEBOUNCE_MS);
-});
-afterEach(async () => {
-    while (disposers.length > 0)
-        disposers.pop()();
-    await server?.close();
-    server = undefined;
-    closeDb();
-});
-after(() => {
-    if (origHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = origHome;
-    if (origNode === undefined)
-        delete process.env['CRTR_NODE_ID'];
-    else
-        process.env['CRTR_NODE_ID'] = origNode;
-    if (origExecution === undefined)
-        delete process.env['CRTR_EXECUTION_ID'];
-    else
-        process.env['CRTR_EXECUTION_ID'] = origExecution;
-    if (origTick === undefined)
-        delete process.env['CRTR_WATCHER_TICK_MS'];
-    else
-        process.env['CRTR_WATCHER_TICK_MS'] = origTick;
-    if (origDebounce === undefined)
-        delete process.env['CRTR_WATCHER_DEBOUNCE_MS'];
-    else
-        process.env['CRTR_WATCHER_DEBOUNCE_MS'] = origDebounce;
-    for (const h of homes) {
-        try {
-            rmSync(h, { recursive: true, force: true });
-        }
-        catch { /* noop */ }
-    }
-});
-describe('canvas inbox watcher — finished-node delivery', () => {
-    test('mid-stream: a finished node (kind final) steers the subscriber', async () => {
-        freshNode('node-final');
-        const pi = makeFakePi();
-        disposers.push(registerWatcher(pi));
-        // Subscriber is actively streaming when the worker finishes.
-        pi.fire('agent_start', { type: 'agent_start' }, { isIdle: () => false });
-        await wait(TICK_MS + 100);
-        publishMail('node-final', { from: 'child-1', tier: 'normal', kind: 'final', label: 'all done' });
-        await waitFor(() => pi.injected.length >= 1);
-        assert.equal(pi.injected.length, 1, 'one coalesced injection');
-        assert.equal(pi.injected[0].deliverAs, 'steer', 'a finished node steers, not follows up');
-    });
-    test('a mixed batch reaches pi as separate messages: the person verbatim, the card whole', async () => {
-        freshNode('node-mixed');
-        const pi = makeFakePi();
-        disposers.push(registerWatcher(pi));
-        await wait(TICK_MS + 100);
-        publishMail('node-mixed', { from: 'human', tier: 'normal', kind: 'message', label: 'do the thing', data: { body: 'do the thing' } });
-        publishMail('node-mixed', { from: 'child-9', tier: 'normal', kind: 'update', label: 'phase one done' });
-        // One visible send per cycle, so the second part lands a tick later.
-        await waitFor(() => pi.injected.length >= 2);
-        assert.equal(pi.injected.length, 2, 'the batch split into two visible messages');
-        assert.equal(pi.injected[0].content, 'do the thing', 'the person\'s words arrive verbatim');
-        assert.equal(parseCard({ role: 'user', content: pi.injected[0].content }), null, 'no envelope rides the human message');
-        const card = parseCard({ role: 'user', content: pi.injected[1].content });
-        assert.notEqual(card, null, 'the card message is a whole envelope');
-        assert.deepEqual(card.senders.map((sender) => sender.id), ['child-9']);
-    });
-    test('mid-stream: a routine update still follows up', async () => {
-        freshNode('node-update');
-        const pi = makeFakePi();
-        disposers.push(registerWatcher(pi));
-        pi.fire('agent_start', { type: 'agent_start' }, { isIdle: () => false });
-        await wait(TICK_MS + 100);
-        publishMail('node-update', { from: 'child-2', tier: 'normal', kind: 'update', label: 'still working' });
-        await waitFor(() => pi.injected.length >= 1);
-        assert.equal(pi.injected.length, 1);
-        assert.equal(pi.injected[0].deliverAs, 'followUp', 'a normal update is not urgent → followUp');
-    });
-});
-describe('canvas inbox watcher — hidden situational-context delivery', () => {
-    test('a situational-only entry (no visible body) never reaches the visible digest, only the hidden sendMessage', async () => {
-        freshNode('node-situational-only');
-        appendSituationalContext('node-situational-only', 'the user is mid-checkout on the store applet');
-        const pi = makeFakePi();
-        disposers.push(registerWatcher(pi));
-        publishMail('node-situational-only', {
-            from: null,
-            tier: 'normal',
-            kind: 'message',
-            label: '(ambient context updated)',
-            data: { situational: true, situationalOnly: true },
-        });
-        // A situational-only flush sets sentMessages (never injected) in a single
-        // synchronous flush(), so waiting on the hidden send is sufficient to also
-        // settle the injected.length === 0 assertion below.
-        await waitFor(() => pi.sentMessages.length >= 1);
-        assert.equal(pi.injected.length, 0, 'a situational-only entry never triggers a visible digest');
-        assert.equal(pi.sentMessages.length, 1, 'exactly one hidden custom message sent');
-        assert.match(pi.sentMessages[0].content, /<runtime kind="situational">/);
-        assert.match(pi.sentMessages[0].content, /the user is mid-checkout on the store applet/);
-        // Pins the seam the attach viewer keys its collapsed-rendering dispatch off
-        // (src/clients/attach/render/chat-view.ts): a regression here (e.g. someone routing
-        // the situational update through a different/generic customType) would make
-        // the viewer fall through to the prominent, uncollapsed CustomMessageComponent.
-        assert.equal(pi.sentMessages[0].customType, SITUATIONAL_CONTEXT_CUSTOM_TYPE);
-    });
-    test('a combined entry (visible body + situational flag) puts the body in the digest and the ambient text ONLY in the hidden sendMessage', async () => {
-        freshNode('node-situational-combined');
-        appendSituationalContext('node-situational-combined', 'the hidden ambient checkout state');
-        const pi = makeFakePi();
-        disposers.push(registerWatcher(pi));
-        publishMail('node-situational-combined', {
-            from: 'child-3',
-            tier: 'normal',
-            kind: 'message',
-            label: 'visible update',
-            data: { body: 'the visible message body', situational: true },
-        });
-        // The hidden send and the visible digest both fire in one synchronous
-        // flush(); the injection is the later of the two, so wait on it.
-        await waitFor(() => pi.injected.length >= 1 && pi.sentMessages.length >= 1);
-        assert.equal(pi.injected.length, 1, 'the visible body still reaches the digest');
-        assert.match(pi.injected[0].content, /the visible message body/);
-        assert.doesNotMatch(pi.injected[0].content, /hidden ambient checkout state/, 'ambient text never rides the visible digest');
-        assert.equal(pi.sentMessages.length, 1, 'exactly one hidden custom message sent');
-        assert.match(pi.sentMessages[0].content, /<runtime kind="situational">/);
-        assert.match(pi.sentMessages[0].content, /the hidden ambient checkout state/);
-    });
-    test('a situational-only entry survives a transient sendMessage failure — retried, not dropped', async () => {
-        // Durability regression: the cursor advances past a situational-only entry
-        // BEFORE flush() runs, so a swallowed sendMessage failure with no re-queue
-        // would drop the hidden wake permanently (never re-read from the inbox,
-        // never retried) — unlike the visible digest path, which already re-queues
-        // on failure. This pins the same durability contract for the hidden path.
-        freshNode('node-situational-retry');
-        appendSituationalContext('node-situational-retry', 'retry me please');
-        const pi = makeFakePi();
-        let calls = 0;
-        const realSendMessage = pi.sendMessage.bind(pi);
-        pi.sendMessage = (message, options) => {
-            calls += 1;
-            if (calls === 1)
-                throw new Error('transient failure');
-            realSendMessage(message, options);
-        };
-        disposers.push(registerWatcher(pi));
-        publishMail('node-situational-retry', {
-            from: null,
-            tier: 'normal',
-            kind: 'message',
-            label: '(ambient context updated)',
-            data: { situational: true, situationalOnly: true },
-        });
-        // First send throws (re-queued), so a later flush retries: wait for the
-        // successful second delivery rather than a fixed multi-settle sleep.
-        await waitFor(() => calls >= 2 && pi.sentMessages.length >= 1);
-        assert.ok(calls >= 2, 'sendMessage retried after the first failure instead of being swallowed once');
-        assert.equal(pi.injected.length, 0, 'still never reaches the visible digest');
-        assert.equal(pi.sentMessages.length, 1, 'eventually delivered exactly once after the retry succeeds');
-        assert.match(pi.sentMessages[0].content, /retry me please/);
-    });
-});

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

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

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

@@ -1,138 +0,0 @@
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode, getRow, updateNode, setStatus, subscribe, unsubscribe, setSubscriptionActive, recordSpawn, subscribersOf, subscriptionsOf, view, hasActiveLiveSubscription, } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { nodeMetaPath } from '../canvas/paths.js';
-let home;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-canvas-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    // Fresh db + dirs per test for isolation.
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('SQL is the source of truth; a node directory contains artifacts only', () => {
-    createNode(node('a', { kind: 'developer' }));
-    assert.equal(getNode('a')?.kind, 'developer');
-    assert.equal(existsSync(nodeMetaPath('a')), false, 'creating a node does not write a metadata authority file');
-});
-// cycle_pending is stored on the node row and read by revive launch arbitration.
-test('cycle_pending survives the updateNode/getNode meta.json round-trip', () => {
-    createNode(node('a'));
-    assert.equal(getNode('a')?.cycle_pending, false); // SQL default
-    updateNode('a', { cycle_pending: true });
-    assert.equal(getNode('a')?.cycle_pending, true);
-    updateNode('a', { cycle_pending: false });
-    assert.equal(getNode('a')?.cycle_pending, false);
-});
-test('subscription spine: subscribersOf / subscriptionsOf', () => {
-    createNode(node('mgr'));
-    createNode(node('w1'));
-    createNode(node('w2'));
-    // mgr subscribes to both workers (parent watches children)
-    subscribe('mgr', 'w1');
-    subscribe('mgr', 'w2', false);
-    // w1's subscribers = who a w1 push fans out to = mgr
-    assert.deepEqual(subscribersOf('w1').map((s) => s.node_id), ['mgr']);
-    // mgr's subscriptions = its reports = both workers
-    const subs = subscriptionsOf('mgr');
-    assert.deepEqual(subs.map((s) => s.node_id).sort(), ['w1', 'w2']);
-    assert.equal(subs.find((s) => s.node_id === 'w1')?.active, true);
-    assert.equal(subs.find((s) => s.node_id === 'w2')?.active, false);
-});
-test('subscribe is idempotent and flips active', () => {
-    createNode(node('a'));
-    createNode(node('b'));
-    subscribe('a', 'b', true);
-    subscribe('a', 'b', false); // re-subscribe updates the flag, no dup
-    const subs = subscriptionsOf('a');
-    assert.equal(subs.length, 1);
-    assert.equal(subs[0].active, false);
-    setSubscriptionActive('a', 'b', true);
-    assert.equal(subscriptionsOf('a')[0].active, true);
-    unsubscribe('a', 'b');
-    assert.equal(subscriptionsOf('a').length, 0);
-});
-test('view = transitive closure down the subscription spine', () => {
-    // root → mid → leaf, plus root → sib
-    for (const id of ['root', 'mid', 'leaf', 'sib'])
-        createNode(node(id));
-    subscribe('root', 'mid');
-    subscribe('root', 'sib');
-    subscribe('mid', 'leaf');
-    assert.deepEqual(view('root').sort(), ['leaf', 'mid', 'sib']);
-    assert.deepEqual(view('mid'), ['leaf']);
-});
-test('view is cycle-safe', () => {
-    createNode(node('a'));
-    createNode(node('b'));
-    subscribe('a', 'b');
-    subscribe('b', 'a');
-    assert.deepEqual(view('a'), ['b']);
-});
-test('hasActiveLiveSubscription: the stop-guard primitive', () => {
-    createNode(node('mgr'));
-    createNode(node('child', { status: 'active' }));
-    // no subscription yet
-    assert.equal(hasActiveLiveSubscription('mgr'), false);
-    subscribe('mgr', 'child', true);
-    assert.equal(hasActiveLiveSubscription('mgr'), true); // active sub to a live node
-    setStatus('child', 'done');
-    assert.equal(hasActiveLiveSubscription('mgr'), false); // child no longer live
-    setStatus('child', 'active');
-    setSubscriptionActive('mgr', 'child', false);
-    assert.equal(hasActiveLiveSubscription('mgr'), false); // passive sub doesn't count
-});
-test('recordSpawn writes the audit-only spawned_by edge', () => {
-    createNode(node('parent'));
-    createNode(node('child', { parent: 'parent' }));
-    recordSpawn('child', 'parent');
-    // spawned_by does not appear in the subscription spine
-    assert.equal(subscriptionsOf('child').length, 0);
-    assert.equal(subscribersOf('parent').length, 0);
-});
-test('artifact metadata does not alter a SQL node', () => {
-    createNode(node('a'));
-    writeFileSync(nodeMetaPath('a'), JSON.stringify({ node_id: 'a', kind: 'other' }));
-    assert.equal(getNode('a')?.kind, 'general');
-});
-test('corrupt artifact metadata does not make a SQL node unreadable', () => {
-    createNode(node('a'));
-    writeFileSync(nodeMetaPath('a'), '{ broken json');
-    assert.equal(getNode('a')?.node_id, 'a');
-});
-test('deleting the database does not rebuild nodes from artifact directories', () => {
-    createNode(node('a', { parent: null }));
-    createNode(node('b', { parent: 'a' }));
-    closeDb();
-    rmSync(join(home, 'canvas.db'), { force: true });
-    rmSync(join(home, 'canvas.db-wal'), { force: true });
-    rmSync(join(home, 'canvas.db-shm'), { force: true });
-    migrate(openDb());
-    assert.equal(getRow('a'), null);
-    assert.equal(getRow('b'), null);
-});

package/dist/core/__tests__/child-death-wake.test.d.ts

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