lynkeus 0.2.0 → 0.4.0

package/lib/cases/__tests__/format.test.js

@@ -1,61 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { dig, interpolate, matcherOf, matches, parseCase, readCases } from '../format.js';
-const CASE = `---
-id: gift
-title: "A gift shows up"
----
-setup:
-  - create_user: { as: u, name: "Ana" }
-steps:
-  - app.press: "#open"
-  - app.back
-  - assert: { user: u, path: score, equals: 25 }
-expected: |
-  The score is 25.
-`;
-test('a case is its frontmatter, its setup, its steps and what it expects', () => {
-    const c = parseCase(CASE, 'cases/gift.md');
-    assert.equal(c.id, 'gift');
-    assert.deepEqual(c.setup, [{ verb: 'create_user', value: { as: 'u', name: 'Ana' } }]);
-    assert.deepEqual(c.steps.map((s) => s.verb), ['app.press', 'app.back', 'assert']);
-    assert.equal(c.expected, 'The score is 25.');
-});
-test('a file without frontmatter, or a step with two verbs, is refused with its place', () => {
-    assert.throws(() => parseCase('steps: []', 'x.md'), /x\.md: no frontmatter/);
-    assert.throws(() => parseCase('---\nid: x\n---\nsteps:\n  - { a: 1, b: 2 }\n', 'x.md'), /steps\[0\] must be one step/);
-});
-test('a path reads into lists, and a star collects from every element', () => {
-    const json = { accounts: [{ code: 'usd' }, { code: 'eur' }], user: { id: 7 } };
-    assert.equal(dig(json, 'accounts.1.code'), 'eur');
-    assert.deepEqual(dig(json, 'accounts.*.code'), ['usd', 'eur']);
-    assert.equal(dig(json, 'user.name.first'), undefined);
-});
-test('a reference alone keeps its type; inside text it is text; a missing one says which', () => {
-    const scope = { u: { user_id: 7, name: 'Ana' } };
-    assert.deepEqual(interpolate({ id: '{{u.user_id}}', hi: 'hi {{u.name}}', n: 3 }, scope), { id: 7, hi: 'hi Ana', n: 3 });
-    assert.match(interpolate('x{{random.letters}}', scope), /^x[a-z]{6}$/);
-    assert.throws(() => interpolate('{{v.user_id}}', scope), /no alias 'v'/);
-    assert.throws(() => interpolate('{{u.phone}}', scope), /\{\{u\.phone\}\} is empty/);
-});
-test('matchers compare numbers as numbers and lists by any element', () => {
-    assert.equal(matches('25.0', { equals: 25 }), true);
-    assert.equal(matches('abc', { equals: 'abc' }), true);
-    assert.equal(matches(['usd', 'bridge_usd'], { includes: 'bridge' }), true);
-    assert.equal(matches(9, { gte: 10 }), false);
-    assert.equal(matches(null, { absent: true }), true);
-    assert.equal(matches('AUTORIZADO', { matches: '^AUT' }), true);
-    assert.deepEqual(matcherOf({ path: 'a', equals: 1, user: 'u' }), { equals: 1 });
-    assert.equal(matcherOf({ path: 'a' }), undefined);
-});
-test('a case with a matrix runs once per combination, named after it', () => {
-    const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-matrix-')), 'm.md');
-    fs.writeFileSync(file, '---\nid: m\nmatrix: { locale: [en, fr], login: [phone] }\n---\nsteps:\n  - create_user: { locale: "{{matrix.locale}}" }\n');
-    const cases = readCases(file);
-    assert.deepEqual(cases.map((c) => c.id), ['m[locale=en,login=phone]', 'm[locale=fr,login=phone]']);
-    assert.deepEqual(cases[1].setup, []);
-    assert.deepEqual(cases[1].steps[0].value, { locale: 'fr' });
-});

package/lib/cases/__tests__/runner.test.d.ts

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

package/lib/cases/__tests__/runner.test.js

