@sovovs/bycli 1.8.0 → 2.0.0

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

@@ -1,134 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateStealthJs } from './stealth.js';
-/**
- * Tests for the stealth anti-detection module.
- *
- * We test the generated JS string for expected content and structure.
- * Evaluating in Node is fragile because stealth patches target browser
- * globals (navigator, Performance, HTMLIFrameElement) that don't exist
- * or behave differently in Node. Instead we verify the code string
- * contains the right patches and is syntactically valid.
- */
-describe('generateStealthJs', () => {
-    it('returns a non-empty string', () => {
-        const code = generateStealthJs();
-        expect(typeof code).toBe('string');
-        expect(code.length).toBeGreaterThan(0);
-    });
-    it('is a valid self-contained IIFE', () => {
-        const code = generateStealthJs();
-        // Should start/end as an IIFE
-        expect(code.trim()).toMatch(/^\(\(\) => \{/);
-        expect(code.trim()).toMatch(/\}\)\(\)$/);
-    });
-    it('patches navigator.webdriver', () => {
-        const code = generateStealthJs();
-        expect(code).toContain("navigator, 'webdriver'");
-        expect(code).toContain('() => false');
-    });
-    it('stubs window.chrome', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('window.chrome');
-        expect(code).toContain('runtime');
-        expect(code).toContain('loadTimes');
-        expect(code).toContain('csi');
-    });
-    it('fakes navigator.plugins if empty', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('navigator.plugins');
-        expect(code).toContain('PDF Viewer');
-        expect(code).toContain('Chrome PDF Viewer');
-    });
-    it('ensures navigator.languages is non-empty', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('navigator.languages');
-        expect(code).toContain("'en-US'");
-    });
-    it('normalizes Permissions.query for notifications', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('Permissions');
-        expect(code).toContain('notifications');
-    });
-    it('cleans automation artifacts', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('__playwright');
-        expect(code).toContain('__puppeteer');
-        expect(code).toContain("'cdc_'");
-        expect(code).toContain("'__cdc_'");
-    });
-    it('filters CDP patterns from Error.stack', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('puppeteer_evaluation_script');
-        expect(code).toContain("'pptr:'");
-        expect(code).toContain("'debugger://'");
-    });
-    it('neutralizes debugger statement traps', () => {
-        const code = generateStealthJs();
-        // Should patch Function constructor with new.target / Reflect.construct
-        expect(code).toContain('_OrigFunction');
-        expect(code).toContain('_PatchedFunction');
-        expect(code).toContain('new.target');
-        expect(code).toContain('Reflect.construct');
-        // Should patch eval
-        expect(code).toContain('_origEval');
-        expect(code).toContain('_patchedEval');
-        // Regex to strip debugger (lookbehind for statement boundaries)
-        expect(code).toContain('_debuggerRe');
-    });
-    it('uses shared toString disguise via WeakMap', () => {
-        const code = generateStealthJs();
-        // Shared infrastructure at the top of the IIFE
-        expect(code).toContain('_origToString');
-        expect(code).toContain('WeakMap');
-        expect(code).toContain('_disguised');
-        expect(code).toContain('_disguise');
-        // Should NOT have per-instance toString overrides on Function/eval
-        // (they go through _disguise instead)
-    });
-    it('defends console method fingerprinting', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('_consoleMethods');
-        expect(code).toContain("'log'");
-        expect(code).toContain("'warn'");
-        expect(code).toContain("'error'");
-        expect(code).toContain('[native code]');
-        // Uses saved _origToString reference
-        expect(code).toContain('_origToString.call');
-    });
-    it('defends window dimension detection', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('outerWidth');
-        expect(code).toContain('outerHeight');
-        expect(code).toContain('innerWidth');
-        expect(code).toContain('innerHeight');
-    });
-    it('filters Performance API entries', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('getEntries');
-        expect(code).toContain('getEntriesByType');
-        expect(code).toContain('getEntriesByName');
-        expect(code).toContain('_suspiciousPatterns');
-    });
-    it('cleans document $cdc_ properties', () => {
-        const code = generateStealthJs();
-        expect(code).toContain("'$cdc_'");
-        expect(code).toContain("'$chrome_'");
-    });
-    it('patches iframe contentWindow.chrome consistency', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('contentWindow');
-        expect(code).toContain('HTMLIFrameElement');
-    });
-    it('uses non-enumerable guard flag on EventTarget.prototype', () => {
-        const code = generateStealthJs();
-        expect(code).toContain('EventTarget.prototype');
-        expect(code).toContain("'__lsn'");
-        expect(code).toContain('enumerable: false');
-    });
-    it('generates syntactically valid JavaScript', () => {
-        const code = generateStealthJs();
-        // new Function() parses the code without executing it in a real
-        // browser context, catching syntax errors from template literal issues.
-        expect(() => new Function(code)).not.toThrow();
-    });
-});

