lynkeus 0.2.0 → 0.4.0

package/src/knowledge/lint.ts

@@ -1,7 +1,8 @@
 /** What a person would flag in review, read off one screen: not accessibility certification, the usual suspects. */
 import type { Screen } from 'lynkeus-protocol';
 
-export type Finding = { rule: string; severity: 'warn' | 'info'; element: number; message: string };
+/** `subject` is what the finding is about, without what was measured: it is how a baseline knows the finding again. */
+export type Finding = { rule: string; severity: 'warn' | 'info'; element: number; message: string; subject?: string };
 
 const DEFAULT_I18N_KEY_PATTERNS = [/^[a-z][a-z0-9]*(\.[a-z0-9]+){2,}$/i, /^[a-z0-9]+(_[a-z0-9]+){2,}$/i];
 
@@ -31,7 +32,7 @@ export const lintScreen = (screen: Screen, options: LintOptions = {}): Finding[]
   for (const e of els) {
     const named = e.text ?? e.accessibilityLabel;
     if ((e.kind === 'button' || e.kind === 'switch') && named === undefined && e.testId === undefined) {
-      out.push({ rule: 'unlabeled-control', severity: 'warn', element: e.i, message: `${e.kind} with no text, label or testId` });
+      out.push({ rule: 'unlabeled-control', severity: 'warn', element: e.i, message: `${e.kind} with no text, label or testId`, subject: e.kind });
     }
     if ((e.kind === 'button' || e.kind === 'switch') && e.enabled !== false && e.frame) {
       const { w, h } = e.frame;
@@ -43,11 +44,12 @@ export const lintScreen = (screen: Screen, options: LintOptions = {}): Finding[]
           severity: iconOnly ? 'warn' : 'info',
           element: e.i,
           message: `${Math.round(w)}×${Math.round(h)}pt target (< ${minTouch}) ${label(e) ?? ''}`.trim(),
+          subject: label(e) ?? e.kind,
         });
       }
     }
     if (e.kind === 'text' && e.text && looksLikeI18nKey(e.text, options.i18nKeyPatterns ?? DEFAULT_I18N_KEY_PATTERNS)) {
-      out.push({ rule: 'untranslated', severity: 'warn', element: e.i, message: `"${e.text}" looks like an i18n key, not copy` });
+      out.push({ rule: 'untranslated', severity: 'warn', element: e.i, message: `"${e.text}" looks like an i18n key, not copy`, subject: e.text });
     }
     if ((e.kind === 'button' || e.kind === 'input' || e.kind === 'switch') && e.covered && e.enabled !== false) {
       out.push({
@@ -55,6 +57,7 @@ export const lintScreen = (screen: Screen, options: LintOptions = {}): Finding[]
         severity: 'info',
         element: e.i,
         message: `${e.kind} ${label(e) ?? ''} is covered; a tap would not reach it`.replace('  ', ' ').trim(),
+        subject: label(e) ?? e.kind,
       });
     }
     if (e.frame && win.w > 0 && label(e) !== undefined) {
@@ -65,6 +68,7 @@ export const lintScreen = (screen: Screen, options: LintOptions = {}): Finding[]
           severity: 'info',
           element: e.i,
           message: `${label(e)} extends past the ${win.w}×${win.h} window (x${Math.round(x)} y${Math.round(y)} ${Math.round(w)}×${Math.round(h)})`,
+          subject: label(e),
         });
       }
     }
@@ -74,6 +78,7 @@ export const lintScreen = (screen: Screen, options: LintOptions = {}): Finding[]
         severity: 'info',
         element: e.i,
         message: `"${e.text.slice(0, 30)}" has ${Math.round(e.frame.w)}×${Math.round(e.frame.h)} size`,
+        subject: e.text,
       });
     }
   }
@@ -86,7 +91,13 @@ export const lintScreen = (screen: Screen, options: LintOptions = {}): Finding[]
   }
   for (const [id, at] of byTestId)
     if (at.length > 1)