@@ -1,188 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { after, test } from 'node:test';
-import { driveCommands } from '../../commands/drive.js';
-import { osCommands } from '../../commands/os.js';
-import { find, register } from '../../registry.js';
-import { Fixtures } from '../fixtures.js';
-import { parseCase } from '../format.js';
-import { argvFor, newSince, runCase } from '../runner.js';
-import { FIXTURES } from '../templates.js';
-register([...driveCommands, ...osCommands]);
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-cases-'));
-fs.writeFileSync(path.join(root, 'fixtures.mjs'), FIXTURES);
-const fixtures = new Fixtures({ command: 'node fixtures.mjs' }, root);
-after(() => fixtures.close());
-// An app with one button that, pressed, shows the points the fixtures hold.
-const fakeApp = () => {
-    const calls = [];
-    let shown = 'Hello';
-    const screen = () => ({
-        route: 'Profile.Main',
-        path: ['Profile.Main'],
-        commit: 1,
-        busy: false,
-        window: { w: 390, h: 844 },
-        costMs: 1,
-        elements: [
-            { i: 0, kind: 'button', testId: 'refresh', enabled: true, depth: 0, frame: { x: 0, y: 0, w: 100, h: 40 } },
-            { i: 1, kind: 'text', text: shown, enabled: true, depth: 0, frame: { x: 0, y: 50, w: 100, h: 20 } },
-        ],
-    });
-    const server = {
-        connected: true,
-        call: async (method, params) => {
-            calls.push({ method, params });
-            if (method === 'find')
-                return screen().elements.find((e) => e.testId === params.testId) ?? null;
-            return null;
-        },
-    };
-    const device = {
-        server,
-        screen: async () => screen(),
-        trace: async () => ({ last: 0, events: [{ seq: 1, t: 0, kind: 'request', method: 'GET', url: 'http://x/api/points', status: 200 }] }),
-        press: async (params) => {
-            calls.push({ method: 'press', params });
-            shown = '25 points';
-            return { x: 0, y: 0, mode: 'native' };
-        },
-        waitFor: async () => ({ waitedMs: 0 }),
-        idle: async () => ({ settled: true }),
-        command: async (name) => (name === 'events' ? [{ name: 'points_viewed', properties: { points: 25 } }] : {}),
-    };
-    const base = {
-        root,
-        config: {},
-        attached: true,
-        err: () => undefined,
-        graph: () => {
-            throw new Error('no graph');
-        },
-        device: async () => device,
-    };
-    return { base, calls };
-};
-const config = { refs: { user: 'user_id' }, inspect: 'inspect' };
-test('a case prepares the backend, drives the app and reads both', async () => {
-    const c = parseCase(`---
-id: gift
----
-setup:
-  - create_user: { as: u, name: "Ana" }
-steps:
-  - app.see: { text: "Hello" }
-  - give_points: { user: u, points: 25 }
-  - app.press: "#refresh"
-  - app.see: { text: "25 points", request: "GET /api/points", event: points_viewed, props: { points: 25 } }
-  - app.see: { text: "Hello", absent: true }
-  - assert: { user: u, path: points, equals: 25 }
-  - assert: { path: name, equals: "Ana" }
-`, 'gift.md');
-    const { base, calls } = fakeApp();
-    const report = await runCase(c, { base, config, fixtures });
-    assert.deepEqual(report.steps.map((s) => [s.status, s.error]), Array(8).fill(['passed', undefined]));
-    assert.equal(calls.filter((x) => x.method === 'press').length, 1);
-});
-test('the first step that fails stops the case and leaves the evidence', async () => {
-    const c = parseCase('---\nid: red\n---\nsteps:\n  - app.see: { text: "Goodbye", timeoutMs: 200 }\n  - app.press: "#refresh"\n', 'red.md');
-    const { base, calls } = fakeApp();
-    const report = await runCase(c, { base, config, fixtures });
-    assert.equal(report.result, 'failed');
-    assert.deepEqual(report.steps.map((s) => s.status), ['failed', 'skipped']);
-    assert.match(report.steps[0].error, /not on screen: "Goodbye"/);
-    assert.match(report.evidence.screen, /button #refresh/);
-    assert.equal(calls.filter((x) => x.method === 'press').length, 0);
-});
-test('an optional press of something that is not there is skipped, not failed', async () => {
-    const c = parseCase('---\nid: opt\n---\nsteps:\n  - app.press: { target: "#dismiss", optional: true }\n', 'opt.md');
-    const { base } = fakeApp();
-    const device = await base.device();
-    device.waitFor = async () => {
-        throw new Error('Timed out');
-    };
-    const report = await runCase(c, { base, config, fixtures });
-    assert.deepEqual(report.steps.map((s) => s.status), ['skipped']);
-});
-test('a macro is the steps a project gave a name to, with what the case passed', async () => {
-    const c = parseCase('---\nid: m\n---\nsetup:\n  - create_user: { as: u }\nsteps:\n  - app.enter: { as: u, then: "#refresh" }\n  - app.enter: { as: u }\n', 'm.md');
-    const { base, calls } = fakeApp();
-    const macros = {
-        'app.enter': [{ assert: { user_id: '{{param.as.user_id}}', path: 'user_id', matches: '^u_' } }, { when: 'then', do: { 'app.press': '{{param.then}}' } }],
-    };
-    const report = await runCase(c, { base, config: { ...config, macros }, fixtures });
-    assert.equal(report.result, 'passed', JSON.stringify(report.steps));
-    assert.equal(calls.filter((x) => x.method === 'press').length, 1);
-});
-test("a step that is neither the app's nor a declared fixture says so", async () => {
-    const c = parseCase('---\nid: f\n---\nsteps:\n  - teleport: { to: "moon" }\n', 'f.md');
-    const { base } = fakeApp();
-    const report = await runCase(c, { base, config, fixtures });
-    assert.match(report.steps[0].error, /no fixture teleport/);
-});
-test('a step becomes the argv of the command it names', () => {
-    assert.deepEqual(argvFor(find('type'), { text: 'ana', target: '#search', submit: true }), ['type', 'ana', '#search', '--submit']);
-    assert.deepEqual(argvFor(find('wait'), { target: '#row-25', scroll: true, timeoutMs: 9000 }), ['wait', '#row-25', '--scroll', '--timeout', '9000']);
-    assert.deepEqual(argvFor(find('press'), { target: '#like', within: 'hi from Ana' }), ['press', '#like', '--in', 'hi from Ana']);
-    assert.deepEqual(argvFor(find('mock'), { request: 'POST /pay', lost: true, times: 1 }), ['mock', 'POST /pay', '--lost', '--times', '1']);
-    assert.deepEqual(argvFor(find('swipe'), { from: '10,20', to: '10,300', durationMs: 300 }), [
-        'swipe',
-        '--from',
-        '10,20',
-        '--to',
-        '10,300',
-        '--duration',
-        '300',
-    ]);
-    assert.deepEqual(argvFor(find('mock'), 'clear'), ['mock', '--clear']);
-    assert.throws(() => argvFor(find('press'), { target: '#x', sideways: true }), /press has no sideways/);
-});
-test('what a buffer gained is found whichever end it grows from', () => {
-    const a = { name: 'a' };
-    const b = { name: 'b' };
-    const c = { name: 'c' };
-    assert.deepEqual(newSince([a], [a, b, c]), [b, c]);
-    assert.deepEqual(newSince([a], [c, b, a]), [b, c]);
-    assert.deepEqual(newSince([a, b], [a, b]), []);
-    assert.deepEqual(newSince([a, b], [c]), [c]);
-});
-test('a run that asks for events keeps each with the step that caused it', async () => {
-    const c = parseCase('---\nid: ev\n---\nsteps:\n  - app.see: { text: "Hello" }\n  - app.press: "#refresh"\n', 'ev.md');
-    const { base } = fakeApp();
-    const device = await base.device();
-    let buffer = [];
-    device.command = async () => buffer;
-    const press = device.press.bind(device);
-    device.press = async (p) => {
-        buffer = [{ name: 'refreshed', properties: { by: 'button' } }, ...buffer];
-        return press(p);
-    };
-    const report = await runCase(c, { base, config, fixtures, events: true });
-    assert.deepEqual(report.events, [{ name: 'refreshed', props: { by: 'button' }, step: 2, route: 'Profile.Main' }]);
-});
-test('what the app puts in the way of a step is dealt with before it, unless the step is about it', async () => {
-    const { base, calls } = fakeApp();
-    const interruptions = [{ see: '#refresh', unless: 'refresh', do: [{ 'app.press': '#refresh' }] }];
-    const c = parseCase('---\nid: t\n---\nsteps:\n  - app.see: { testId: refresh }\n  - app.see: { text: "25 points" }\n', 't.md');
-    const report = await runCase(c, { base, config: { ...config, interruptions }, fixtures });
-    assert.equal(report.result, 'passed');
-    assert.equal(calls.filter((call) => call.method === 'press').length > 0, true);
-});
-test('a dry run names the step nobody answers and the argument a command does not take', async () => {
-    const { base } = fakeApp();
-    const c = parseCase('---\nid: t\n---\nsteps:\n  - app.teleport: somewhere\n  - app.clock: { sideways: 1 }\n  - app.clock: { advanceMs: 1000 }\n', 't.md');
-    const report = await runCase(c, { base, config, fixtures, dry: true });
-    assert.equal(report.result, 'failed');
-    assert.deepEqual(report.steps.map((s) => s.status), ['failed', 'failed', 'passed']);
-});
-test('a step kept to a device is skipped on a host, and one kept to the host runs there', async () => {
-    const { base, calls } = fakeApp();
-    const c = parseCase('---\nid: t\n---\nsteps:\n  - on: device\n    do:\n      - app.press: "#nowhere"\n  - on: headless\n    do: { app.press: "#refresh" }\n  - app.see: { text: "25 points" }\n', 't.md');
-    assert.equal(c.steps[0].on, 'device');
-    const report = await runCase(c, { base, config, fixtures });
-    assert.equal(report.result, 'passed', JSON.stringify(report.steps));
-    assert.deepEqual(report.steps.map((s) => s.status), ['skipped', 'passed', 'passed']);
-    assert.equal(calls.filter((call) => call.method === 'press').length, 1);
-});

package/lib/knowledge/__tests__/edges.test.d.ts

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

package/lib/knowledge/__tests__/edges.test.js

@@ -1,25 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'node:test';
-import * as edges from '../edges.js';
-test('a sighting is one appended line; reading merges them and compaction keeps one per edge', () => {
-    const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-edges-')), 'edges.jsonl');
-    const store = edges.open(file);
-    assert.equal(store.record({ from: 'B.Main', to: 'C.Main', via: 'next' }), true);
-    assert.equal(store.record({ from: 'A.Main', to: 'B.Main', via: 'open' }), true);
-    assert.equal(store.record({ from: 'B.Main', to: 'C.Main', via: 'next' }), false);
-    assert.equal(fs.readFileSync(file, 'utf8').trim().split('\n').length, 3);
-    assert.deepEqual(edges.load(file).map((e) => [e.from, e.seen]), [
-        ['B.Main', 2],
-        ['A.Main', 1],
-    ]);
-    store.compact();
-    assert.deepEqual(fs
-        .readFileSync(file, 'utf8')
-        .trim()
-        .split('\n')
-        .map((l) => JSON.parse(l).from), ['A.Main', 'B.Main']);
-    assert.equal(edges.prune(file, new Set(['A.Main', 'B.Main'])), 1);
-});

package/lib/knowledge/__tests__/events.test.d.ts

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

package/lib/knowledge/__tests__/events.test.js

@@ -1,39 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'node:test';
-import { runFlow } from '../../flow/runner.js';
-import { eventsFile, normalizeEvents, readEvents } from '../events.js';
-test('an app buffer that says properties reads as props', () => {
-    assert.deepEqual(normalizeEvents([{ name: 'a', properties: { x: 1 } }, { name: 'b', props: { y: 2 } }, { nope: true }]), [
-        { name: 'a', props: { x: 1 } },
-        { name: 'b', props: { y: 2 } },
-    ]);
-});
-test('a run with events keeps each one with the step and route that caused it', async () => {
-    let buffer = [{ name: 'app_opened' }];
-    const routes = ['Checkout.Main', 'Checkout.Confirm'];
-    let step = 0;
-    const device = {
-        server: { connected: true },
-        press: async () => {
-            buffer.push({ name: step === 0 ? 'checkout_started' : 'checkout_confirmed', properties: { step } });
-            step += 1;
-        },
-        screen: async () => ({ route: routes[step - 1], path: [], elements: [], commit: 0, busy: false, window: { w: 1, h: 1 }, costMs: 0 }),
-        command: async (name, params) => {
-            assert.equal(name, 'events');
-            const out = buffer;
-            if (params?.clear)
-                buffer = [];
-            return out;
-        },
-    };
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-events-'));
-    const report = await runFlow({ name: 'checkout', steps: [{ press: { testId: 'start' } }, { press: { testId: 'confirm' } }] }, { device, artifactsRoot: root, events: true });
-    assert.deepEqual(readEvents(eventsFile(report.dir)), [
-        { name: 'checkout_started', props: { step: 0 }, step: 1, route: 'Checkout.Main' },
-        { name: 'checkout_confirmed', props: { step: 1 }, step: 2, route: 'Checkout.Confirm' },
-    ]);
-});

package/lib/knowledge/__tests__/extract.test.d.ts

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

package/lib/knowledge/__tests__/extract.test.js

@@ -1,69 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { Project } from 'ts-morph';
-import { collectImports, screenDeclarations } from '../extract.js';
-const file = (code) => new Project({ useInMemoryFileSystem: true }).createSourceFile('Nav.tsx', code);
-test('JSX screens are found', () => {
-    const decls = screenDeclarations(file(`
-    const Nav = () => <Stack.Navigator><Stack.Screen name="A.Main" component={AMain} /></Stack.Navigator>
-  `));
-    assert.deepEqual(decls, [{ route: 'A.Main', component: 'AMain' }]);
-});
-test('static-config screens are found, with quoted and bare keys', () => {
-    const decls = screenDeclarations(file(`
-    const Tabs = createTabs({ screens: {
-      'Settings.Notifications': { screen: SettingsNotifications, options: { lazy: false } },
-      Settings: { screen: SettingsMain },
-    } })
-  `));
-    assert.deepEqual(decls, [
-        { route: 'Settings.Notifications', component: 'SettingsNotifications' },
-        { route: 'Settings', component: 'SettingsMain' },
-    ]);
-});
-test('a static entry whose screen is a nested navigator call is not a screen', () => {
-    const decls = screenDeclarations(file(`
-    const Root = createStack({ screens: { 'Root.Tabs': { screen: buildRootTabs({ hideFirst: false }) } } })
-  `));
-    assert.deepEqual(decls, []);
-});
-test('an object with a screen key inside a spread still counts', () => {
-    const decls = screenDeclarations(file(`
-    const tabs = { ...(hide ? {} : { 'Settings.Main': { screen: SettingsMain } }) }
-  `));
-    assert.deepEqual(decls, [{ route: 'Settings.Main', component: 'SettingsMain' }]);
-});
-test('navigate params that name a screen are not declarations', () => {
-    const decls = screenDeclarations(file(`
-    navigation.navigate('Root.Tabs', { screen: 'Settings.Main', params: { screen: 'Settings.Main' } })
-    const target = { name: 'Root.Tabs', params: { screen: 'Settings.Main' } }
-  `));
-    assert.deepEqual(decls, []);
-});
-const app = (files) => {
-    const project = new Project({ useInMemoryFileSystem: true });
-    for (const [name, code] of Object.entries(files))
-        project.createSourceFile(`/app/${name}`, code);
-    return (name) => collectImports(project.getSourceFileOrThrow(`/app/${name}`), '/app');
-};
-test('a name imported through a barrel points at the file that defines it', () => {
-    const imports = app({
-        'hooks/useThing.ts': 'const useThing = () => 1\nexport { useThing }',
-        'hooks/useOther.ts': 'export const useOther = () => 2',
-        'hooks/index.ts': "export * from './useThing'\nexport { useOther as useRenamed } from './useOther'",
-        'Screen.tsx': "import { useThing } from './hooks'",
-        'Other.tsx': "import { useRenamed } from './hooks'",
-    });
-    assert.deepEqual(imports('Screen.tsx'), { imports: ['hooks/useThing.ts'], barrels: ['hooks/index.ts'] });
-    assert.deepEqual(imports('Other.tsx'), { imports: ['hooks/useOther.ts'], barrels: ['hooks/index.ts'] });
-});
-test('what cannot be traced to one file stays on the module it was imported from', () => {
-    const imports = app({
-        'hooks/useThing.ts': 'export const useThing = () => 1',
-        'hooks/index.ts': "export * from './useThing'\nexport const here = 1",
-        'Whole.tsx': "import * as hooks from './hooks'",
-        'Local.tsx': "import { here, missing } from './hooks'",
-    });
-    assert.deepEqual(imports('Whole.tsx'), { imports: ['hooks/index.ts'], barrels: [] });
-    assert.deepEqual(imports('Local.tsx'), { imports: ['hooks/index.ts'], barrels: [] });
-});

package/lib/knowledge/__tests__/frontier.test.d.ts

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

package/lib/knowledge/__tests__/frontier.test.js

@@ -1,57 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'node:test';
-import * as frontier from '../frontier.js';
-const tmpFile = () => path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-frontier-')), 'frontier.jsonl');
-test('a place owes what it has not tried', () => {
-    const file = tmpFile();
-    const memory = frontier.open(file);
-    memory.record('Settings.Main', { seen: ['share-button', 'account-button', 'profile-button'], visited: true });
-    memory.record('Settings.Main', { tried: ['share-button'] });
-    const [row] = frontier.load(file);
-    assert.deepEqual(row?.tried, ['share-button']);
-    assert.deepEqual(row?.left, ['account-button', 'profile-button']);
-    assert.deepEqual(memory.tried('Settings.Main'), ['share-button']);
-});
-test('a place with nothing left is not offered again', () => {
-    const memory = frontier.open(tmpFile());
-    memory.record('Settings.Main', { seen: ['a'], visited: true });
-    memory.record('Profile.Main', { seen: ['b', 'c'], visited: true });
-    memory.record('Settings.Main', { tried: ['a'] });
-    assert.deepEqual(memory.unfinished(), ['Profile.Main']);
-});
-test('a place only ever seen from outside owes a first visit, before any remainder', () => {
-    const memory = frontier.open(tmpFile());
-    memory.record('Settings.Main', { seen: ['a', 'b', 'c'], visited: true });
-    memory.record('Settings.Main', { tried: ['a'] });
-    memory.record('Profile.Edit', {});
-    assert.deepEqual(memory.unfinished(), ['Profile.Edit', 'Settings.Main']);
-});
-test('a layer is a place of its own', () => {
-    const memory = frontier.open(tmpFile());
-    memory.record('Settings.Main#account-button', { seen: ['nested-button'], visited: true });
-    memory.record('Settings.Main', { seen: ['account-button'], tried: ['account-button'], visited: true });
-    assert.deepEqual(memory.unfinished(), ['Settings.Main#account-button']);
-});
-test('a run appends as it goes and compacts to one sorted line per place', () => {
-    const file = tmpFile();
-    const memory = frontier.open(file);
-    memory.record('Settings.Main', { seen: ['a', 'b'], visited: true });
-    memory.record('Settings.Main', { tried: ['a'] });
-    memory.record('Account.Main', { seen: ['c'] });
-    assert.equal(fs.readFileSync(file, 'utf8').trim().split('\n').length, 3);
-    assert.deepEqual(frontier.open(file).tried('Settings.Main'), ['a']);
-    memory.compact();
-    const lines = fs.readFileSync(file, 'utf8').trim().split('\n');
-    assert.deepEqual(lines.map((l) => JSON.parse(l).node), ['Account.Main', 'Settings.Main']);
-});
-test('a deleted screen takes its unfinished controls with it', () => {
-    const file = tmpFile();
-    const memory = frontier.open(file);
-    memory.record('Settings.Main', { seen: ['a'], visited: true });
-    memory.record('Gone.Screen#sheet', { seen: ['b'], visited: true });
-    assert.equal(frontier.prune(file, new Set(['Settings.Main'])), 1);
-    assert.deepEqual(frontier.load(file).map((r) => r.node), ['Settings.Main']);
-});

package/lib/knowledge/__tests__/funnels.test.d.ts

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

package/lib/knowledge/__tests__/funnels.test.js

@@ -1,40 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { checkFunnel, diffEvents, funnelCoverage } from '../funnels.js';
-const signup = {
-    name: 'signup',
-    steps: [
-        { event: 'signup_started', props: { source: 'string', step: 'number' } },
-        { event: 'signup_completed', props: { method: 'email' } },
-    ],
-};
-test('a run that produced every step in order, with the right shapes, passes', () => {
-    const result = checkFunnel(signup, [
-        { name: 'app_opened', step: 1 },
-        { name: 'signup_started', props: { source: 'ad', step: 2 }, step: 2 },
-        { name: 'signup_completed', props: { method: 'email' }, step: 4 },
-    ]);
-    assert.equal(result.ok, true);
-    assert.deepEqual(result.steps.map((s) => s.at), [2, 4]);
-});
-test('a missing step, a step out of order and a property of the wrong type each say so', () => {
-    assert.equal(checkFunnel(signup, [{ name: 'signup_started', props: { source: 'ad', step: 2 } }]).steps[1]?.problem, 'never happened');
-    assert.equal(checkFunnel(signup, [
-        { name: 'signup_completed', props: { method: 'email' } },
-        { name: 'signup_started', props: { source: 'ad', step: 2 } },
-    ]).steps[1]?.problem, 'happened, but before the step it should follow');
-    assert.equal(checkFunnel(signup, [
-        { name: 'signup_started', props: { source: 'ad', step: '2' } },
-        { name: 'signup_completed', props: { method: 'phone' } },
-    ])
-        .steps.map((s) => s.problem)
-        .join(' | '), 'step is string, the funnel needs number | method is "phone", the funnel filters on "email"');
-});
-test('between two builds: an event that appeared, one that was lost, one whose properties changed', () => {
-    const diff = diffEvents([{ name: 'a', props: { step: 1 } }, { name: 'gone' }], [{ name: 'a', props: { step: '1', ref: 'x' } }, { name: 'new' }]);
-    assert.deepEqual(diff, { added: ['new'], lost: ['gone'], changed: [{ event: 'a', changes: ['+ref', 'step number→string'] }] });
-});
-test('coverage names the funnel steps no run produces', () => {
-    const coverage = funnelCoverage([signup], [{ run: 'signup/1', events: [{ name: 'signup_started' }] }]);
-    assert.deepEqual(coverage[0]?.steps.map((s) => s.runs.length), [1, 0]);
-});

package/lib/knowledge/__tests__/lint.test.d.ts

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

package/lib/knowledge/__tests__/lint.test.js

@@ -1,53 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { lintScreen } from '../lint.js';
-const screen = (elements) => ({
-    path: ['Root'],
-    commit: 1,
-    busy: false,
-    window: { w: 390, h: 844 },
-    costMs: 1,
-    elements: elements.map((e, i) => ({ i, kind: 'view', frame: { x: 0, y: 0, w: 100, h: 50 }, enabled: true, depth: 0, ...e })),
-});
-test('an unlabeled button is flagged', () => {
-    const f = lintScreen(screen([{ kind: 'button' }]));
-    assert.equal(f.filter((x) => x.rule === 'unlabeled-control').length, 1);
-});
-test('a labeled button is not', () => {
-    const f = lintScreen(screen([{ kind: 'button', testId: 'ok' }]));
-    assert.equal(f.filter((x) => x.rule === 'unlabeled-control').length, 0);
-});
-test('an icon-only small target warns, a labeled one (a tab item) is info', () => {
-    const f = lintScreen(screen([
-        { kind: 'button', testId: 'icon', frame: { x: 0, y: 0, w: 24, h: 24 } },
-        { kind: 'button', testId: 'tab', text: 'HOME', frame: { x: 0, y: 0, w: 26, h: 16 } },
-    ]));
-    const small = f.filter((x) => x.rule === 'small-target');
-    assert.equal(small.find((x) => x.message.includes('icon'))?.severity, 'warn');
-    assert.equal(small.find((x) => x.message.includes('tab'))?.severity, 'info');
-});
-test('an untranslated i18n key is flagged, real copy is not', () => {
-    const f = lintScreen(screen([
-        { kind: 'text', text: 'profile.settings.title' },
-        { kind: 'text', text: 'Settings' },
-    ]));
-    assert.equal(f.filter((x) => x.rule === 'untranslated').length, 1);
-});
-test('the theme-[object Object] duplicate testId is caught', () => {
-    const f = lintScreen(screen([
-        { kind: 'button', testId: 'theme-[object Object]-radio', frame: { x: 0, y: 0, w: 24, h: 24 } },
-        { kind: 'button', testId: 'theme-[object Object]-radio', frame: { x: 0, y: 100, w: 24, h: 24 } },
-    ]));
-    assert.equal(f.filter((x) => x.rule === 'duplicate-testid').length, 1);
-});
-test('a covered interactive element is info, a covered view is nothing', () => {
-    const f = lintScreen(screen([
-        { kind: 'button', testId: 'under', covered: true },
-        { kind: 'view', covered: true },
-    ]));
-    assert.equal(f.filter((x) => x.rule === 'covered-control').length, 1);
-});
-test('an element drawn past the window is flagged', () => {
-    const f = lintScreen(screen([{ kind: 'text', text: 'wide', frame: { x: 300, y: 0, w: 200, h: 20 } }]));
-    assert.equal(f.filter((x) => x.rule === 'offscreen').length, 1);
-});

package/lib/knowledge/__tests__/perf.test.d.ts

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

package/lib/knowledge/__tests__/perf.test.js

@@ -1,34 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { summarize, visitsFrom } from '../perf.js';
-const ev = (partial, seq) => ({ seq, ...partial });
-const trace = [
-    ev({ kind: 'route', route: 'First.Main', path: ['First.Main'], t: 1000 }, 1),
-    ev({ kind: 'request', method: 'GET', url: 'http://x/api/a', status: 200, ms: 120, t: 1130 }, 2),
-    ev({ kind: 'request', method: 'GET', url: 'http://x/api/b?limit=100', status: 500, ms: 900, t: 1920 }, 3),
-    // Polling long after arrival is not part of what the screen cost to open.
-    ev({ kind: 'request', method: 'GET', url: 'http://x/api/a', status: 200, ms: 50, t: 4000 }, 8),
-    ev({ kind: 'stall', renders: 50, windowMs: 100, t: 1500 }, 4),
-    ev({ kind: 'route', route: 'Second.Main', path: ['Second.Main'], t: 5000 }, 5),
-    ev({ kind: 'request', method: 'GET', url: 'http://x/api/c', status: 200, ms: 40, t: 5045 }, 6),
-    ev({ kind: 'command', method: 'press', ms: 5, t: 5100 }, 7),
-];
-test('a visit counts its requests, errors, stalls and when it went quiet', () => {
-    const [home, pay] = visitsFrom(trace);
-    assert.equal(home.route, 'First.Main');
-    assert.equal(home.requests, 3);
-    assert.equal(home.errors, 1);
-    assert.equal(home.stalls, 1);
-    assert.equal(home.quietAfterMs, 920); // the 900 ms request ended at +920; the poll at +3950 came after a quiet gap
-    assert.deepEqual(home.slowest, { method: 'GET', path: '/api/b?limit=100', ms: 900 });
-    assert.equal(home.ms, 4000);
-    assert.equal(pay.requests, 1);
-});
-test('the summary averages per route and puts the slowest screen first', () => {
-    const s = summarize(visitsFrom(trace));
-    assert.deepEqual(s.map((r) => r.route), ['First.Main', 'Second.Main']);
-    assert.equal(s[0].quietAfterMs, 920);
-});
-test('events before any route are ignored', () => {
-    assert.deepEqual(visitsFrom([ev({ kind: 'request', method: 'GET', url: 'http://x/a', ms: 1, t: 1 }, 1)]), []);
-});

package/lib/knowledge/__tests__/plan.test.d.ts

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

package/lib/knowledge/__tests__/plan.test.js

@@ -1,35 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { describePlan, plan } from '../plan.js';
-const graph = (routes) => ({
-    app: 'test',
-    root: '/tmp',
-    extractedAt: '2026-01-01',
-    screens: Object.fromEntries(routes.map((route) => [route, { route, component: route, file: null, declaredIn: 'nav.tsx' }])),
-    files: {},
-    warnings: [],
-});
-const edge = (e) => ({ seen: 1, last: '2026-01-01', ...e });
-test('a sheet is a place the directions can reach', () => {
-    const steps = plan(graph(['Settings.Main', 'Account.Delete']), 'Settings.Main', 'Account.Delete', [
-        edge({ from: 'Settings.Main', to: 'Settings.Main', via: 'account-button', toLayer: 'account-button' }),
-        edge({ from: 'Settings.Main', to: 'Account.Delete', via: 'delete-account-button', fromLayer: 'account-button' }),
-    ]);
-    assert.deepEqual(steps?.map((s) => [s.from, s.press, s.to]), [
-        ['Settings.Main', 'account-button', 'Settings.Main#account-button'],
-        ['Settings.Main#account-button', 'delete-account-button', 'Account.Delete'],
-    ]);
-    assert.match(describePlan(steps), /opens a layer/);
-});
-test('what a screen offers does not apply while a sheet covers it', () => {
-    const steps = plan(graph(['Settings.Main', 'Profile.Edit']), 'Settings.Main#account-button', 'Profile.Edit', [
-        edge({ from: 'Settings.Main', to: 'Profile.Edit', via: 'profile-button' }),
-    ]);
-    assert.equal(steps, null);
-});
-test('asking for a route accepts arriving with something open over it', () => {
-    const steps = plan(graph(['Settings.Main', 'Checkout.Main']), 'Settings.Main', 'Checkout.Main', [
-        edge({ from: 'Settings.Main', to: 'Checkout.Main', via: 'send-button', toLayer: 'send-button' }),
-    ]);
-    assert.deepEqual(steps?.map((s) => s.to), ['Checkout.Main#send-button']);
-});

package/lib/knowledge/__tests__/query.test.d.ts

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