@jackwener/opencli 1.7.5 → 1.7.7

package/dist/src/browser/extract.js

@@ -0,0 +1,132 @@
+/**
+ * `browser extract` — agent-native article/content reading channel.
+ *
+ * Pipeline (from first principles — agents want the *content*, not the DOM):
+ *   1. Scope:    select `--selector` (default: document.body or <main>/<article>)
+ *   2. Denoise:  strip script/style/nav/header/footer/aside/iframe/svg/form, inline noise
+ *   3. Convert:  HTML → Markdown via shared `htmlToMarkdown` (turndown)
+ *   4. Chunk:    paragraph-boundary-aware slicing with `next_start_char` cursor
+ *
+ * Why a separate command:
+ * - `get html --as json` returns tree structure; useless for "read the article".
+ * - `get text` flattens everything; loses headings, lists, links.
+ * - Markdown is the agent-readable middle ground: structure preserved, noise gone.
+ *
+ * Continuation contract: the envelope always carries `start`, `end`,
+ * `total_chars`, and `next_start_char` (null when the last chunk was emitted).
+ * Agents pass `--start <next>` to continue. No session state required.
+ */
+import { htmlToMarkdown } from '../utils.js';
+const DEFAULT_CHUNK_SIZE = 20000;
+const MIN_CHUNK_SIZE = 100;
+const MAX_CHUNK_SIZE = 200000;
+const BOUNDARY_WINDOW_RATIO = 0.15;
+/**
+ * Returns the JS expression string used with `page.evaluate` to produce the
+ * cleaned HTML subtree that we then hand to `htmlToMarkdown`. We do the
+ * denoise/clone inside the page so we can use DOM APIs (querySelectorAll,
+ * cloneNode) rather than regex on serialized HTML.
+ */
+export function buildExtractHtmlJs(selector) {
+    const selectorLiteral = selector ? JSON.stringify(selector) : 'null';
+    return `(() => {
+  const sel = ${selectorLiteral};
+  let root = null;
+  if (sel) {
+    try { root = document.querySelector(sel); }
+    catch (e) {
+      return { invalidSelector: true, reason: (e && e.message) || String(e) };
+    }
+    if (!root) return { notFound: true };
+  } else {
+    root = document.querySelector('main') || document.querySelector('article') || document.body || document.documentElement;
+  }
+  if (!root) return { notFound: true };
+  const clone = root.cloneNode(true);
+  const drop = [
+    'script', 'style', 'noscript', 'template',
+    'nav', 'header', 'footer', 'aside',
+    'iframe', 'svg', 'canvas',
+    'form', 'button', 'input', 'select', 'textarea',
+    '[role="navigation"]', '[role="banner"]', '[role="contentinfo"]', '[role="complementary"]',
+    '[aria-hidden="true"]',
+  ];
+  for (const q of drop) {
+    for (const n of clone.querySelectorAll(q)) n.remove();
+  }
+  // Also strip event-handler and style attributes that bloat markdown output.
+  const walker = document.createTreeWalker(clone, NodeFilter.SHOW_ELEMENT);
+  let n = walker.currentNode;
+  while (n) {
+    if (n.nodeType === 1) {
+      const el = n;
+      for (const a of [...el.attributes]) {
+        if (a.name.startsWith('on') || a.name === 'style' || a.name.startsWith('data-')) el.removeAttribute(a.name);
+      }
+    }
+    n = walker.nextNode();
+  }
+  return { ok: true, url: location.href, title: document.title || '', html: clone.outerHTML || '' };
+})()`;
+}
+/**
+ * Slice `content` into one chunk starting at `start` with target size
+ * `chunkSize`. When the chunk would land mid-paragraph, we pull the break
+ * back to the nearest `\n\n` (or `\n`) within a small window to keep the
+ * output readable. If no boundary is found, we hard-cut at `start+chunkSize`.
+ */
+export function chunkMarkdown(opts) {
+    const { content, start } = opts;
+    const chunkSize = Math.max(MIN_CHUNK_SIZE, Math.min(MAX_CHUNK_SIZE, opts.chunkSize));
+    if (start >= content.length) {
+        return { content: '', start, end: start, nextStartChar: null };
+    }
+    const hardEnd = Math.min(content.length, start + chunkSize);
+    if (hardEnd === content.length) {
+        return { content: content.slice(start, hardEnd), start, end: hardEnd, nextStartChar: null };
+    }
+    const windowSize = Math.max(1, Math.floor(chunkSize * BOUNDARY_WINDOW_RATIO));
+    const windowStart = Math.max(start + 1, hardEnd - windowSize);
+    const slice = content.slice(windowStart, hardEnd);
+    const paraBreak = slice.lastIndexOf('\n\n');
+    let cut = hardEnd;
+    if (paraBreak >= 0) {
+        cut = windowStart + paraBreak + 2;
+    }
+    else {
+        const lineBreak = slice.lastIndexOf('\n');
+        if (lineBreak >= 0)
+            cut = windowStart + lineBreak + 1;
+    }
+    return {
+        content: content.slice(start, cut),
+        start,
+        end: cut,
+        nextStartChar: cut,
+    };
+}
+/** End-to-end host-side pipeline: HTML → markdown → chunked envelope. */
+export function runExtractFromHtml(opts) {
+    const md = htmlToMarkdown(opts.html);
+    const chunk = chunkMarkdown({
+        content: md,
+        start: Math.max(0, opts.start),
+        chunkSize: opts.chunkSize || DEFAULT_CHUNK_SIZE,
+    });
+    return {
+        url: opts.url,
+        title: opts.title,
+        selector: opts.selector,
+        total_chars: md.length,
+        chunk_size: chunk.end - chunk.start,
+        start: chunk.start,
+        end: chunk.end,
+        next_start_char: chunk.nextStartChar,
+        content: chunk.content,
+    };
+}
+export const __extractInternals = {
+    DEFAULT_CHUNK_SIZE,
+    MIN_CHUNK_SIZE,
+    MAX_CHUNK_SIZE,
+};

