lynkeus 0.2.0 → 0.3.0

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

@@ -1,30 +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 { diffGeometry, record } from '../screens.js';
-const f = (x, y, w, h) => ({ x, y, w, h });
-test('drift within the tolerance is not a change', () => {
-    assert.deepEqual(diffGeometry({ a: f(10, 10, 100, 40) }, { a: f(12, 8, 102, 41) }), []);
-});
-test('a move past the tolerance is reported with both positions', () => {
-    assert.deepEqual(diffGeometry({ a: f(10, 10, 100, 40) }, { a: f(10, 60, 100, 40) }), ['#a moved (10,10)→(10,60)']);
-});
-test('a resize is reported', () => {
-    assert.deepEqual(diffGeometry({ a: f(0, 0, 100, 40) }, { a: f(0, 0, 100, 80) }), ['#a resized 100×40→100×80']);
-});
-test('an element that collapsed to zero is named as such', () => {
-    assert.deepEqual(diffGeometry({ a: f(0, 0, 100, 40) }, { a: f(0, 0, 100, 0) }), ['#a collapsed to 100×0 (was 100×40)']);
-});
-test('elements only on one side are not geometry changes', () => {
-    assert.deepEqual(diffGeometry({ a: f(0, 0, 1, 1) }, { b: f(0, 0, 1, 1) }), []);
-});
-test('a recorded screen keeps what is presented, not what another tab or a covered screen holds', () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-screens-'));
-    const el = (i, testId, hidden) => ({ i, kind: 'button', frame: f(0, i * 50, 100, 40), enabled: true, depth: 0, testId, hidden });
-    const screen = (elements) => ({ route: 'Settings.Main', path: ['Settings.Main'], commit: 1, busy: false, window: { w: 390, h: 844 }, costMs: 1, elements });
-    record(dir, screen([el(0, 'save'), el(1, 'other-tab', 'a11y'), el(2, 'slide', 'inert')]));
-    const change = record(dir, screen([el(0, 'save'), el(2, 'slide', 'inert')]));
-    assert.equal(change, null);
-});

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

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

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

@@ -1,28 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { explain } from '../why.js';
-const el = (p, i) => ({ i, kind: 'button', frame: { x: 0, y: 0, w: 10, h: 10 }, enabled: true, depth: 1, tag: i + 1, ...p });
-const screen = (elements, route) => ({ route, path: route ? [route] : [], elements, commit: 5, costMs: 1 });
-const req = (status, url, error) => ({ id: 1, method: 'GET', url, status, startedAt: 0, ms: 10, error });
-const rules = (f) => f.map((x) => x.rule);
-test('a dead navigator and a gone session are named', () => {
-    assert.deepEqual(rules(explain({ screen: screen([]), requests: [], inFlight: 0 })), ['dead-navigator']);
-    assert.ok(rules(explain({ screen: screen([el({}, 0)], 'Home'), requests: [req(401, 'http://x/a'), req(401, 'http://x/b')], inFlight: 0 })).includes('session-gone'));
-});
-test('a covered target, a near text and a capped list', () => {
-    const s = screen([el({ testId: 'submit', covered: true }, 0), el({ kind: 'text', text: 'Café Ünïcode wörks here' }, 1)], 'Home');
-    assert.ok(rules(explain({ screen: s, requests: [], inFlight: 0, target: { testId: 'submit' } })).includes('covered'));
-    assert.ok(rules(explain({ screen: s, requests: [], inFlight: 0, target: { text: 'Cafe Unicode works here' } })).includes('near-match'));
-    assert.ok(rules(explain({ screen: s, requests: [], inFlight: 0, target: { text: 'cafe unicode works here' } })).includes('near-match'));
-    assert.ok(!rules(explain({ screen: s, requests: [], inFlight: 0, target: { text: 'A completely different sentence' } })).includes('near-match'));
-    const list = screen(Array.from({ length: 12 }, (_, i) => el({ testId: `row-${i}-item`, text: `Item${i}` }, i)), 'Search');
-    assert.ok(rules(explain({ screen: list, requests: [req(200, 'http://x/search')], inFlight: 0, target: { text: 'itemabc' } })).includes('capped-list'));
-});
-test('backend and loading conditions', () => {
-    const s = screen([el({}, 0)], 'Home');
-    assert.ok(rules(explain({ screen: s, requests: [req(500, 'http://x/api/a')], inFlight: 0 })).includes('backend-error'));
-    assert.ok(rules(explain({ screen: s, requests: [req(200, 'http://x/a')], inFlight: 2, target: { testId: 'x' } })).includes('in-flight'));
-    const stall = { seq: 1, t: 1, kind: 'stall', renders: 2000, windowMs: 3000, component: 'Feed' };
-    assert.ok(rules(explain({ screen: s, requests: [], inFlight: 0, trace: [stall] })).includes('render-loop'));
-    assert.deepEqual(rules(explain({ screen: s, requests: [req(200, 'http://x/a')], inFlight: 0 })), []);
-});

