@north-light/crouter 0.3.173 → 0.3.175

package/dist/core/canvas/__tests__/remote-event-stream.test.js

@@ -1,146 +0,0 @@
-// remote-event-stream.test.ts — `RemoteEventStream` (`../remote-event-stream.ts`),
-// a manual SSE client over `/__crtr/events`. Covers the wire parse (only
-// known `kind`s fire listeners; comments/pings/unknown kinds are silently
-// ignored) and that `stop()` actually halts the reconnect loop rather than
-// leaving it retrying forever in the background.
-//
-// Reconnect/backoff timing uses an INJECTABLE backoff (`RemoteEventStreamOptions`)
-// so these tests run against a small, fast backoff window instead of the
-// production 1s→30s one, and every wait is a condition-poll on an observed
-// request/event count (`waitFor`) rather than a fixed wall-clock sleep —
-// less flaky under scheduler variance, and fast.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createServer } from 'node:http';
-import { RemoteEventStream } from '../remote-event-stream.js';
-function startSseServer(onRequest) {
-    return new Promise((resolve) => {
-        let hits = 0;
-        const requests = [];
-        const server = createServer((req, res) => {
-            hits += 1;
-            requests.push({ method: req.method, url: req.url ?? '', headers: req.headers });
-            onRequest(res, req);
-        });
-        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}`,
-                hitCount: () => hits,
-                requests,
-                close: () => new Promise((res) => server.close(() => res())),
-            });
-        });
-    });
-}
-/** Poll `predicate` until it's true, or throw after `timeoutMs` — used in
- *  place of a fixed sleep so tests assert on the OBSERVED condition (a
- *  request landed, an event fired) rather than a guessed timing window. */
-async function waitFor(predicate, timeoutMs = 2000, intervalMs = 5) {
-    const deadline = Date.now() + timeoutMs;
-    while (!predicate()) {
-        if (Date.now() > deadline)
-            throw new Error(`waitFor: condition not met within ${timeoutMs}ms`);
-        await new Promise((r) => setTimeout(r, intervalMs));
-    }
-}
-test('a listener fires once per known-kind SSE event, and never for a ping or an unknown kind', async (t) => {
-    const server = await startSseServer((res) => {
-        res.writeHead(200, { 'content-type': 'text/event-stream' });
-        res.write(': connected\n\n');
-        res.write('data: {"kind":"nodes"}\n\n');
-        res.write(': ping\n\n');
-        res.write('data: {"kind":"bogus"}\n\n');
-        res.end();
-    });
-    const stream = new RemoteEventStream(server.url, 'tok');
-    // Register cleanup BEFORE any assertion runs — a thrown assertion must not
-    // leave the client's reconnect loop or the server's listening socket alive
-    // (see the CI-hang postmortem on rebuild-coalescer.test.ts).
-    t.after(() => { stream.stop(); return server.close(); });
-    const seen = [];
-    stream.subscribe((kind) => seen.push(kind));
-    stream.start();
-    await waitFor(() => seen.length > 0);
-    stream.stop();
-    assert.deepEqual(seen, ['nodes']);
-});
-test('the SSE connection carries the token ONLY in the Authorization header — not in the URL or any other header', async (t) => {
-    const server = await startSseServer((res) => {
-        res.writeHead(200, { 'content-type': 'text/event-stream' });
-        res.end();
-    });
-    // A token that cannot collide with a hostname/port (unlike 'tok', which is a
-    // substring of numeric-looking noise) so a pass here can't be a coincidence —
-    // no header, including Host, is permitted to carry it.
-    const token = 'secret-sse-token-value';
-    const stream = new RemoteEventStream(server.url, token);
-    t.after(() => { stream.stop(); return server.close(); });
-    stream.start();
-    await waitFor(() => server.requests.length > 0);
-    stream.stop();
-    assert.equal(server.requests.length, 1);
-    const req = server.requests[0];
-    assert.equal(req.method, 'GET');
-    assert.equal(req.url, '/__crtr/events');
-    assert.equal(req.headers['authorization'], `Bearer ${token}`);
-    for (const [k, v] of Object.entries(req.headers)) {
-        if (k.toLowerCase() === 'authorization')
-            continue;
-        assert.ok(!String(v).includes(token), `header ${k} must not carry the token`);
-    }
-    assert.ok(!req.url.includes(token));
-});
-test('stop() cancels a pending reconnect timer — no zombie loop survives a stop()+start() cycle', async (t) => {
-    const server = await startSseServer((res) => {
-        res.writeHead(500);
-        res.end();
-    });
-    // A small injected backoff (200ms, not production's 1s) — the test asserts
-    // the SAME relative-timing invariant (a stopped loop's dangling reconnect
-    // timer must not fire) but the deliberate gap below (half the backoff)
-    // between the stale deadline and the new deadline is kept proportionally
-    // wide enough that ordinary event-loop/scheduler jitter can't flip it.
-    const BACKOFF = 200;
-    const stream = new RemoteEventStream(server.url, 'tok', { initialBackoffMs: BACKOFF });
-    t.after(() => { stream.stop(); return server.close(); });
-    stream.start();
-    // t≈0: first request fires+fails, backoff(BACKOFF) scheduled → stale deadline ≈ BACKOFF.
-    await waitFor(() => server.hitCount() >= 1);
-    assert.equal(server.hitCount(), 1);
-    // Deliberate mid-backoff gap (half the window) before stop()+start(), so the
-    // stale deadline (hit1 + BACKOFF) and the new loop's own deadline
-    // (hit2 + BACKOFF) land ~BACKOFF/2 apart — the window this test inspects.
-    await new Promise((r) => setTimeout(r, BACKOFF / 2));
-    stream.stop();
-    stream.start();
-    await waitFor(() => server.hitCount() >= 2);
-    assert.equal(server.hitCount(), 2, 'restart fires its own immediate request');
-    // Wait past the STALE timer's deadline (~BACKOFF from the first request) but
-    // well before the NEW loop's own deadline (~BACKOFF from the second,
-    // later, request). A dangling old-loop timer (bug) would add a 3rd hit in
-    // this window; a cleared one (fixed) leaves it at 2.
-    await new Promise((r) => setTimeout(r, BACKOFF * 0.7));
-    assert.equal(server.hitCount(), 2, "no zombie request from the stopped loop's dangling timer");
-});
-test('stop() halts the reconnect loop — no further requests after it is called', async (t) => {
-    const server = await startSseServer((res) => {
-        // Every connection is refused immediately (no SSE headers, just a close)
-        // so the client's loop falls into its backoff-and-retry path.
-        res.writeHead(500);
-        res.end();
-    });
-    const BACKOFF = 20;
-    const stream = new RemoteEventStream(server.url, 'tok', { initialBackoffMs: BACKOFF });
-    t.after(() => { stream.stop(); return server.close(); });
-    stream.start();
-    await waitFor(() => server.hitCount() >= 1);
-    const hitsAtStop = server.hitCount();
-    stream.stop();
-    // The reconnect backoff is BACKOFF ms; wait well past it and confirm no new
-    // connection was attempted — proves the loop actually stopped rather than
-    // continuing to retry in the background after stop() returned.
-    await new Promise((r) => setTimeout(r, BACKOFF * 5));
-    assert.equal(server.hitCount(), hitsAtStop);
-});

package/dist/core/canvas/__tests__/source-resolve.test.d.ts

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

package/dist/core/canvas/__tests__/source-resolve.test.js

@@ -1,77 +0,0 @@
-// source-resolve.test.ts — `resolveCanvasSource` (`../source.ts`), the
-// --canvas > activeCanvas > local precedence a command's read path goes
-// through. The one invariant worth pinning: the local case returns the SAME
-// `localCanvasSource` singleton by identity, not a structurally-equal copy —
-// callers that hold onto a source reference (e.g. `canvas browse`'s
-// `instanceof RemoteCanvasSource` checks) depend on that.
-import { test, before, after, beforeEach } 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 { resolveCanvasSource, localCanvasSource } from '../source.js';
-import { RemoteCanvasSource } from '../remote-canvas-source.js';
-import { updateConfig, updateState } from '../../config.js';
-import { setRelayToken } from '../../secrets.js';
-let home;
-let realHome;
-before(() => {
-    realHome = process.env['HOME'];
-    home = mkdtempSync(join(tmpdir(), 'crtr-source-resolve-'));
-    process.env['HOME'] = home;
-});
-beforeEach(() => {
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    if (realHome !== undefined)
-        process.env['HOME'] = realHome;
-    else
-        delete process.env['HOME'];
-});
-test('no --canvas and no activeCanvas resolves to the local singleton by identity', () => {
-    const source = resolveCanvasSource();
-    assert.equal(source, localCanvasSource);
-});
-test('an explicit canvasName wins over local, even with no activeCanvas set', () => {
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['cloud'] = { previewEndpoint: 'https://x.preview.bl.run', relayTokenRef: 'cloud' };
-    });
-    setRelayToken('cloud', 'tok', 'user');
-    const source = resolveCanvasSource({ canvasName: 'cloud' });
-    assert.ok(source instanceof RemoteCanvasSource);
-    assert.notEqual(source, localCanvasSource);
-});
-test('the durable activeCanvas selection is honored when no explicit canvasName is passed', () => {
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['cloud'] = { previewEndpoint: 'https://x.preview.bl.run', relayTokenRef: 'cloud' };
-    });
-    setRelayToken('cloud', 'tok', 'user');
-    updateState('user', (s) => {
-        s.activeCanvas = 'cloud';
-    });
-    const source = resolveCanvasSource();
-    assert.ok(source instanceof RemoteCanvasSource);
-});
-test('an explicit --canvas wins over a different durable activeCanvas selection', () => {
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['cloud-a'] = { previewEndpoint: 'https://a.preview.bl.run', relayTokenRef: 'cloud-a' };
-        cfg.remoteCanvas.targets['cloud-b'] = { previewEndpoint: 'https://b.preview.bl.run', relayTokenRef: 'cloud-b' };
-    });
-    setRelayToken('cloud-a', 'tok-a', 'user');
-    setRelayToken('cloud-b', 'tok-b', 'user');
-    updateState('user', (s) => {
-        s.activeCanvas = 'cloud-a';
-    });
-    const source = resolveCanvasSource({ canvasName: 'cloud-b' });
-    assert.ok(source instanceof RemoteCanvasSource);
-    assert.equal(source.previewEndpoint, 'https://b.preview.bl.run');
-});
-test('activeCanvas set to null (explicit local) falls back to the local singleton', () => {
-    updateState('user', (s) => {
-        s.activeCanvas = null;
-    });
-    const source = resolveCanvasSource();
-    assert.equal(source, localCanvasSource);
-});

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

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

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

@@ -1,290 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { buildTree, flatten, fuzzyMatch, pruneNode, tabPredicate, TABS, attentionTier, attentionMtime } from '../model.js';
-// ── Fixture canvas ───────────────────────────────────────────────────────────
-//   root1 (active)            ← rank 0
-//     child-a (idle)
-//       grand-x (done)
-//     child-b (active, ⚑2)
-//   root2 (done)              ← rank 2 (dormant root, but ancestor of a live node)
-//     child-c (active)
-//   lonely (idle)             ← straggler: in rows, no edge reaches it, not a root
-function row(node_id, name, status, asks = 0) {
-    return { node_id, name, status, kind: 'general', mode: 'base', ctx_tokens: 0, asks, cwd: '/tmp/proj', created: '2026-01-01T00:00:00.000Z' };
-}
-function lrow(node_id, name, status, lifecycle) {
-    return { ...row(node_id, name, status), lifecycle };
-}
-const ROWS = [
-    row('root1', 'root-one', 'active'),
-    row('child-a', 'child-a', 'idle'),
-    row('grand-x', 'grand-x', 'done'),
-    row('child-b', 'child-b', 'active', 2),
-    row('root2', 'root-two', 'done'),
-    row('child-c', 'child-c', 'active'),
-    row('lonely', 'lonely-node', 'idle'),
-];
-// rootIds intentionally unsorted to prove buildTree sorts live-first.
-const ROOT_IDS = ['root2', 'root1'];
-const CHILDREN = {
-    root1: ['child-a', 'child-b'],
-    'child-a': ['grand-x'],
-    root2: ['child-c'],
-};
-const childIdsOf = (id) => CHILDREN[id] ?? [];
-function tree() {
-    return buildTree(ROWS, ROOT_IDS, childIdsOf);
-}
-// ── fuzzyMatch ───────────────────────────────────────────────────────────────
-test('fuzzyMatch: empty query matches everything', () => {
-    assert.equal(fuzzyMatch('', 'whatever'), true);
-});
-test('fuzzyMatch: case-insensitive subsequence', () => {
-    assert.equal(fuzzyMatch('abc', 'aXbXc'), true);
-    assert.equal(fuzzyMatch('AB', 'xaYbz'), true);
-    assert.equal(fuzzyMatch('grandx', 'grand-x'), true);
-});
-test('fuzzyMatch: out-of-order is not a match', () => {
-    assert.equal(fuzzyMatch('abc', 'acb'), false);
-    assert.equal(fuzzyMatch('zz', 'z'), false);
-});
-// ── buildTree ────────────────────────────────────────────────────────────────
-test('buildTree: roots sorted live-first, stragglers appended', () => {
-    const t = tree();
-    assert.deepEqual(t.roots, ['root1', 'root2', 'lonely']);
-});
-test('buildTree: depth, parentId, childIds', () => {
-    const t = tree();
-    assert.equal(t.nodes.size, 7);
-    assert.deepEqual(t.nodes.get('root1'), {
-        row: ROWS[0], depth: 0, parentId: null, childIds: ['child-a', 'child-b'],
-    });
-    assert.equal(t.nodes.get('child-a').depth, 1);
-    assert.equal(t.nodes.get('child-a').parentId, 'root1');
-    assert.deepEqual(t.nodes.get('child-a').childIds, ['grand-x']);
-    assert.equal(t.nodes.get('grand-x').depth, 2);
-    assert.equal(t.nodes.get('grand-x').parentId, 'child-a');
-    // straggler attaches at depth 0 with no parent
-    assert.equal(t.nodes.get('lonely').depth, 0);
-    assert.equal(t.nodes.get('lonely').parentId, null);
-});
-test('buildTree: unknown child ids are dropped (missing meta safe)', () => {
-    const t = buildTree(ROWS, ['root1'], (id) => (id === 'root1' ? ['child-a', 'ghost'] : childIdsOf(id)));
-    assert.deepEqual(t.nodes.get('root1').childIds, ['child-a']);
-    assert.equal(t.nodes.has('ghost'), false);
-});
-// ── pruneNode ────────────────────────────────────────────────────────────────
-// Regression: pressing `x` in canvas browse on an EMPTY active node looked like a
-// no-op — closeNode hard-deletes (reaps) an empty node, but doClose never removed
-// it from the in-memory tree, so the stale active row kept painting. pruneNode is
-// the splice doClose now applies for a reaped (getNode===null) close.
-test('pruneNode: reaping a leaf removes it from its parent and the node map', () => {
-    const t = tree();
-    pruneNode(t, 'grand-x'); // leaf under child-a
-    assert.equal(t.nodes.has('grand-x'), false);
-    assert.deepEqual(t.nodes.get('child-a').childIds, []);
-});
-test('pruneNode: reaping a mid-tree node re-homes its children to its parent', () => {
-    const t = tree();
-    pruneNode(t, 'child-a'); // child-a (under root1) owns grand-x
-    assert.equal(t.nodes.has('child-a'), false);
-    // grand-x lifts into child-a's slot in root1's child order (before child-b).
-    assert.deepEqual(t.nodes.get('root1').childIds, ['grand-x', 'child-b']);
-    assert.equal(t.nodes.get('grand-x').parentId, 'root1');
-});
-test('pruneNode: reaping a root lifts its children into the root list', () => {
-    const t = tree();
-    const rootIdx = t.roots.indexOf('root2');
-    pruneNode(t, 'root2'); // root2 owns child-c
-    assert.equal(t.nodes.has('root2'), false);
-    assert.equal(t.roots.includes('root2'), false);
-    assert.equal(t.roots[rootIdx], 'child-c'); // child-c took root2's slot
-    assert.equal(t.nodes.get('child-c').parentId, null);
-});
-test('pruneNode: absent id is a no-op', () => {
-    const t = tree();
-    const before = t.nodes.size;
-    pruneNode(t, 'ghost');
-    assert.equal(t.nodes.size, before);
-});
-// ── tab predicates ───────────────────────────────────────────────────────────
-test('tabPredicate: All / Live / Dormant / Attention / Pinned', () => {
-    assert.deepEqual([...TABS], ['All', 'Live', 'Dormant', 'Attention', 'Pinned']);
-    const active = ROWS[0]; // root1 active
-    const idle = ROWS[1]; // child-a idle
-    const done = ROWS[2]; // grand-x done
-    const attention = ROWS[3]; // child-b active asks 2
-    assert.equal(tabPredicate('All', done), true);
-    assert.equal(tabPredicate('Live', active), true);
-    assert.equal(tabPredicate('Live', idle), true);
-    assert.equal(tabPredicate('Live', done), false);
-    assert.equal(tabPredicate('Dormant', done), true);
-    assert.equal(tabPredicate('Dormant', active), false);
-    // Attention = pending asks OR a fault.
-    assert.equal(tabPredicate('Attention', attention), true);
-    assert.equal(tabPredicate('Attention', active), false);
-    assert.equal(tabPredicate('Attention', { ...active, asks: 0, hanging: { kind: 'provider' } }), true);
-    // Pinned reads the isPinned arg, not the row.
-    assert.equal(tabPredicate('Pinned', active), false);
-    assert.equal(tabPredicate('Pinned', active, true), true);
-});
-// ── flatten: pins ────────────────────────────────────────────────────────────
-test('flatten: profile scope keeps only the launching profile, with ancestors for context', () => {
-    const profileRows = [
-        { ...row('profile-root', 'profile-root', 'active'), profile_id: 'alpha-11111111' },
-        { ...row('profile-child', 'profile-child', 'idle'), profile_id: 'beta-22222222' },
-        { ...row('other-root', 'other-root', 'active'), profile_id: 'beta-22222222' },
-    ];
-    const t = buildTree(profileRows, ['profile-root', 'other-root'], (id) => id === 'profile-root' ? ['profile-child'] : []);
-    const v = flatten(t, { collapsed: new Set(), tab: 'All', query: '', profileScope: 'alpha-11111111' });
-    assert.deepEqual(v.map((r) => r.id), ['profile-root']);
-    assert.equal(v[0].matched, true);
-});
-test('flatten: Pinned tab shows only pinned rows', () => {
-    const pinned = new Set(['child-c']);
-    const v = flatten(tree(), { collapsed: new Set(), tab: 'Pinned', query: '', pinned });
-    // child-c is directly matched; root2 rides along as its ancestor (context).
-    const matched = v.filter((r) => r.matched).map((r) => r.id);
-    assert.deepEqual(matched, ['child-c']);
-});
-test('flatten: pinned rows float to the top in a flat sort', () => {
-    const pinned = new Set(['lonely']); // an idle straggler that would otherwise sort late
-    const v = flatten(tree(), { collapsed: new Set(), tab: 'All', query: '', sort: 'recency', pinned });
-    assert.equal(v[0].id, 'lonely');
-});
-// ── flatten: collapse / expand ───────────────────────────────────────────────
-const allCollapsed = () => new Set(['root1', 'child-a', 'root2']); // every node with children
-test('flatten: default-collapsed shows only top-level', () => {
-    const v = flatten(tree(), { collapsed: allCollapsed(), tab: 'All', query: '' });
-    assert.deepEqual(v.map((r) => r.id), ['root1', 'root2', 'lonely']);
-    // root1 has children and is collapsed → glyph state
-    assert.equal(v[0].hasChildren, true);
-    assert.equal(v[0].collapsed, true);
-    assert.equal(v[2].hasChildren, false); // lonely is a leaf
-});
-test('flatten: expanding a root reveals its (still-collapsed) children', () => {
-    const collapsed = allCollapsed();
-    collapsed.delete('root1');
-    const v = flatten(tree(), { collapsed, tab: 'All', query: '' });
-    assert.deepEqual(v.map((r) => r.id), ['root1', 'child-a', 'child-b', 'root2', 'lonely']);
-    // child-a still collapsed → grand-x hidden
-    assert.equal(v.find((r) => r.id === 'child-a').collapsed, true);
-});
-test('flatten: fully expanded shows the whole subtree', () => {
-    const collapsed = new Set(); // nothing collapsed
-    const v = flatten(tree(), { collapsed, tab: 'All', query: '' });
-    assert.deepEqual(v.map((r) => r.id), ['root1', 'child-a', 'grand-x', 'child-b', 'root2', 'child-c', 'lonely']);
-});
-// ── flatten: tab filtering + ancestor context ────────────────────────────────
-test('flatten: Live tab dims dormant ancestors, keeps live matches', () => {
-    const v = flatten(tree(), { collapsed: allCollapsed(), tab: 'Live', query: '' });
-    assert.deepEqual(v.map((r) => r.id), ['root1', 'root2', 'lonely']);
-    const byId = Object.fromEntries(v.map((r) => [r.id, r]));
-    assert.equal(byId['root1'].matched, true); // active
-    assert.equal(byId['lonely'].matched, true); // idle
-    assert.equal(byId['root2'].matched, false); // dormant, shown only as ancestor of child-c
-});
-test('flatten: Dormant tab excludes live-only branches', () => {
-    const v = flatten(tree(), { collapsed: new Set(), tab: 'Dormant', query: '' });
-    const ids = v.map((r) => r.id);
-    assert.ok(ids.includes('grand-x')); // done
-    assert.ok(ids.includes('root2')); // done
-    assert.ok(!ids.includes('child-b')); // active → excluded
-    assert.ok(!ids.includes('lonely')); // idle → excluded
-});
-// ── flatten: query auto-expands ancestors of matches ─────────────────────────
-test('flatten: query force-expands ancestors even when collapsed', () => {
-    // Everything collapsed; query targets a deep leaf. Its ancestors must appear.
-    const v = flatten(tree(), { collapsed: allCollapsed(), tab: 'All', query: 'grandx' });
-    assert.deepEqual(v.map((r) => r.id), ['root1', 'child-a', 'grand-x']);
-    const byId = Object.fromEntries(v.map((r) => [r.id, r]));
-    assert.equal(byId['grand-x'].matched, true); // the actual match
-    assert.equal(byId['child-a'].matched, false); // ancestor for context
-    assert.equal(byId['root1'].matched, false); // ancestor for context
-});
-test('flatten: query with no matches yields nothing', () => {
-    const v = flatten(tree(), { collapsed: allCollapsed(), tab: 'All', query: 'zzzznope' });
-    assert.deepEqual(v, []);
-});
-// ── flatten: residentsOnly fold-reveal ───────────────────────────────────────
-//   resident-root → terminal-worker (child) → terminal-grand (grandchild)
-//   resident-only must hide the terminals from the TOP LEVEL + flat search, yet
-//   still reveal them once you expand the resident fold that owns them.
-const RES_ROWS = [
-    lrow('res-root', 'resident-root', 'idle', 'resident'),
-    lrow('term-a', 'worker-a', 'active', 'terminal'),
-    lrow('term-g', 'worker-grand', 'active', 'terminal'),
-    lrow('term-root', 'lone-worker', 'active', 'terminal'), // pure-terminal root
-];
-const RES_CHILDREN = { 'res-root': ['term-a'], 'term-a': ['term-g'] };
-function resTree() {
-    return buildTree(RES_ROWS, ['res-root', 'term-root'], (id) => RES_CHILDREN[id] ?? []);
-}
-test('flatten: residentsOnly hides terminal top-level rows (incl. terminal roots)', () => {
-    // Everything collapsed → only the resident root shows; the lone terminal root
-    // and the worker subtree are hidden at the top level.
-    const v = flatten(resTree(), { collapsed: new Set(['res-root', 'term-a']), tab: 'All', query: '', residentsOnly: true });
-    assert.deepEqual(v.map((r) => r.id), ['res-root']);
-});
-test('flatten: residentsOnly reveals terminal children once their fold is expanded', () => {
-    // Expand the resident root → its terminal worker appears (still collapsed, so
-    // its own terminal grandchild stays hidden).
-    const v1 = flatten(resTree(), { collapsed: new Set(['term-a']), tab: 'All', query: '', residentsOnly: true });
-    assert.deepEqual(v1.map((r) => r.id), ['res-root', 'term-a']);
-    // Expand the worker too → the terminal grandchild is revealed.
-    const v2 = flatten(resTree(), { collapsed: new Set(), tab: 'All', query: '', residentsOnly: true });
-    assert.deepEqual(v2.map((r) => r.id), ['res-root', 'term-a', 'term-g']);
-});
-test('flatten: residentsOnly keeps terminals out of flat (relevance) search results', () => {
-    // A query that matches the workers must not surface them in the flat search —
-    // resident-only de-clutters search even though the fold would reveal them.
-    const v = flatten(resTree(), { collapsed: new Set(), tab: 'All', query: 'worker', residentsOnly: true, sort: 'relevance' });
-    assert.deepEqual(v.map((r) => r.id), []);
-});
-test('flatten: residentsOnly off shows every lifecycle at the top level', () => {
-    // Roots are live-first: term-root (active) ranks ahead of res-root (idle).
-    const v = flatten(resTree(), { collapsed: new Set(['res-root', 'term-a']), tab: 'All', query: '', residentsOnly: false });
-    assert.deepEqual(v.map((r) => r.id), ['term-root', 'res-root']);
-});
-function arow(node_id, status, opts) {
-    return { ...row(node_id, node_id, status), ...opts };
-}
-test('attentionTier: classifies each cheap-field combination', () => {
-    assert.equal(attentionTier(arow('x', 'active', { viewed: true, streaming: true })), 0);
-    assert.equal(attentionTier(arow('x', 'active', { viewed: true })), 1);
-    assert.equal(attentionTier(arow('x', 'active', { streaming: true, viewed: false })), 2);
-    assert.equal(attentionTier(arow('x', 'active', {})), 3);
-    assert.equal(attentionTier(arow('x', 'idle', {})), 3);
-    assert.equal(attentionTier(arow('x', 'done', {})), 4);
-    assert.equal(attentionTier(arow('x', 'dead', {})), 4);
-    assert.equal(attentionTier(arow('x', 'canceled', {})), 4);
-});
-test('attentionMtime: prefers mtimeMs, falls back to created', () => {
-    assert.equal(attentionMtime(arow('x', 'active', { mtimeMs: 1234 })), 1234);
-    // No mtimeMs → epoch-ms of the ISO `created` (fixture is 2026-01-01T00:00:00Z).
-    assert.equal(attentionMtime(arow('x', 'active', {})), Date.parse('2026-01-01T00:00:00.000Z'));
-});
-test('flatten: attention sort tiers rows (attached/streaming/live first)', () => {
-    // One row per tier, deliberately shuffled in input order.
-    const rows = [
-        arow('dormant', 'done', { mtimeMs: 100 }), // T4
-        arow('live', 'active', { mtimeMs: 100 }), // T3
-        arow('streaming', 'active', { streaming: true, mtimeMs: 100 }), // T2
-        arow('attached', 'idle', { viewed: true, mtimeMs: 100 }), // T1
-        arow('both', 'active', { viewed: true, streaming: true, mtimeMs: 100 }), // T0
-    ];
-    const t = buildTree(rows, [], () => []);
-    const v = flatten(t, { collapsed: new Set(), tab: 'All', query: '', sort: 'attention' });
-    assert.deepEqual(v.map((r) => r.id), ['both', 'attached', 'streaming', 'live', 'dormant']);
-});
-test('flatten: attention sort orders newest-message-first WITHIN a tier', () => {
-    // All dormant (T4) → ordering is purely by mtime, newest first.
-    const rows = [
-        arow('old', 'done', { mtimeMs: 1000 }),
-        arow('newest', 'done', { mtimeMs: 3000 }),
-        arow('mid', 'done', { mtimeMs: 2000 }),
-    ];
-    const t = buildTree(rows, [], () => []);
-    const v = flatten(t, { collapsed: new Set(), tab: 'All', query: '', sort: 'attention' });
-    assert.deepEqual(v.map((r) => r.id), ['newest', 'mid', 'old']);
-});

package/dist/core/canvas/browse/__tests__/rebuild-coalescer.test.d.ts

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