package/dist/src/browser/extract.test.d.ts

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

package/dist/src/browser/extract.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest';
+import { buildExtractHtmlJs, chunkMarkdown, runExtractFromHtml } from './extract.js';
+describe('chunkMarkdown', () => {
+    it('returns the full content when it fits in one chunk', () => {
+        const content = 'short body';
+        const r = chunkMarkdown({ content, start: 0, chunkSize: 20000 });
+        expect(r.content).toBe(content);
+        expect(r.start).toBe(0);
+        expect(r.end).toBe(content.length);
+        expect(r.nextStartChar).toBeNull();
+    });
+    it('emits next_start_char when more content remains', () => {
+        // Build content long enough that chunkSize cuts it mid-stream.
+        const para = 'p'.repeat(400);
+        const content = [para, para, para].join('\n\n');
+        const r = chunkMarkdown({ content, start: 0, chunkSize: 500 });
+        expect(r.nextStartChar).not.toBeNull();
+        expect(r.nextStartChar).toBeGreaterThan(0);
+        expect(r.nextStartChar).toBeLessThan(content.length);
+    });
+    it('prefers to break at a paragraph boundary inside the boundary window', () => {
+        // chunkSize=500, window=15% → [425, 500). Place `\n\n` at 450 so it lands
+        // inside the window; the chunker should snap the cut back to it.
+        const a = 'a'.repeat(450);
+        const b = 'b'.repeat(400);
+        const content = `${a}\n\n${b}`;
+        const r = chunkMarkdown({ content, start: 0, chunkSize: 500 });
+        expect(r.content.endsWith('\n\n')).toBe(true);
+        expect(r.nextStartChar).toBe(r.end);
+        expect(content.slice(r.end).startsWith('b')).toBe(true);
+    });
+    it('falls back to a single newline when no paragraph boundary is in window', () => {
+        // 6 lines × 90 chars joined by `\n` → `\n` at 90, 181, 272, 363, 454.
+        // chunkSize=500 with window [425, 500) catches the `\n` at 454.
+        const line = 'l'.repeat(90);
+        const content = Array.from({ length: 6 }, () => line).join('\n');
+        const r = chunkMarkdown({ content, start: 0, chunkSize: 500 });
+        expect(r.content.endsWith('\n')).toBe(true);
+        expect(content.slice(r.end).startsWith('l')).toBe(true);
+    });
+    it('hard-cuts when no boundary is found within the window', () => {
+        const content = 'x'.repeat(5000);
+        const r = chunkMarkdown({ content, start: 0, chunkSize: 500 });
+        expect(r.end).toBe(500);
+        expect(r.content).toHaveLength(500);
+        expect(r.nextStartChar).toBe(500);
+    });
+    it('handles start >= content.length with an empty final chunk', () => {
+        const content = 'hello';
+        const r = chunkMarkdown({ content, start: 5, chunkSize: 100 });
+        expect(r.content).toBe('');
+        expect(r.nextStartChar).toBeNull();
+    });
+    it('resumes from a provided start cursor until the stream terminates', () => {
+        const content = `${'a'.repeat(100)}\n\n${'b'.repeat(100)}\n\n${'c'.repeat(100)}`;
+        const first = chunkMarkdown({ content, start: 0, chunkSize: 110 });
+        expect(first.nextStartChar).not.toBeNull();
+        const second = chunkMarkdown({ content, start: first.nextStartChar, chunkSize: 110 });
+        expect(second.start).toBe(first.nextStartChar);
+        expect(second.content.length).toBeGreaterThan(0);
+        let cursor = second.nextStartChar;
+        let safety = 20;
+        while (cursor !== null && safety-- > 0) {
+            const step = chunkMarkdown({ content, start: cursor, chunkSize: 110 });
+            cursor = step.nextStartChar;
+        }
+        expect(cursor).toBeNull();
+    });
+    it('clamps chunk size to the configured minimum', () => {
+        const content = 'a'.repeat(2000);
+        const r = chunkMarkdown({ content, start: 0, chunkSize: 1 });
+        // MIN_CHUNK_SIZE is 100 — requesting 1 should still produce >= 100 chars.
+        expect(r.end).toBeGreaterThanOrEqual(100);
+    });
+});
+describe('runExtractFromHtml', () => {
+    it('converts HTML to markdown and wraps it in the chunking envelope', () => {
+        const html = '<article><h1>Title</h1><p>Hello <strong>world</strong>.</p></article>';
+        const r = runExtractFromHtml({
+            html,
+            url: 'https://example.com/a',
+            title: 'Example',
+            selector: 'article',
+            start: 0,
+            chunkSize: 20000,
+        });
+        expect(r.url).toBe('https://example.com/a');
+        expect(r.title).toBe('Example');
+        expect(r.selector).toBe('article');
+        expect(r.content).toContain('# Title');
+        expect(r.content).toContain('**world**');
+        expect(r.start).toBe(0);
+        expect(r.end).toBe(r.content.length);
+        expect(r.total_chars).toBe(r.content.length);
+        expect(r.next_start_char).toBeNull();
+    });
+    it('reports total_chars and chunk_size against the final markdown', () => {
+        const body = Array.from({ length: 30 }, (_, i) => `<p>paragraph ${i} ${'x'.repeat(200)}</p>`).join('');
+        const r = runExtractFromHtml({
+            html: `<main>${body}</main>`,
+            url: 'https://example.com/b',
+            title: 't',
+            selector: 'main',
+            start: 0,
+            chunkSize: 500,
+        });
+        expect(r.total_chars).toBeGreaterThan(r.end);
+        expect(r.chunk_size).toBe(r.end - r.start);
+        expect(r.next_start_char).toBe(r.end);
+    });
+});
+describe('buildExtractHtmlJs', () => {
+    it('embeds the selector as a JSON literal', () => {
+        const js = buildExtractHtmlJs('main.article');
+        expect(js).toContain('"main.article"');
+    });
+    it('uses null when no selector given', () => {
+        const js = buildExtractHtmlJs(null);
+        // The expression references `sel` and compares to null.
+        expect(js).toContain('const sel = null;');
+    });
+    it('includes the denoise selector list', () => {
+        const js = buildExtractHtmlJs(null);
+        expect(js).toContain("'script'");
+        expect(js).toContain("'nav'");
+        expect(js).toContain("'iframe'");
+        expect(js).toContain("'[aria-hidden=\"true\"]'");
+    });
+});