package/src/__tests__/args.test.ts

@@ -1,82 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import { pairs, parseArgs, splitLine, UsageError } from '../args.js';
-import { driveCommands } from '../commands/drive.js';
-import { headlessCommands } from '../commands/headless.js';
-import { mapCommands } from '../commands/map.js';
-import { osCommands } from '../commands/os.js';
-import { runsCommands } from '../commands/runs.js';
-
-const FLAGS = {
-  direct: { type: 'boolean' as const, help: '' },
-  depth: { type: 'number' as const, help: '', default: 4 },
-  var: { type: 'list' as const, help: '' },
-  out: { type: 'string' as const, help: '' },
-};
-
-test('booleans never eat the next positional; numbers are numbers; lists collect', () => {
-  const p = parseArgs(
-    ['--direct', 'a.ts', 'b.ts', '--depth', '2', '--var', 'x=1', '--var', 'y=2'],
-    [{ name: 'file', help: '', required: true, rest: true }],
-    FLAGS,
-  );
-  assert.deepEqual(p.args, ['a.ts', 'b.ts']);
-  assert.equal(p.flags.direct, true);
-  assert.equal(p.flags.depth, 2);
-  assert.deepEqual(p.flags.var, ['x=1', 'y=2']);
-  assert.deepEqual(pairs(p.flags.var as string[]), { x: '1', y: '2' });
-});
-
-test('defaults, --no-flag, --flag=value and passthrough after --', () => {
-  const p = parseArgs(['--no-direct', '--out=x.json', '--', '--jest-flag'], [], FLAGS);
-  assert.equal(p.flags.direct, false);
-  assert.equal(p.flags.depth, 4);
-  assert.equal(p.flags.out, 'x.json');
-  assert.deepEqual(p.passthrough, ['--jest-flag']);
-});
-
-test('unknown flags, missing values and missing positionals are usage errors that name what exists', () => {
-  assert.throws(
-    () => parseArgs(['--nope'], [], FLAGS),
-    (e: unknown) => e instanceof UsageError && /--direct/.test((e as Error).message),
-  );
-  assert.throws(() => parseArgs(['--depth', '--direct'], [], FLAGS), /--depth needs a value/);
-  assert.throws(() => parseArgs(['--depth', 'x'], [], FLAGS), /expects a number/);
-  assert.throws(() => parseArgs([], [{ name: 'target', help: '', required: true }], FLAGS), /missing <target>/);
-  assert.throws(() => parseArgs(['a', 'b'], [{ name: 'one', help: '' }], FLAGS), /unexpected argument "b"/);
-});
-
-test('a session line splits on spaces and keeps quoted text together', () => {
-  assert.deepEqual(splitLine('press "Comenzar ya" --hold 200'), ['press', 'Comenzar ya', '--hold', '200']);
-});
-
-test('every command is named once, documented, and its aliases are unique', () => {
-  const all = [...driveCommands, ...osCommands, ...mapCommands, ...runsCommands, ...headlessCommands];
-  const names = new Set<string>();
-  for (const c of all) {
-    assert.ok(c.summary.length > 10, `${c.name} has a summary`);
-    assert.ok(!names.has(c.name), `${c.name} defined once`);
-    names.add(c.name);
-    for (const a of c.aliases ?? []) {
-      assert.ok(!names.has(a), `${a} unique`);
-      names.add(a);
-    }
-    for (const [flag, spec] of Object.entries(c.flags ?? {})) assert.ok(spec.help, `${c.name} --${flag} has help`);
-    for (const p of c.positionals ?? []) assert.ok(p.help, `${c.name} <${p.name}> has help`);
-  }
-  for (const short of ['plan', 'deeplink', 'appstate', 'network', 'clock', 'biometrics', 'scan', 'gallery', 'headless'])
-    assert.ok(names.has(short), `${short} accepted`);
-});
-
-test('MCP serves a small core by default and everything else on request', () => {
-  const all = [...driveCommands, ...osCommands, ...mapCommands, ...runsCommands, ...headlessCommands];
-  const core = all.filter((c) => c.mcp === 'core').map((c) => c.name);
-  assert.deepEqual(core.sort(), ['call', 'map plan', 'map show', 'os deeplink', 'press', 'screen', 'type', 'wait', 'why']);
-});
-
-test('what MCP leaves out of a tool is still a flag of the command', () => {
-  for (const c of [...driveCommands, ...osCommands, ...mapCommands, ...runsCommands, ...headlessCommands]) {
-    for (const flag of c.mcpOmit ?? []) assert.ok(c.flags?.[flag], `${c.name} omits --${flag}, which it does not have`);
-  }
-});