-      out.push({ rule: 'duplicate-testid', severity: 'info', element: at[0]!, message: `testId "${id}" is on ${at.length} elements (${at.join(', ')})` });
+      out.push({
+        rule: 'duplicate-testid',
+        severity: 'info',
+        element: at[0]!,
+        message: `testId "${id}" is on ${at.length} elements (${at.join(', ')})`,
+        subject: id,
+      });
   return out;
 };
 

package/src/mcp/server.ts

@@ -60,9 +60,23 @@ const argvFor = (c: Command, input: Record<string, unknown>): string[] => {
   return av;
 };
 
+// What a model is told once, when it connects: the order things are done in, so "set lynkeus up" and "write me
+// a test for this" need nothing more from the person asking.
+const INSTRUCTIONS = `lynkeus drives a React Native app (bare or Expo) by what is on its screen, and runs cases written as readable steps.
+
+In a project you do not know, call status first: it lists what is set up and, for what is not, the one thing that fixes it.
+
+To set lynkeus up: call init (it installs lynkeus-agent, mounts it from the app's entry and makes the project's token; nobody sets a variable). The agent has native code, so the app must then be built again (npx react-native run-ios or run-android; npx expo run:ios or run:android, never Expo Go) with Metro restarted with --reset-cache. Do that with your shell if you have one, or ask the person to. Then status until an app is attached.
+
+To write a test: call case_init once if the project has no cases, and read the README.md it writes for the format. Go to the screen with press, type and wait, calling screen to see what is there; prefer testIDs (#id) over text. Write the case as a markdown file in the cases folder, then call case_run with that file. A failed step comes back with the screen it failed on: fix the case or report the app's bug, do not weaken the check.
+
+To test without a simulator: call headless_init (it installs what the Node host needs and writes its entry; an Expo Router app works too), then headless_doctor for the native modules still to mock, then case_run with host. The backend the app talks to must be local: set apiUrl in lynkeus.config.json.
+
+To share a run: case_run with out, screenshots and push uploads it and prints the report's address. That needs LYNKEUS_REPORTS_KEY in this server's environment.`;
+
 export const serve = async (session: Session, options: { full?: boolean } = {}) => {
   const { version } = createRequire(import.meta.url)('../../package.json') as { version: string };
-  const server = new Server({ name: 'lynkeus', version }, { capabilities: { tools: {} } });
+  const server = new Server({ name: 'lynkeus', version }, { capabilities: { tools: {} }, instructions: INSTRUCTIONS });
   const served = commands().filter((c) => overMcp(c, !!options.full));
   const byName = new Map(served.map((c) => [identifier(c.name), c]));
   // So a model reading the app's screens knows their language before it starts guessing.
@@ -105,5 +119,20 @@ export const serve = async (session: Session, options: { full?: boolean } = {})
     if (r.error) return { ...text(`✗ ${r.error}${r.why ? `\n\nwhy:\n${r.why}` : ''}`), isError: true };
     return text(r.text || (r.json !== undefined ? JSON.stringify(r.json, null, 2) : 'ok'));
   });
-  await server.connect(new StdioServerTransport());
+  // The client going away ends the server: the session holds the driver's port open, and a server left behind
+  // keeps the next one (or a case run) from binding it.
+  const transport = new StdioServerTransport();
+  let stopping = false;
+  const stop = () => {
+    if (stopping) return;
+    stopping = true;
+    void session
+      .stop()
+      .catch(() => undefined)
+      .finally(() => process.exit(0));
+  };
+  process.stdin.once('end', stop);
+  process.stdin.once('close', stop);
+  transport.onclose = stop;
+  await server.connect(transport);
 };

package/src/registry.ts

@@ -29,6 +29,8 @@ export type Base = {
   err: (line: string) => void;
   /** Inside `lynkeus session` and over MCP: one connection, many commands. */
   attached: boolean;
+  /** The same, but waiting for its app on another port: one per host when several run side by side. */
+  forPort?: (port: number) => { base: Base; stop: () => Promise<void> };
 };
 
 export type Ctx = Base & { args: string[]; flags: FlagValues; passthrough: string[] };

package/src/targets.ts

@@ -2,8 +2,13 @@ import type { Target } from 'lynkeus-protocol';
 
 export const TARGET_HELP = '#testId | "text" | 12 (index) | 100,200';
 