package/dist/src/browser/find.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `browser find --css <sel>` — structured CSS query.
+ *
+ * Returns every match of a selector as a JSON envelope agents can read
+ * without parsing free-text snapshot output. Each entry carries two
+ * identifiers — a numeric `ref` (matching the snapshot contract) and a
+ * stable 0-based `nth` — so the agent can act on a specific result via
+ * either path:
+ *
+ *   browser click <ref>              // when ref is numeric
+ *   browser click "<sel>" --nth <n>  // always works
+ *
+ * Refs are *allocated on the spot* for matched elements that were not
+ * tagged by a prior snapshot: `data-opencli-ref` is set on the element
+ * and a fingerprint is written into `window.__opencli_ref_identity`
+ * (same shape the snapshot uses). That makes `find` a first-class entry
+ * point to the ref system — agents can skip running `browser state`
+ * when they already know the selector.
+ *
+ * Attributes are whitelisted to keep output small and high-signal.
+ * Invisible elements are still returned so agents can reason about
+ * offscreen vs truly-missing targets.
+ *
+ * When a matched element is a compound form control (date-like input,
+ * select, file input), the entry gains a `compound` field with the
+ * rich view from `compound.ts`. This is what kills the three biggest
+ * agent-fail modes on form pages (wrong date format, guessed options,
+ * re-uploaded files) without forcing agents to probe further.
+ */
+import { type CompoundInfo } from './compound.js';
+/** Whitelist of attributes surfaced per entry. Keep small; agents do not need full DOM dumps. */
+export declare const FIND_ATTR_WHITELIST: readonly ["id", "class", "name", "type", "placeholder", "aria-label", "title", "href", "value", "role", "data-testid"];
+export interface FindEntry {
+    /** Zero-based position within the match set — pair with `--nth` on downstream commands. */
+    nth: number;
+    /**
+     * Numeric data-opencli-ref. Find assigns one if the element was not
+     * tagged by a prior snapshot, so downstream `browser click <ref>` works
+     * directly off the find output without requiring `browser state` first.
+     */
+    ref: number;
+    tag: string;
+    role: string;
+    text: string;
+    attrs: Record<string, string>;
+    visible: boolean;
+    /**
+     * Rich view for date / time / datetime-local / month / week / select /
+     * file inputs. Omitted (undefined) for all other element types. See
+     * `compound.ts` for the shape.
+     */
+    compound?: CompoundInfo;
+}
+export interface FindResult {
+    matches_n: number;
+    entries: FindEntry[];
+}
+export interface FindError {
+    error: {
+        code: 'invalid_selector' | 'selector_not_found';
+        message: string;
+        hint?: string;
+    };
+}
+export interface FindOptions {
+    /** Max entries returned. Default 50 — enough to pick from without flooding context. */
+    limit?: number;
+    /** Max chars of trimmed text per entry. Default 120. */
+    textMax?: number;
+}
+/**
+ * Build the browser-side JS that performs the CSS query and emits the
+ * FindResult (or FindError) envelope. Evaluated inside `page.evaluate`.
+ */
+export declare function buildFindJs(selector: string, opts?: FindOptions): string;
+export declare function isFindError(result: unknown): result is FindError;