package/src/__tests__/check.test.ts

@@ -1,71 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import { diffGraphs, newFindings } from '../commands/check.js';
-import { mapCheckWorkflow } from '../commands/map.js';
-import { summarizeRuns } from '../commands/flake.js';
-import type { FlowReport } from '../flow/types.js';
-import type { ScreenGraph } from '../knowledge/types.js';
-
-const graph = (screens: Record<string, string | null>, files: Record<string, { selectors?: string[]; navigates?: string[] }>): ScreenGraph =>
-  ({
-    app: 'x',
-    root: '/x',
-    extractedAt: '',
-    warnings: [],
-    screens: Object.fromEntries(Object.entries(screens).map(([route, file]) => [route, { route, component: route, file, declaredIn: 'nav.tsx' }])),
-    files: Object.fromEntries(
-      Object.entries(files).map(([file, f]) => [
-        file,
-        {
-          selectors: (f.selectors ?? []).map((id) => ({ id, line: 1 })),
-          navigates: (f.navigates ?? []).map((to) => ({ to, line: 1, confidence: 'static', via: { kind: 'unknown' } })),
-          imports: [],
-        },
-      ]),
-    ),
-  }) as unknown as ScreenGraph;
-
-test('a graph diff names routes, navigations and testIDs that changed', () => {
-  const base = graph({ A: 'a.tsx', B: 'b.tsx' }, { 'a.tsx': { selectors: ['go-b'], navigates: ['B'] }, 'b.tsx': { selectors: ['submit'] } });
-  const head = graph({ A: 'a.tsx', B: 'b.tsx', C: 'c.tsx' }, { 'a.tsx': { selectors: ['go-b', 'go-c'], navigates: ['B', 'C'] }, 'b.tsx': {}, 'c.tsx': {} });
-  const d = diffGraphs(base, head);
-  assert.deepEqual(d.routesAdded, ['C']);
-  assert.deepEqual(d.edgesAdded, [{ from: 'A', to: 'C' }]);
-  assert.deepEqual(d.selectorsAdded, [{ file: 'a.tsx', id: 'go-c' }]);
-  assert.deepEqual(d.selectorsRemoved, [{ file: 'b.tsx', id: 'submit' }]);
-});
-
-test('lint findings already in the baseline are not new', () => {
-  const f1 = { finding: { rule: 'unlabeled-control', severity: 'warn' as const, element: 3, message: 'button without a label' }, testId: 'x' };
-  const f2 = { finding: { rule: 'small-target', severity: 'warn' as const, element: 4, message: '20×20' }, testId: 'y' };
-  const fresh = newFindings({ A: [{ rule: 'unlabeled-control', testId: 'x', message: 'button without a label' }] }, 'A', [f1, f2]);
-  assert.deepEqual(fresh, [f2]);
-});
-
-test('flake runs are summarised by the step and error they died on', () => {
-  const ok = (ms: number): FlowReport => ({ name: 'f', ok: true, totalMs: ms, vars: {}, steps: [{ step: { press: { testId: 'a' } }, ok: true, ms: 1 }] });
-  const bad = (err: string): FlowReport => ({
-    name: 'f',
-    ok: false,
-    totalMs: 900,
-    vars: {},
-    steps: [
-      { step: { press: { testId: 'a' } }, ok: true, ms: 1 },
-      { step: { waitFor: { route: 'A' } }, ok: false, ms: 1, error: err },
-    ],
-  });
-  const s = summarizeRuns([ok(100), bad('Timed out waiting for A (on Z)'), ok(300), bad('Timed out waiting for A (on Y)')]);
-  assert.equal(s.passed, 2);
-  assert.equal(s.failures.length, 1);
-  assert.equal(s.failures[0]!.times, 2);
-  assert.equal(s.failures[0]!.step, 2);
-  assert.match(s.failures[0]!.what, /waitFor/);
-});
-
-test('the map check workflow diffs against the pull request base and keeps one comment', () => {
-  const yml = mapCheckWorkflow(2);
-  assert.match(yml, /lynkeus map check --base origin\/\$\{\{ github\.base_ref \}\} --depth 2/);
-  assert.match(yml, /--edit-last/);
-  assert.match(yml, /pull-requests: write/);
-});