-/** `#testId`, `12` (an index), `100,200` (a point), anything else a text; `#testId[2]` or `text[2]` is the third match. */
+/**
+ * `#testId`, `12` (an index), `100,200` (a point), anything else a text; `#testId[2]` or `text[2]` is the third match.
+ * A text in quotes is that text and nothing else: `"12"` is not an index, and `"Next"` is not a route.
+ */
 export const parseTarget = (raw: string): Target => {
+  const quoted = /^(["'])((?:(?!\1).)*)\1$/s.exec(raw);
+  if (quoted) return { text: quoted[2]! };
   const nth = /^(.+)\[(\d+)\]$/.exec(raw);
   if (nth && !/^\d+$/.test(nth[1]!)) {
     const base = parseTarget(nth[1]!);
@@ -31,14 +36,23 @@ export const scopedTarget = (raw: string, flags: { in?: unknown; nth?: unknown }
   };
 };
 
-export const isRoute = (raw: string) => /^[A-Z]\w*(\.[A-Z]\w*)*$/.test(raw);
+const ROUTE_PREFIX = 'route:';
+
+/**
+ * A word that starts with a capital is a route (`Home.Main`), as React Navigation names them. A router
+ * that names routes after files (Expo Router's `index`, `(tabs)/settings`) says so: `route:index`.
+ */
+export const isRoute = (raw: string) => raw.startsWith(ROUTE_PREFIX) || /^[A-Z]\w*(\.[A-Z]\w*)*$/.test(raw);
+
+/** The route a target names, without the prefix that marked it as one. */
+export const routeOf = (raw: string) => (raw.startsWith(ROUTE_PREFIX) ? raw.slice(ROUTE_PREFIX.length) : raw);
 
 export type Expected = { testId?: string; text?: string; route?: string };
 
 /** What a command was looking for, as `why` reads it. */
 export const expectedOf = (raw: string | undefined): Expected | undefined => {
   if (!raw) return undefined;
-  if (isRoute(raw)) return { route: raw };
+  if (isRoute(raw)) return { route: routeOf(raw) };
   const t = parseTarget(raw);
   return 'testId' in t ? { testId: t.testId } : 'text' in t ? { text: t.text } : undefined;
 };

package/lib/__tests__/args.test.d.ts

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

package/lib/__tests__/args.test.js

@@ -1,69 +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', help: '' },
-    depth: { type: 'number', help: '', default: 4 },
-    var: { type: 'list', help: '' },
-    out: { type: 'string', 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), { 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) => e instanceof UsageError && /--direct/.test(e.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();
-    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/lib/__tests__/check.test.d.ts

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

package/lib/__tests__/check.test.js

@@ -1,60 +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';
-const graph = (screens, files) => ({
-    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: [],
-        },
-    ])),
-});
-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', element: 3, message: 'button without a label' }, testId: 'x' };
-    const f2 = { finding: { rule: 'small-target', severity: 'warn', 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) => ({ name: 'f', ok: true, totalMs: ms, vars: {}, steps: [{ step: { press: { testId: 'a' } }, ok: true, ms: 1 }] });
-    const bad = (err) => ({
-        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/lib/__tests__/init.test.d.ts

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

package/lib/__tests__/init.test.js

@@ -1,42 +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/lib/__tests__/record.test.d.ts

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

package/lib/__tests__/record.test.js

@@ -1,44 +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';
-const ev = (partial, seq) => ({ seq, t: seq * 100, ...partial });
-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/lib/__tests__/snapshot.test.d.ts

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

package/lib/__tests__/snapshot.test.js

@@ -1,47 +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, h, paint) => {
-    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/lib/__tests__/targets.test.d.ts

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

package/lib/__tests__/targets.test.js

@@ -1,127 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-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' }],
-    };
-    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' },
-        ],
-    };
-    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, over) => ({ 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 }),
-        ],
-    };
-    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' },
-        ],
-    };
-    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, over) => ({ 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, {}),
-        ],
-    };
-    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/lib/cases/__tests__/format.test.d.ts

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