package/dist/src/browser/find.js

@@ -0,0 +1,179 @@
+/**
+ * `browser find --css <sel>` — structured CSS query.
+ *
+ * Returns every match of a selector as a JSON envelope agents can read
+ * without parsing free-text snapshot output. Each entry carries two
+ * identifiers — a numeric `ref` (matching the snapshot contract) and a
+ * stable 0-based `nth` — so the agent can act on a specific result via
+ * either path:
+ *
+ *   browser click <ref>              // when ref is numeric
+ *   browser click "<sel>" --nth <n>  // always works
+ *
+ * Refs are *allocated on the spot* for matched elements that were not
+ * tagged by a prior snapshot: `data-opencli-ref` is set on the element
+ * and a fingerprint is written into `window.__opencli_ref_identity`
+ * (same shape the snapshot uses). That makes `find` a first-class entry
+ * point to the ref system — agents can skip running `browser state`
+ * when they already know the selector.
+ *
+ * Attributes are whitelisted to keep output small and high-signal.
+ * Invisible elements are still returned so agents can reason about
+ * offscreen vs truly-missing targets.
+ *
+ * When a matched element is a compound form control (date-like input,
+ * select, file input), the entry gains a `compound` field with the
+ * rich view from `compound.ts`. This is what kills the three biggest
+ * agent-fail modes on form pages (wrong date format, guessed options,
+ * re-uploaded files) without forcing agents to probe further.
+ */
+import { COMPOUND_INFO_JS } from './compound.js';
+/** Whitelist of attributes surfaced per entry. Keep small; agents do not need full DOM dumps. */
+export const FIND_ATTR_WHITELIST = [
+    'id',
+    'class',
+    'name',
+    'type',
+    'placeholder',
+    'aria-label',
+    'title',
+    'href',
+    'value',
+    'role',
+    'data-testid',
+];
+/**
+ * Build the browser-side JS that performs the CSS query and emits the
+ * FindResult (or FindError) envelope. Evaluated inside `page.evaluate`.
+ */
+export function buildFindJs(selector, opts = {}) {
+    const safeSel = JSON.stringify(selector);
+    const limit = opts.limit ?? 50;
+    const textMax = opts.textMax ?? 120;
+    const whitelist = JSON.stringify(FIND_ATTR_WHITELIST);
+    return `
+    (() => {
+      const sel = ${safeSel};
+      const LIMIT = ${limit};
+      const TEXT_MAX = ${textMax};
+      const ATTR_WHITELIST = ${whitelist};
+
+      ${COMPOUND_INFO_JS}
+
+      let matches;
+      try {
+        matches = document.querySelectorAll(sel);
+      } catch (e) {
+        return {
+          error: {
+            code: 'invalid_selector',
+            message: 'Invalid CSS selector: ' + sel + ' (' + ((e && e.message) || String(e)) + ')',
+            hint: 'Check the selector syntax.',
+          },
+        };
+      }
+
+      if (matches.length === 0) {
+        return {
+          error: {
+            code: 'selector_not_found',
+            message: 'CSS selector ' + sel + ' matched 0 elements',
+            hint: 'Use browser state to inspect the page, or try a less specific selector.',
+          },
+        };
+      }
+
+      function pickAttrs(el) {
+        const out = {};
+        for (const key of ATTR_WHITELIST) {
+          const v = el.getAttribute(key);
+          if (v != null && v !== '') out[key] = v;
+        }
+        return out;
+      }
+
+      function isVisible(el) {
+        const rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) return false;
+        try {
+          const style = getComputedStyle(el);
+          if (style.display === 'none' || style.visibility === 'hidden') return false;
+          if (parseFloat(style.opacity || '1') === 0) return false;
+        } catch (_) {}
+        return true;
+      }
+
+      // Ref allocation: reuse \`window.__opencli_ref_identity\` (the same map
+      // snapshot populates) as the source of truth. For matched elements that
+      // don't already carry a \`data-opencli-ref\`, assign the next free numeric
+      // ref and write the fingerprint so the target resolver can verify it on
+      // downstream click/type/get calls.
+      const identity = (window.__opencli_ref_identity = window.__opencli_ref_identity || {});
+      let maxRef = 0;
+      for (const k in identity) {
+        const n = parseInt(k, 10);
+        if (!isNaN(n) && n > maxRef) maxRef = n;
+      }
+      // Also walk any \`data-opencli-ref\` already in the DOM in case the identity
+      // map was cleared but annotations remain (e.g. soft navigation without a
+      // fresh snapshot). Guarantees allocated refs don't collide.
+      try {
+        const tagged = document.querySelectorAll('[data-opencli-ref]');
+        for (let t = 0; t < tagged.length; t++) {
+          const v = tagged[t].getAttribute('data-opencli-ref');
+          const n = v != null && /^\\d+$/.test(v) ? parseInt(v, 10) : NaN;
+          if (!isNaN(n) && n > maxRef) maxRef = n;
+        }
+      } catch (_) {}
+
+      function fingerprintOf(el) {
+        return {
+          tag: el.tagName.toLowerCase(),
+          role: el.getAttribute('role') || '',
+          text: (el.textContent || '').trim().slice(0, 30),
+          ariaLabel: el.getAttribute('aria-label') || '',
+          id: el.id || '',
+          testId: el.getAttribute('data-testid') || el.getAttribute('data-test') || '',
+        };
+      }
+
+      const take = Math.min(matches.length, LIMIT);
+      const entries = [];
+      for (let i = 0; i < take; i++) {
+        const el = matches[i];
+        const refAttr = el.getAttribute('data-opencli-ref');
+        let refNum = refAttr != null && /^\\d+$/.test(refAttr) ? parseInt(refAttr, 10) : null;
+        if (refNum === null) {
+          refNum = ++maxRef;
+          try { el.setAttribute('data-opencli-ref', '' + refNum); } catch (_) {}
+          identity['' + refNum] = fingerprintOf(el);
+        } else if (!identity['' + refNum]) {
+          // Ref annotation survived but identity map was cleared — repopulate so the
+          // target resolver's fingerprint check passes on downstream calls.
+          identity['' + refNum] = fingerprintOf(el);
+        }
+        const text = (el.textContent || '').trim();
+        const entry = {
+          nth: i,
+          ref: refNum,
+          tag: el.tagName.toLowerCase(),
+          role: el.getAttribute('role') || '',
+          text: text.length > TEXT_MAX ? text.slice(0, TEXT_MAX) : text,
+          attrs: pickAttrs(el),
+          visible: isVisible(el),
+        };
+        const compound = compoundInfoOf(el);
+        if (compound) entry.compound = compound;
+        entries.push(entry);
+      }
+
+      return {
+        matches_n: matches.length,
+        entries,
+      };
+    })()
+  `;
+}
+export function isFindError(result) {
+    return !!result && typeof result === 'object' && 'error' in result;
+}