package/dist/src/browser/target-errors.test.js

@@ -1,94 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { TargetError } from './target-errors.js';
-describe('TargetError', () => {
-    it('creates not_found error with code and hint', () => {
-        const err = new TargetError({
-            code: 'not_found',
-            message: 'ref=99 not found in DOM',
-            hint: 'Re-run `bycli browser state` to get a fresh snapshot.',
-        });
-        expect(err).toBeInstanceOf(Error);
-        expect(err.name).toBe('TargetError');
-        expect(err.code).toBe('not_found');
-        expect(err.message).toBe('ref=99 not found in DOM');
-        expect(err.hint).toContain('fresh snapshot');
-        expect(err.candidates).toBeUndefined();
-    });
-    it('creates selector_ambiguous error with candidates + matches_n', () => {
-        const err = new TargetError({
-            code: 'selector_ambiguous',
-            message: 'CSS selector ".btn" matched 3 elements',
-            hint: 'Use a more specific selector, or pass --nth.',
-            candidates: ['<button> "Login"', '<button> "Sign Up"', '<button> "Cancel"'],
-            matches_n: 3,
-        });
-        expect(err.code).toBe('selector_ambiguous');
-        expect(err.candidates).toHaveLength(3);
-        expect(err.candidates[0]).toContain('Login');
-        expect(err.matches_n).toBe(3);
-    });
-    it('creates invalid_selector error', () => {
-        const err = new TargetError({
-            code: 'invalid_selector',
-            message: 'Invalid CSS selector: >>> (unexpected token)',
-            hint: 'Check the selector syntax.',
-        });
-        expect(err.code).toBe('invalid_selector');
-        expect(err.message).toContain('Invalid CSS selector');
-    });
-    it('creates selector_not_found error with matches_n=0', () => {
-        const err = new TargetError({
-            code: 'selector_not_found',
-            message: 'CSS selector ".missing" matched 0 elements',
-            hint: 'Check the page or use browser find.',
-            matches_n: 0,
-        });
-        expect(err.code).toBe('selector_not_found');
-        expect(err.matches_n).toBe(0);
-    });
-    it('creates selector_nth_out_of_range error', () => {
-        const err = new TargetError({
-            code: 'selector_nth_out_of_range',
-            message: 'matched 3 elements, but --nth=5 is out of range',
-            hint: 'Use --nth between 0 and 2.',
-            matches_n: 3,
-        });
-        expect(err.code).toBe('selector_nth_out_of_range');
-        expect(err.matches_n).toBe(3);
-    });
-    it('creates stale_ref error', () => {
-        const err = new TargetError({
-            code: 'stale_ref',
-            message: 'ref=12 was <button>"Login" but now points to <div>"Header"',
-            hint: 'Re-run `bycli browser state` to refresh.',
-        });
-        expect(err.code).toBe('stale_ref');
-        expect(err.message).toContain('was <button>');
-    });
-    it('serializes to JSON for structured output', () => {
-        const err = new TargetError({
-            code: 'selector_ambiguous',
-            message: 'matched 3',
-            hint: 'be specific',
-            candidates: ['a', 'b'],
-            matches_n: 3,
-        });
-        const json = err.toJSON();
-        expect(json).toEqual({
-            code: 'selector_ambiguous',
-            message: 'matched 3',
-            hint: 'be specific',
-            candidates: ['a', 'b'],
-            matches_n: 3,
-        });
-    });
-    it('omits candidates from JSON when not present', () => {
-        const err = new TargetError({
-            code: 'not_found',
-            message: 'gone',
-            hint: 'refresh',
-        });
-        const json = err.toJSON();
-        expect(json).not.toHaveProperty('candidates');
-    });
-});

package/dist/src/browser/target-resolver.test.js