package/src/__tests__/init.test.ts

@@ -1,52 +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 { init } from '../commands/init.js';
-import { explainError } from '../knowledge/errors.js';
-
-const tmpApp = () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-init-'));
-  fs.mkdirSync(path.join(root, 'app'));
-  fs.writeFileSync(path.join(root, 'app', 'App.tsx'), 'export default () => null');
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'demo' }));
-  fs.writeFileSync(
-    path.join(root, 'index.js'),
-    "import { AppRegistry } from 'react-native'\nimport App from './app/App'\n\nAppRegistry.registerComponent('demo', () => App)\n",
-  );
-  return root;
-};
-
-test('init writes an entry that requires the app and refuses non-local backends', () => {
-  const root = tmpApp();
-  const notes = init(root, { entry: 'qa/headless.tsx', apiEnv: 'API_URL', auto: false, force: false });
-  const entry = fs.readFileSync(path.join(root, 'qa/headless.tsx'), 'utf8');
-  assert.match(entry, /require\('\.\.\/app\/App'\)/);
-  assert.match(entry, /process\.env\.API_URL/);
-  assert.match(entry, /installDefaultMocks/);
-  assert.ok(notes.some((n) => n.includes('wrote qa/headless.tsx')));
-  // Second run leaves it alone.
-  const again = init(root, { entry: 'qa/headless.tsx', apiEnv: 'API_URL', auto: false, force: false });
-  assert.ok(again.some((n) => n.includes('left as is')));
-});
-
-test('init --auto adds the mount after the imports, once', () => {
-  const root = tmpApp();
-  init(root, { entry: 'qa/headless.tsx', apiEnv: 'API_URL', auto: true, force: false });
-  init(root, { entry: 'qa/headless.tsx', apiEnv: 'API_URL', auto: true, force: false });
-  const index = fs.readFileSync(path.join(root, 'index.js'), 'utf8');
-  assert.equal(index.split('lynkeus-agent/auto').length, 2);
-  assert.ok(index.indexOf('auto(') < index.indexOf('registerComponent'));
-  assert.ok(index.indexOf("import App from './app/App'") < index.indexOf('lynkeus-agent/auto'));
-});
-
-test('the error catalogue names the module behind a TurboModule crash', () => {
-  const [e] = explainError(
-    "Invariant Violation: TurboModuleRegistry.getEnforcing(...): 'RNCWebView' could not be found. Verify that a module by this name is registered",
-  );
-  assert.ok(e);
-  assert.match(e.cause, /RNCWebView/);
-  assert.equal(explainError('all good').length, 0);
-});

package/src/__tests__/record.test.ts