package/dist/src/browser/find.test.d.ts

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

package/dist/src/browser/find.test.js

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import { buildFindJs, FIND_ATTR_WHITELIST, isFindError } from './find.js';
+/**
+ * These tests validate the shape and options of the generated JS string
+ * (no DOM available in the default vitest unit env). Runtime behavior of
+ * the generated JS against a real DOM is covered by the browser e2e suite.
+ */
+describe('buildFindJs', () => {
+    it('produces syntactically valid JS that can be parsed', () => {
+        expect(() => new Function(`return (${buildFindJs('.btn')});`)).not.toThrow();
+    });
+    it('embeds the selector via JSON.stringify (injection-safe)', () => {
+        const js = buildFindJs('[data-x="a\"b"]');
+        // Unescaped literal break-out must not appear
+        expect(js).not.toContain('[data-x="a"b"]');
+        // The JSON-encoded form (with escaped quotes) should
+        expect(js).toContain(JSON.stringify('[data-x="a\"b"]'));
+    });
+    it('emits invalid_selector + selector_not_found branches', () => {
+        const js = buildFindJs('.btn');
+        expect(js).toContain("code: 'invalid_selector'");
+        expect(js).toContain("code: 'selector_not_found'");
+    });
+    it('emits matches_n + entries + per-entry shape', () => {
+        const js = buildFindJs('.btn');
+        expect(js).toContain('matches_n: matches.length');
+        expect(js).toContain('entries.push(');
+        // Per-entry keys reviewers signed off on: nth, ref, tag, role, text, attrs, visible
+        expect(js).toContain('nth: i');
+        expect(js).toContain('ref: refNum');
+        expect(js).toContain('tag: el.tagName.toLowerCase()');
+        expect(js).toContain("el.getAttribute('role')");
+        expect(js).toContain('visible: isVisible(el)');
+    });
+    it('allocates fresh refs for untagged matches (write attribute + identity map)', () => {
+        const js = buildFindJs('.btn');
+        // On the just-annotated branch we must flip the attribute on the element
+        // so downstream `browser click <ref>` works off the find output.
+        expect(js).toContain("el.setAttribute('data-opencli-ref'");
+        // The fingerprint must also land in the shared identity map so the
+        // target resolver's stale-ref check has data to verify against.
+        expect(js).toContain('__opencli_ref_identity');
+        expect(js).toContain("identity['' + refNum] = fingerprintOf(el)");
+        // Allocation walks both the identity map and any existing data-opencli-ref
+        // annotations — guards against collisions after a soft nav.
+        expect(js).toContain("document.querySelectorAll('[data-opencli-ref]')");
+    });
+    it('fingerprint shape matches the snapshot / resolver contract', () => {
+        const js = buildFindJs('.btn');
+        // The six fields resolveTargetJs verifies in its stale_ref check.
+        for (const field of ['tag:', 'role:', 'text:', 'ariaLabel:', 'id:', 'testId:']) {
+            expect(js).toContain(field);
+        }
+    });
+    it('embeds defaults for limit and textMax', () => {
+        const js = buildFindJs('.btn');
+        expect(js).toContain('LIMIT = 50');
+        expect(js).toContain('TEXT_MAX = 120');
+    });
+    it('overrides limit and textMax when requested', () => {
+        const js = buildFindJs('.btn', { limit: 3, textMax: 20 });
+        expect(js).toContain('LIMIT = 3');
+        expect(js).toContain('TEXT_MAX = 20');
+    });
+    it('embeds the attribute whitelist verbatim (no style/onclick leaking)', () => {
+        const js = buildFindJs('.btn');
+        // Whitelist fields appear inside the generated JS
+        for (const key of FIND_ATTR_WHITELIST) {
+            expect(js).toContain(`"${key}"`);
+        }
+        // Sensitive / high-noise attrs must stay out of the whitelist
+        expect(FIND_ATTR_WHITELIST).not.toContain('style');
+        expect(FIND_ATTR_WHITELIST).not.toContain('onclick');
+        expect(FIND_ATTR_WHITELIST).not.toContain('onload');
+    });
+    it('inlines compoundInfoOf and attaches compound field per entry', () => {
+        const js = buildFindJs('input, select');
+        // Helper definition is inlined so each matched element can be classified.
+        expect(js).toContain('function compoundInfoOf(el)');
+        // The emitted entry opts in only when compound data is present — no noisy
+        // compound: null on every non-form element.
+        expect(js).toContain('const compound = compoundInfoOf(el);');
+        expect(js).toContain('if (compound) entry.compound = compound;');
+        // Spot-check all three compound families are covered in the inlined helper.
+        expect(js).toContain("'YYYY-MM-DD'");
+        expect(js).toContain("control: 'file'");
+        expect(js).toContain("control: 'select'");
+    });
+    it('keeps the whitelist small and explicit (guardrail against silent expansion)', () => {
+        expect(FIND_ATTR_WHITELIST).toEqual([
+            'id',
+            'class',
+            'name',
+            'type',
+            'placeholder',
+            'aria-label',
+            'title',
+            'href',
+            'value',
+            'role',
+            'data-testid',
+        ]);
+    });
+});
+describe('isFindError', () => {
+    it('narrows { error: ... } as FindError', () => {
+        const payload = { error: { code: 'invalid_selector', message: 'x' } };
+        expect(isFindError(payload)).toBe(true);
+        if (isFindError(payload)) {
+            const err = payload;
+            expect(err.error.code).toBe('invalid_selector');
+        }
+    });
+    it('rejects successful envelopes', () => {
+        expect(isFindError({ matches_n: 0, entries: [] })).toBe(false);
+        expect(isFindError(null)).toBe(false);
+        expect(isFindError(undefined)).toBe(false);
+        expect(isFindError('string')).toBe(false);
+    });
+});