@@ -1,118 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveTargetJs } from './target-resolver.js';
-/**
- * Tests for the target resolver JS generator.
- *
- * Since resolveTargetJs() produces JS strings for browser evaluate(),
- * we test the generated JS by running it in a simulated DOM-like context
- * and verifying the structure of the output.
- */
-describe('resolveTargetJs', () => {
-    it('generates JS that returns structured resolution for numeric ref', () => {
-        const js = resolveTargetJs('12');
-        expect(js).toContain('data-bycli-ref');
-        expect(js).toContain('__bycli_ref_identity');
-        expect(js).toContain('"12"');
-    });
-    it('generates JS that handles CSS selector input', () => {
-        const js = resolveTargetJs('#submit-btn');
-        expect(js).toContain('querySelectorAll');
-        expect(js).toContain('"#submit-btn"');
-    });
-    it('generates JS with stale_ref detection for numeric refs', () => {
-        const js = resolveTargetJs('5');
-        expect(js).toContain('stale_ref');
-        expect(js).toContain('__bycli_ref_identity');
-    });
-    it('generates JS with ambiguity detection for CSS selectors', () => {
-        const js = resolveTargetJs('.btn');
-        expect(js).toContain('selector_ambiguous');
-        expect(js).toContain('candidates');
-    });
-    it('generates JS that propagates --nth option into the CSS branch', () => {
-        const js = resolveTargetJs('.btn', { nth: 2 });
-        expect(js).toContain('selector_nth_out_of_range');
-        // opt.nth=2 should be inlined so the runtime picks matches[2]
-        expect(js).toMatch(/const nth = 2;?/);
-    });
-    it('generates JS that enables firstOnMulti for read commands', () => {
-        const js = resolveTargetJs('.btn', { firstOnMulti: true });
-        expect(js).toContain('firstOnMulti = true');
-    });
-    it('generates JS with invalid_selector branch for CSS syntax errors', () => {
-        const js = resolveTargetJs('.btn');
-        expect(js).toContain('invalid_selector');
-    });
-    it('generates JS with selector_not_found branch for 0 matches', () => {
-        const js = resolveTargetJs('#does-not-exist');
-        expect(js).toContain('selector_not_found');
-    });
-    it('hands every non-numeric input to querySelectorAll (no regex shortlist)', () => {
-        // Inputs that the old isCssLike regex rejected — must all flow into the
-        // CSS branch so `find --css` and `get/click/type/select` accept the same surface.
-        for (const sel of [':root', '*', ':has(.foo)', '::shadow-root', '???']) {
-            const js = resolveTargetJs(sel);
-            expect(js).toContain('querySelectorAll');
-            // invalid selectors still route through invalid_selector at runtime,
-            // never through a frontend "Cannot parse target" rejection.
-            expect(js).not.toContain('Cannot parse target');
-        }
-    });
-    it('escapes ref value safely', () => {
-        const js = resolveTargetJs('"; alert(1); "');
-        // JSON.stringify should handle escaping
-        expect(js).not.toContain('alert(1); "');
-        expect(js).toContain('\\"');
-    });
-    it('tags every success envelope with match_level so agents can tell tiers apart', () => {
-        const numericJs = resolveTargetJs('7');
-        const cssJs = resolveTargetJs('.btn');
-        // Exact / reidentified emit the literal directly; stable flows through the
-        // classifier's `level` variable. All three strings must appear in the JS.
-        expect(numericJs).toContain("match_level: 'exact'");
-        expect(numericJs).toContain("match_level: 'reidentified'");
-        expect(numericJs).toContain("return 'stable'");
-        // Stable + exact share the same emit site (match_level: level) — make sure
-        // we didn't hardcode one of them and drop the other.
-        expect(numericJs).toContain('match_level: level');
-        // CSS path is always exact (selector ran successfully).
-        expect(cssJs).toContain("match_level: 'exact'");
-    });
-    it('cascading ref path — classifier + reidentifier are both wired in', () => {
-        const js = resolveTargetJs('3');
-        // Classifier distinguishes the three tiers
-        expect(js).toContain('function classifyMatch');
-        expect(js).toContain("return 'exact'");
-        expect(js).toContain("return 'stable'");
-        expect(js).toContain("return 'mismatch'");
-        // Strong id is the only thing that can rescue a drifted fingerprint
-        expect(js).toContain('hadStrongId');
-        // Reidentify searches live DOM with the same fingerprint shape the
-        // snapshot / find writers emit — id / testId / aria-label only.
-        expect(js).toContain('function reidentify');
-        expect(js).toContain('getElementById');
-        expect(js).toContain('[data-testid="');
-        expect(js).toContain('[aria-label="');
-        // Unique match required — never silently picks one of many candidates.
-        expect(js).toContain('candidates.length === 1');
-        // Recovered element is re-tagged + identity map refreshed so subsequent
-        // resolves land on 'exact' instead of re-walking the cascade.
-        expect(js).toContain("setAttribute('data-bycli-ref', ref)");
-        expect(js).toContain('identity[ref] = fingerprintOf(recovered)');
-    });
-    it('reidentify runs both when data-bycli-ref is missing AND when fingerprint is mismatched', () => {
-        const js = resolveTargetJs('9');
-        // Two call sites: one in the !el branch, one after classifyMatch returns mismatch.
-        const count = js.split('reidentify(fp)').length - 1;
-        expect(count).toBeGreaterThanOrEqual(2);
-    });
-    it('falls through to stale_ref only after reidentify exhausts', () => {
-        const js = resolveTargetJs('4');
-        // The stale_ref emit must sit *below* a reidentify attempt so the cascade
-        // is what produces the error — not the original strict check.
-        const reidentifyIdx = js.indexOf('const recovered = reidentify(fp);');
-        const staleIdx = js.indexOf("code: 'stale_ref'");
-        expect(reidentifyIdx).toBeGreaterThan(-1);
-        expect(staleIdx).toBeGreaterThan(reidentifyIdx);
-    });
-});

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

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildEvaluateExpression, wrapForEval } from './utils.js';
-describe('browser eval utils', () => {
-    it('keeps existing string eval wrapping behavior', () => {
-        expect(wrapForEval('21 + 21')).toBe('21 + 21');
-        expect(wrapForEval('() => 42')).toBe('(() => 42)()');
-    });
-    it('serializes function eval arguments as JSON', () => {
-        const code = buildEvaluateExpression((selector) => {
-            return document.querySelector(selector)?.textContent ?? null;
-        }, ['.title']);
-        expect(code).toContain('document.querySelector(selector)');
-        expect(code).toContain('(...[".title"])');
-    });
-    it('accepts compact async arrow functions', () => {
-        const fn = new Function('return async()=>42')();
-        expect(buildEvaluateExpression(fn)).toBe('(async()=>42)(...[])');
-    });
-    it('rejects string eval with stray args', () => {
-        expect(() => buildEvaluateExpression('document.title', ['ignored']))
-            .toThrow('use page.evaluate(fn, ...args)');
-    });
-    it('rejects non-JSON-serializable function args', () => {
-        const circular = {};
-        circular.self = circular;
-        expect(() => buildEvaluateExpression((value) => value, [circular]))
-            .toThrow('JSON-serializable');
-    });
-});