@@ -1,49 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import { simulatorArgv } from '../commands/device.js';
-import { draftFlow } from '../commands/record.js';
-import type { TraceEvent } from 'lynkeus-protocol';
-
-const ev = (partial: Record<string, unknown>, seq: number): TraceEvent => ({ seq, t: seq * 100, ...partial }) as unknown as TraceEvent;
-
-test('a recording becomes presses with what each one caused', () => {
-  const flow = draftFlow([
-    ev({ kind: 'route', route: 'First.Screen', path: ['First.Screen'] }, 1),
-    ev({ kind: 'touch', x: 10, y: 20, testId: 'primary-button', route: 'First.Screen' }, 2),
-    ev({ kind: 'request', method: 'GET', url: 'http://x/api/items', status: 200, ms: 40 }, 3),
-    ev({ kind: 'route', route: 'Second.Screen', path: ['Second.Screen'] }, 4),
-    ev({ kind: 'touch', x: 10, y: 20, text: 'Second option', route: 'Second.Screen' }, 5),
-    ev({ kind: 'store', store: 'session', changed: { step: { from: 1, to: 2 } } }, 6),
-    ev({ kind: 'touch', x: 5, y: 5, route: 'Second.Screen' }, 7),
-  ]);
-  assert.deepEqual(flow.steps, [
-    { press: { testId: 'primary-button' } },
-    { waitFor: { route: 'Second.Screen', timeoutMs: 10000 } },
-    { note: 'requests: GET /api/items 200' },
-    { press: { text: 'Second option' } },
-    { note: 'stores changed: session.step' },
-    { note: 'touch at 5,5 on Second.Screen hit nothing lynkeus could name' },
-  ]);
-});
-
-test('device subcommands map to simctl and adb', () => {
-  assert.deepEqual(simulatorArgv('ios', 'UDID', 'permissions', ['grant', 'camera'], 'com.example.myapp')[0], {
-    bin: 'xcrun',
-    args: ['simctl', 'privacy', 'UDID', 'grant', 'camera', 'com.example.myapp'],
-  });
-  assert.deepEqual(simulatorArgv('ios', 'UDID', 'appearance', ['dark'])[0]!.args, ['simctl', 'ui', 'UDID', 'appearance', 'dark']);
-  assert.deepEqual(simulatorArgv('ios', 'UDID', 'location', ['-34.6,-58.4'])[0]!.args, ['simctl', 'location', 'UDID', 'set', '-34.6,-58.4']);
-  assert.equal(simulatorArgv('ios', 'UDID', 'language', ['de-DE'], 'com.example.myapp').length, 2);
-  assert.deepEqual(simulatorArgv('android', 'emu', 'permissions', ['grant', 'camera'], 'com.example.myapp')[0]!.args, [
-    '-s',
-    'emu',
-    'shell',
-    'pm',
-    'grant',
-    'com.example.myapp',
-    'android.permission.CAMERA',
-  ]);
-  assert.throws(() => simulatorArgv('ios', 'UDID', 'permissions', ['grant', 'camera']), /--app/);
-  assert.throws(() => simulatorArgv('ios', 'UDID', 'appearance', ['blue']), /light\|dark/);
-});

package/src/__tests__/snapshot.test.ts

@@ -1,51 +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 { PNG } from 'pngjs';
-
-import { comparePng, snapshot } from '../commands/snapshot.js';
-
-const png = (w: number, h: number, paint: (x: number, y: number) => [number, number, number]): Buffer => {
-  const p = new PNG({ width: w, height: h });
-  for (let y = 0; y < h; y++)
-    for (let x = 0; x < w; x++) {
-      const i = (y * w + x) * 4;
-      const [r, g, b] = paint(x, y);
-      p.data[i] = r;
-      p.data[i + 1] = g;
-      p.data[i + 2] = b;
-      p.data[i + 3] = 255;
-    }
-  return PNG.sync.write(p);
-};
-
-test('pixels that moved are counted and painted into a diff', () => {
-  const a = png(10, 10, () => [255, 255, 255]);
-  const b = png(10, 10, (x, y) => (x < 2 && y < 2 ? [0, 0, 0] : [250, 250, 250]));
-  const c = comparePng(a, b);
-  assert.equal(c.different, 4); // the 250 vs 255 shade stays under the channel threshold
-  assert.equal(c.ratio, 0.04);
-  assert.ok(c.diff);
-  const d = PNG.sync.read(c.diff!);
-  assert.deepEqual([d.data[0], d.data[1], d.data[2]], [255, 0, 0]);
-});
-
-test('a first capture is the baseline; a small change matches; a big one writes a diff', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'lynkeus-snap-'));
-  const lynkeusDir = path.join(root, '.lynkeus');
-  const runsDir = path.join(lynkeusDir, 'runs');
-  const white = png(20, 20, () => [255, 255, 255]);
-  assert.equal(snapshot(lynkeusDir, 'card', white, { runsDir }).status, 'baseline');
-  const nearly = png(20, 20, (x, y) => (x === 0 && y === 0 ? [0, 0, 0] : [255, 255, 255]));
-  assert.equal(snapshot(lynkeusDir, 'card', nearly, { runsDir, tolerance: 0.01 }).status, 'match');
-  const half = png(20, 20, (x) => (x < 10 ? [0, 0, 0] : [255, 255, 255]));
-  const r = snapshot(lynkeusDir, 'card', half, { runsDir });
-  assert.equal(r.status, 'mismatch');
-  assert.ok(fs.existsSync(r.diffFile!));
-  assert.equal(snapshot(lynkeusDir, 'card', half, { runsDir, update: true }).status, 'baseline');
-  assert.equal(snapshot(lynkeusDir, 'card', half, { runsDir }).status, 'match');
-  const other = png(30, 20, () => [255, 255, 255]);
-  assert.ok(snapshot(lynkeusDir, 'card', other, { runsDir }).comparison?.sizeMismatch);
-});

package/src/__tests__/targets.test.ts