package/dist/src/browser/verify-fixture.test.js

@@ -1,219 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { deriveFixture, expandFixtureArgs, parseSeedArgs, validateRows, validateRowShape } from './verify-fixture.js';
-describe('validateRows', () => {
-    it('passes when rows meet all expectations', () => {
-        const fixture = {
-            expect: {
-                rowCount: { min: 1, max: 3 },
-                columns: ['id', 'title', 'url'],
-                types: { id: 'number', title: 'string', url: 'string' },
-                patterns: { url: '^https://' },
-                notEmpty: ['title', 'url'],
-            },
-        };
-        const rows = [
-            { id: 1, title: 'a', url: 'https://x.com/a' },
-            { id: 2, title: 'b', url: 'https://x.com/b' },
-        ];
-        expect(validateRows(rows, fixture)).toEqual([]);
-    });
-    it('reports rowCount below min', () => {
-        const failures = validateRows([], { expect: { rowCount: { min: 1 } } });
-        expect(failures).toHaveLength(1);
-        expect(failures[0]).toMatchObject({ rule: 'rowCount' });
-        expect(failures[0].detail).toContain('at least 1');
-    });
-    it('reports rowCount above max', () => {
-        const failures = validateRows([{}, {}, {}, {}], { expect: { rowCount: { max: 3 } } });
-        expect(failures).toHaveLength(1);
-        expect(failures[0].detail).toContain('at most 3');
-    });
-    it('reports missing columns per row', () => {
-        const failures = validateRows([{ a: 1 }, { a: 2, b: 3 }], { expect: { columns: ['a', 'b'] } });
-        // row 0 missing 'b', row 1 complete
-        expect(failures).toEqual([
-            { rule: 'column', detail: 'missing column "b"', rowIndex: 0 },
-        ]);
-    });
-    it('reports type mismatch including null', () => {
-        const failures = validateRows([{ a: 'abc' }, { a: null }, { a: 42 }], { expect: { types: { a: 'string' } } });
-        // row 0 string ok, row 1 null fail, row 2 number fail
-        expect(failures).toHaveLength(2);
-        expect(failures[0].rowIndex).toBe(1);
-        expect(failures[0].detail).toContain('null');
-        expect(failures[1].rowIndex).toBe(2);
-        expect(failures[1].detail).toContain('number');
-    });
-    it('accepts union types like "number|string"', () => {
-        const failures = validateRows([{ id: 1 }, { id: 'abc' }], { expect: { types: { id: 'number|string' } } });
-        expect(failures).toEqual([]);
-    });
-    it('accepts "any" as wildcard type', () => {
-        const failures = validateRows([{ v: 1 }, { v: 'x' }, { v: null }, { v: [1, 2] }], { expect: { types: { v: 'any' } } });
-        expect(failures).toEqual([]);
-    });
-    it('reports pattern mismatch with row index and truncated value', () => {
-        const failures = validateRows([{ url: 'https://ok.com' }, { url: 'not-a-url' }], { expect: { patterns: { url: '^https?://' } } });
-        expect(failures).toHaveLength(1);
-        expect(failures[0]).toMatchObject({ rule: 'pattern', rowIndex: 1 });
-        expect(failures[0].detail).toContain('not-a-url');
-    });
-    it('skips pattern check for null/undefined values', () => {
-        const failures = validateRows([{ url: null }, { url: undefined }], { expect: { patterns: { url: '^x' } } });
-        expect(failures).toEqual([]);
-    });
-    it('reports invalid regex without crashing', () => {
-        const failures = validateRows([{ a: 'x' }], { expect: { patterns: { a: '[unclosed' } } });
-        expect(failures.some((f) => f.rule === 'pattern' && f.detail.includes('invalid'))).toBe(true);
-    });
-    it('treats empty/whitespace/null as failing notEmpty', () => {
-        const failures = validateRows([{ t: '' }, { t: '   ' }, { t: null }, { t: 'ok' }], { expect: { notEmpty: ['t'] } });
-        expect(failures).toHaveLength(3);
-        expect(failures.map((f) => f.rowIndex)).toEqual([0, 1, 2]);
-    });
-    it('no failures when fixture has no expect block', () => {
-        expect(validateRows([{ anything: 1 }], {})).toEqual([]);
-    });
-    it('mustNotContain flags substring bleed in columns', () => {
-        const failures = validateRows([
-            { description: 'Lead engineer, 5 years exp. address: Shanghai. category: IT' },
-            { description: 'Clean text.' },
-        ], {
-            expect: {
-                mustNotContain: { description: ['address:', 'category:'] },
-            },
-        });
-        expect(failures).toHaveLength(2);
-        expect(failures.every((f) => f.rule === 'mustNotContain')).toBe(true);
-        expect(failures.every((f) => f.rowIndex === 0)).toBe(true);
-    });
-    it('mustNotContain skips null/undefined values', () => {
-        const failures = validateRows([{ description: null }, { description: undefined }], { expect: { mustNotContain: { description: ['x'] } } });
-        expect(failures).toEqual([]);
-    });
-    it('mustBeTruthy catches silent 0 / false / "" fallbacks', () => {
-        const failures = validateRows([{ count: 10 }, { count: 0 }, { count: false }, { count: '' }, { count: null }], { expect: { mustBeTruthy: ['count'] } });
-        expect(failures).toHaveLength(4);
-        expect(failures.every((f) => f.rule === 'mustBeTruthy')).toBe(true);
-        expect(failures.map((f) => f.rowIndex)).toEqual([1, 2, 3, 4]);
-    });
-});
-describe('validateRowShape', () => {
-    it('passes flat rows with a compact key set', () => {
-        const failures = validateRowShape([
-            { id: '1', title: 'A', author: { name: 'Ada' }, tags: ['ai', 'web'] },
-        ]);
-        expect(failures).toEqual([]);
-    });
-    it('reports rows with too many top-level keys', () => {
-        const row = Object.fromEntries(Array.from({ length: 13 }, (_, i) => [`k${i}`, i]));
-        const failures = validateRowShape([row]);
-        expect(failures).toEqual([
-            {
-                rule: 'shapeKeyCount',
-                detail: 'row has 13 top-level keys, expected at most 12',
-                rowIndex: 0,
-            },
-        ]);
-    });
-    it('reports nesting deeper than one level', () => {
-        const failures = validateRowShape([
-            { title: 'A', stats: { author: { name: 'Ada' } } },
-        ]);
-        expect(failures).toEqual([
-            {
-                rule: 'shapeDepth',
-                detail: '"stats" nesting depth is 2, expected at most 1',
-                rowIndex: 0,
-            },
-        ]);
-    });
-    it('reports nested id-shaped fields even when one-level nesting is otherwise allowed', () => {
-        const failures = validateRowShape([
-            { title: 'A', author: { user_id: 'u1', name: 'Ada' } },
-        ]);
-        expect(failures).toEqual([
-            {
-                rule: 'shapeNestedId',
-                detail: 'id-shaped field "author.user_id" must be a top-level row key',
-                rowIndex: 0,
-            },
-        ]);
-    });
-});
-describe('deriveFixture', () => {
-    it('returns rowCount.min=0 when rows are empty', () => {
-        expect(deriveFixture([])).toEqual({ expect: { rowCount: { min: 0 } } });
-    });
-    it('extracts columns from first row and infers types per column', () => {
-        const fixture = deriveFixture([
-            { id: 1, title: 'a', url: 'https://x' },
-            { id: 2, title: 'b', url: 'https://y' },
-        ]);
-        expect(fixture.expect?.columns).toEqual(['id', 'title', 'url']);
-        expect(fixture.expect?.types).toEqual({
-            id: 'number',
-            title: 'string',
-            url: 'string',
-        });
-        expect(fixture.expect?.rowCount).toEqual({ min: 1 });
-    });
-    it('unions mixed types across rows as "a|b"', () => {
-        const fixture = deriveFixture([
-            { v: 1 },
-            { v: 'two' },
-            { v: null },
-        ]);
-        expect(fixture.expect?.types?.v).toBe('null|number|string');
-    });
-    it('embeds args when provided', () => {
-        const fixture = deriveFixture([{ x: 1 }], { limit: 5 });
-        expect(fixture.args).toEqual({ limit: 5 });
-    });
-    it('embeds positional argv array when provided', () => {
-        const fixture = deriveFixture([{ x: 1 }], ['123', '--limit', '3']);
-        expect(fixture.args).toEqual(['123', '--limit', '3']);
-    });
-    it('does not add patterns or notEmpty automatically', () => {
-        const fixture = deriveFixture([{ a: 'x' }]);
-        expect(fixture.expect?.patterns).toBeUndefined();
-        expect(fixture.expect?.notEmpty).toBeUndefined();
-    });
-});
-describe('expandFixtureArgs', () => {
-    it('returns [] for undefined', () => {
-        expect(expandFixtureArgs(undefined)).toEqual([]);
-    });
-    it('expands object form as --key value pairs', () => {
-        expect(expandFixtureArgs({ limit: 3, sort: 'hot' })).toEqual(['--limit', '3', '--sort', 'hot']);
-    });
-    it('passes array form verbatim, stringifying values', () => {
-        expect(expandFixtureArgs(['123456', '--limit', 3])).toEqual(['123456', '--limit', '3']);
-    });
-    it('handles empty object and empty array', () => {
-        expect(expandFixtureArgs({})).toEqual([]);
-        expect(expandFixtureArgs([])).toEqual([]);
-    });
-    it('preserves positional + flag mix (e.g. <tid> --limit 3)', () => {
-        expect(expandFixtureArgs(['https://example.com/thread-1', '--comments', '5'])).toEqual([
-            'https://example.com/thread-1',
-            '--comments',
-            '5',
-        ]);
-    });
-});
-describe('parseSeedArgs', () => {
-    it('treats plain text as one positional arg', () => {
-        expect(parseSeedArgs('bycli-verify')).toEqual(['bycli-verify']);
-    });
-    it('accepts JSON array seed args', () => {
-        expect(parseSeedArgs('["subject", "--limit", 3]')).toEqual(['subject', '--limit', 3]);
-    });
-    it('accepts JSON object seed args', () => {
-        expect(parseSeedArgs('{"limit":3,"sort":"hot"}')).toEqual({ limit: 3, sort: 'hot' });
-    });
-    it('ignores empty input', () => {
-        expect(parseSeedArgs(undefined)).toBeUndefined();
-        expect(parseSeedArgs('   ')).toBeUndefined();
-    });
-});