@@ -1,132 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-
-import type { Screen } from 'lynkeus-protocol';
-
-import { describeScreen } from '../device/driver.js';
-import { parseTarget, scopedTarget } from '../targets.js';
-
-test('a #-prefixed string is a testId', () => {
-  assert.deepEqual(parseTarget('#next-button'), { testId: 'next-button' });
-});
-test('an x,y pair is a point', () => {
-  assert.deepEqual(parseTarget('100,200'), { x: 100, y: 200 });
-});
-test('a bare integer is an index', () => {
-  assert.deepEqual(parseTarget('12'), { i: 12 });
-});
-test('anything else is text', () => {
-  assert.deepEqual(parseTarget('Some label'), { text: 'Some label' });
-});
-test('a testId that contains a comma is still a testId, not a point', () => {
-  assert.deepEqual(parseTarget('#a,b'), { testId: 'a,b' });
-});
-
-test('describeScreen prints the value a QR image carries', () => {
-  const screen = {
-    route: 'X',
-    path: ['X'],
-    commit: 1,
-    busy: false,
-    window: { w: 390, h: 844 },
-    costMs: 1,
-    elements: [{ i: 0, kind: 'image', frame: { x: 0, y: 0, w: 168, h: 169 }, enabled: true, depth: 0, accessibilityLabel: 'qr', value: 'QR-TEST-0001' }],
-  } as unknown as Screen;
-  assert.match(describeScreen(screen), /image .*value="QR-TEST-0001"/);
-});
-test('describeScreen lists a view with a testID and leaves plain layout out', () => {
-  const screen = {
-    route: 'X',
-    path: ['X'],
-    commit: 1,
-    busy: false,
-    window: { w: 390, h: 844 },
-    costMs: 1,
-    elements: [
-      { i: 0, kind: 'view', frame: { x: 0, y: 0, w: 390, h: 844 }, enabled: true, depth: 0 },
-      { i: 1, kind: 'view', frame: { x: 0, y: 0, w: 390, h: 400 }, enabled: true, depth: 1, testId: 'intro-page-advances' },
-    ],
-  } as unknown as Screen;
-  const text = describeScreen(screen);
-  assert.match(text, /view +#intro-page-advances/);
-  assert.doesNotMatch(text, /^0? ?view$/m);
-});
-test('describeScreen leaves out what is not presented, counts it, and lists it with --all', () => {
-  const el = (i: number, over: object) => ({ i, kind: 'button', frame: { x: 0, y: 0, w: 100, h: 40 }, enabled: true, depth: 0, ...over });
-  const screen = {
-    route: 'X',
-    path: ['X'],
-    commit: 7,
-    busy: false,
-    window: { w: 390, h: 844 },
-    costMs: 3,
-    elements: [
-      el(0, { testId: 'tab-a', hidden: 'a11y' }),
-      el(1, { testId: 'behind', hidden: 'behind-overlay' }),
-      el(2, { testId: 'slide', hidden: 'inert' }),
-      el(3, { testId: 'close', enabled: false }),
-    ],
-  } as unknown as Screen;
-  const text = describeScreen(screen);
-  assert.equal(text.split('\n')[0] ?? '', 'X · 2 hidden: 1 a11y, 1 behind-overlay');
-  assert.doesNotMatch(text, /#tab-a|#behind/);
-  assert.match(text, /^button #slide ~inert$/m);
-  assert.match(text, /^button #close !disabled$/m);
-  assert.match(describeScreen(screen, { all: true }), /#behind ~behind-overlay/);
-  assert.match(describeScreen(screen, { frames: true }), /#slide ~inert @50,20$/m);
-  assert.match(describeScreen(screen, { verbose: true }).split('\n')[0] ?? '', /commit=7 3ms/);
-});
-test("describeScreen leaves a button's icon out", () => {
-  const screen = {
-    route: 'X',
-    path: ['X'],
-    commit: 1,
-    busy: false,
-    window: { w: 390, h: 844 },
-    costMs: 1,
-    elements: [
-      { i: 0, kind: 'button', frame: { x: 0, y: 0, w: 100, h: 40 }, enabled: true, depth: 0, testId: 'open' },
-      { i: 1, kind: 'view', frame: { x: 0, y: 0, w: 20, h: 20 }, enabled: true, depth: 1, testId: 'SvgArrow', parent: 0 },
-      { i: 2, kind: 'view', frame: { x: 0, y: 50, w: 20, h: 20 }, enabled: true, depth: 0, testId: 'page-marker' },
-    ],
-  } as unknown as Screen;
-  assert.doesNotMatch(describeScreen(screen), /SvgArrow/);
-  assert.match(describeScreen(screen), /#page-marker/);
-  assert.match(describeScreen(screen, { all: true }), /SvgArrow/);
-});
-test('describeScreen gives an index only to what cannot be named apart', () => {
-  const el = (i: number, over: object) => ({ i, kind: 'button', frame: { x: 0, y: 0, w: 100, h: 40 }, enabled: true, depth: 0, ...over });
-  const screen = {
-    route: 'X',
-    path: ['X'],
-    commit: 1,
-    busy: false,
-    window: { w: 390, h: 844 },
-    costMs: 1,
-    elements: [
-      el(0, { testId: 'save' }),
-      el(1, { testId: 'like' }),
-      el(2, { testId: 'like' }),
-      el(3, { kind: 'text', text: 'Hello' }),
-      el(4, { kind: 'view', testId: 'marker', accessibilityLabel: 'marker' }),
-      el(5, {}),
-    ],
-  } as unknown as Screen;
-  assert.deepEqual(describeScreen(screen).split('\n').slice(1), [
-    'button #save',
-    '1 button #like',
-    '2 button #like',
-    'text "Hello"',
-    'view #marker',
-    '5 button',
-  ]);
-});
-test('a [n] suffix picks the nth match of a testId or text', () => {
-  assert.deepEqual(parseTarget('#field[2]'), { testId: 'field', nth: 2 });
-  assert.deepEqual(parseTarget('Ciudad[0]'), { text: 'Ciudad', nth: 0 });
-});
-test('--in and --nth narrow a target', () => {
-  assert.deepEqual(scopedTarget('#like-message-button', { in: 'hi from Ana' }), { testId: 'like-message-button', within: { text: 'hi from Ana' } });
-  assert.deepEqual(scopedTarget('#like-message-button', { in: '#feed', nth: 2 }), { testId: 'like-message-button', within: { testId: 'feed' }, nth: 2 });
-  assert.deepEqual(scopedTarget('100,200', { in: '#feed' }), { x: 100, y: 200 });
-});

package/src/cases/__tests__/format.test.ts

@@ -1,76 +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' });
-});