@sovovs/bycli 1.8.0 → 2.0.0

package/dist/src/observation/artifact.test.js

@@ -1,121 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { buildTraceReceipt, exportObservationSession, getTraceDirectory } from './artifact.js';
-import { ObservationSession } from './session.js';
-describe('observation artifact', () => {
-    let baseDir;
-    beforeEach(() => {
-        baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-trace-'));
-    });
-    afterEach(() => {
-        fs.rmSync(baseDir, { recursive: true, force: true });
-    });
-    it('writes artifacts under profile-scoped trace directory', () => {
-        const session = new ObservationSession({
-            id: 'trace-1',
-            scope: {
-                contextId: 'work',
-                session: 'site:demo',
-                site: 'demo',
-                command: 'demo/run',
-                adapterSourcePath: '/tmp/clis/demo/run.js',
-            },
-            now: () => 1_700_000_000_000,
-        });
-        session.record({ stream: 'action', name: 'command', phase: 'start' });
-        session.record({ stream: 'screenshot', format: 'png', data: Buffer.from('png-bytes').toString('base64'), label: 'final' });
-        session.record({
-            stream: 'network',
-            url: 'https://api.test/data?token=secret',
-            method: 'GET',
-            status: 500,
-            requestHeaders: { authorization: 'Bearer secret' },
-            responseBody: { ok: false },
-        });
-        session.record({ stream: 'console', level: 'error', text: 'boom password=supersecret' });
-        const result = exportObservationSession(session, { baseDir, error: new Error('failed') });
-        expect(result.dir).toBe(getTraceDirectory('work', 'trace-1', baseDir));
-        expect(fs.existsSync(path.join(result.dir, 'trace.jsonl'))).toBe(true);
-        expect(fs.existsSync(path.join(result.dir, 'network.jsonl'))).toBe(true);
-        expect(fs.existsSync(path.join(result.dir, 'console.jsonl'))).toBe(true);
-        expect(fs.existsSync(result.receiptPath)).toBe(true);
-        expect(fs.readFileSync(path.join(result.dir, 'screenshots', '0001.png'), 'utf-8')).toBe('png-bytes');
-        const trace = fs.readFileSync(path.join(result.dir, 'trace.jsonl'), 'utf-8');
-        expect(trace).toContain('token=[REDACTED]');
-        expect(trace).toContain('"authorization":"[REDACTED]"');
-        expect(trace).not.toContain('supersecret');
-        const summary = fs.readFileSync(result.summaryPath, 'utf-8');
-        expect(summary).toContain('schemaVersion: 1');
-        expect(summary).toContain('bycliVersion:');
-        expect(summary).toContain('expiresAt:');
-        expect(summary).toContain('status: failure');
-        expect(summary).toContain('contextId: "work"');
-        expect(summary).toContain('adapterSourcePath: "/tmp/clis/demo/run.js"');
-        expect(summary).toContain('adapterSourcePathExists: false');
-        expect(summary).toContain('## Failed Network');
-        expect(summary).toContain('500 GET https://api.test/data?token=[REDACTED]');
-        expect(summary).toContain('network: 1');
-        const receipt = JSON.parse(fs.readFileSync(result.receiptPath, 'utf-8'));
-        expect(receipt).toMatchObject({
-            schemaVersion: 1,
-            bycliVersion: expect.any(String),
-            traceId: 'trace-1',
-            traceDir: result.dir,
-            summaryPath: result.summaryPath,
-            receiptPath: result.receiptPath,
-            status: 'failure',
-            expiresAt: expect.any(String),
-            scope: {
-                contextId: 'work',
-                session: 'site:demo',
-                site: 'demo',
-                command: 'demo/run',
-                adapterSourcePath: '/tmp/clis/demo/run.js',
-            },
-            error: { message: 'failed' },
-        });
-    });
-    it('builds a compact trace receipt', () => {
-        const receipt = buildTraceReceipt({
-            traceId: 'trace-1',
-            dir: '/tmp/bycli/profiles/work/traces/trace-1',
-            summaryPath: '/tmp/bycli/profiles/work/traces/trace-1/summary.md',
-            receiptPath: '/tmp/bycli/profiles/work/traces/trace-1/receipt.json',
-        }, 'failure', new Error('failed with token=secret'), {
-            createdAt: '2026-05-03T00:00:00.000Z',
-            retentionPolicy: { maxAgeDays: 7 },
-        });
-        expect(receipt).toMatchObject({
-            schemaVersion: 1,
-            bycliVersion: expect.any(String),
-            traceId: 'trace-1',
-            traceDir: '/tmp/bycli/profiles/work/traces/trace-1',
-            receiptPath: '/tmp/bycli/profiles/work/traces/trace-1/receipt.json',
-            status: 'failure',
-            expiresAt: '2026-05-10T00:00:00.000Z',
-        });
-        expect(receipt.error?.message).toContain('token=[REDACTED]');
-    });
-    it('prunes older traces after export while protecting the exported trace', () => {
-        const oldTraceDir = getTraceDirectory('work', 'old-trace', baseDir);
-        fs.mkdirSync(oldTraceDir, { recursive: true });
-        fs.writeFileSync(path.join(oldTraceDir, 'receipt.json'), JSON.stringify({
-            createdAt: '2026-04-01T00:00:00.000Z',
-        }), 'utf-8');
-        fs.writeFileSync(path.join(oldTraceDir, 'trace.jsonl'), '{}\n', 'utf-8');
-        const session = new ObservationSession({
-            id: 'new-trace',
-            scope: { contextId: 'work', session: 'site:demo' },
-            now: () => Date.parse('2026-05-03T00:00:00.000Z'),
-        });
-        session.record({ stream: 'action', name: 'command', phase: 'start' });
-        const result = exportObservationSession(session, {
-            baseDir,
-            retentionPolicy: { maxAgeDays: 365, maxCountPerProfile: 1, maxBytesPerProfile: '500MB' },
-        });
-        expect(fs.existsSync(oldTraceDir)).toBe(false);
-        expect(fs.existsSync(result.dir)).toBe(true);
-    });
-});

package/dist/src/observation/manager.test.js

@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ObservationManager } from './manager.js';
-describe('ObservationManager', () => {
-    it('indexes sessions by id and scope', () => {
-        const manager = new ObservationManager();
-        const work = manager.start({ id: 'work-1', scope: { contextId: 'work', session: 'site:x', target: 'tab-1' } });
-        manager.start({ id: 'personal-1', scope: { contextId: 'personal', session: 'site:x', target: 'tab-2' } });
-        expect(manager.get('work-1')).toBe(work);
-        expect(manager.findByScope({ contextId: 'work', session: 'site:x' }).map((session) => session.id)).toEqual(['work-1']);
-        expect(manager.stop('work-1')).toBe(work);
-        expect(manager.get('work-1')).toBeUndefined();
-    });
-});

package/dist/src/observation/redaction.test.js

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { redactHeaders, redactUrl, redactValue } from './redaction.js';
-describe('observation redaction', () => {
-    it('redacts sensitive headers by default', () => {
-        expect(redactHeaders({
-            authorization: 'Bearer secret-token',
-            cookie: 'sid=abc',
-            'set-cookie': 'sid=abc',
-            accept: 'application/json',
-        })).toEqual({
-            authorization: '[REDACTED]',
-            cookie: '[REDACTED]',
-            'set-cookie': '[REDACTED]',
-            accept: 'application/json',
-        });
-    });
-    it('redacts sensitive url query params', () => {
-        expect(redactUrl('https://x.test/api?token=abc&ok=1&password=secret'))
-            .toBe('https://x.test/api?token=[REDACTED]&ok=1&password=[REDACTED]');
-    });
-    it('redacts password and token fields recursively', () => {
-        expect(redactValue({
-            user: 'alice',
-            password: 'secret',
-            nested: { access_token: 'abc123456789', value: 'safe' },
-        })).toEqual({
-            user: 'alice',
-            password: '[REDACTED]',
-            nested: { access_token: '[REDACTED]', value: 'safe' },
-        });
-    });
-});

package/dist/src/observation/retention.test.js

@@ -1,118 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { parseByteSize, pruneTraceArtifacts } from './retention.js';
-describe('trace artifact retention', () => {
-    let tmpDir;
-    let tracesDir;
-    beforeEach(() => {
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-trace-retention-'));
-        tracesDir = path.join(tmpDir, 'profiles', 'default', 'traces');
-        fs.mkdirSync(tracesDir, { recursive: true });
-    });
-    afterEach(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it('parses byte budgets with units', () => {
-        expect(parseByteSize(128)).toBe(128);
-        expect(parseByteSize('128')).toBe(128);
-        expect(parseByteSize('2KB')).toBe(2 * 1024);
-        expect(parseByteSize('1.5MB')).toBe(Math.floor(1.5 * 1024 * 1024));
-        expect(parseByteSize('1 GB')).toBe(1024 ** 3);
-        expect(() => parseByteSize('many')).toThrow('Invalid byte size');
-    });
-    it('prunes traces older than the age budget', () => {
-        const now = Date.parse('2026-05-03T00:00:00.000Z');
-        const old = createTraceDir('old', '2026-04-24T00:00:00.000Z');
-        const recent = createTraceDir('recent', '2026-05-02T00:00:00.000Z');
-        const result = pruneTraceArtifacts(tracesDir, {
-            now: () => now,
-            policy: { maxAgeDays: 7, maxCountPerProfile: 20, maxBytesPerProfile: '500MB' },
-            warn: vi.fn(),
-        });
-        expect(result.deleted).toEqual([old]);
-        expect(fs.existsSync(old)).toBe(false);
-        expect(fs.existsSync(recent)).toBe(true);
-    });
-    it('prunes oldest traces over the count budget', () => {
-        const oldest = createTraceDir('oldest', '2026-05-01T00:00:00.000Z');
-        const middle = createTraceDir('middle', '2026-05-02T00:00:00.000Z');
-        const newest = createTraceDir('newest', '2026-05-03T00:00:00.000Z');
-        const result = pruneTraceArtifacts(tracesDir, {
-            now: () => Date.parse('2026-05-03T12:00:00.000Z'),
-            policy: { maxAgeDays: 30, maxCountPerProfile: 2, maxBytesPerProfile: '500MB' },
-            warn: vi.fn(),
-        });
-        expect(result.deleted).toEqual([oldest]);
-        expect(fs.existsSync(oldest)).toBe(false);
-        expect(fs.existsSync(middle)).toBe(true);
-        expect(fs.existsSync(newest)).toBe(true);
-    });
-    it('prunes oldest traces over the byte budget', () => {
-        const oldest = createTraceDir('oldest', '2026-05-01T00:00:00.000Z', 512);
-        const middle = createTraceDir('middle', '2026-05-02T00:00:00.000Z', 64);
-        const newest = createTraceDir('newest', '2026-05-03T00:00:00.000Z', 64);
-        const budget = directorySize(middle) + directorySize(newest) + 1;
-        const result = pruneTraceArtifacts(tracesDir, {
-            now: () => Date.parse('2026-05-03T12:00:00.000Z'),
-            policy: { maxAgeDays: 30, maxCountPerProfile: 20, maxBytesPerProfile: budget },
-            warn: vi.fn(),
-        });
-        expect(result.deleted).toEqual([oldest]);
-        expect(fs.existsSync(oldest)).toBe(false);
-        expect(fs.existsSync(middle)).toBe(true);
-        expect(fs.existsSync(newest)).toBe(true);
-    });
-    it('falls back to directory mtime when receipt is missing', () => {
-        const now = Date.parse('2026-05-03T00:00:00.000Z');
-        const old = createTraceDir('old-no-receipt', undefined);
-        const recent = createTraceDir('recent', '2026-05-02T00:00:00.000Z');
-        const oldDate = new Date('2026-04-20T00:00:00.000Z');
-        fs.utimesSync(old, oldDate, oldDate);
-        const result = pruneTraceArtifacts(tracesDir, {
-            now: () => now,
-            policy: { maxAgeDays: 7, maxCountPerProfile: 20, maxBytesPerProfile: '500MB' },
-            warn: vi.fn(),
-        });
-        expect(result.deleted).toEqual([old]);
-        expect(fs.existsSync(old)).toBe(false);
-        expect(fs.existsSync(recent)).toBe(true);
-    });
-    it('does not delete the protected trace exported by the current run', () => {
-        const old = createTraceDir('oldest', '2026-05-01T00:00:00.000Z');
-        const current = createTraceDir('current', '2026-04-01T00:00:00.000Z', 1024);
-        const result = pruneTraceArtifacts(tracesDir, {
-            now: () => Date.parse('2026-05-03T12:00:00.000Z'),
-            policy: { maxAgeDays: 0, maxCountPerProfile: 0, maxBytesPerProfile: 1 },
-            protectedTraceDirs: [current],
-            warn: vi.fn(),
-        });
-        expect(result.deleted).toEqual([old]);
-        expect(fs.existsSync(old)).toBe(false);
-        expect(fs.existsSync(current)).toBe(true);
-    });
-    function createTraceDir(name, createdAt, payloadBytes = 8) {
-        const dir = path.join(tracesDir, name);
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(path.join(dir, 'trace.jsonl'), 'x'.repeat(payloadBytes), 'utf-8');
-        if (createdAt) {
-            fs.writeFileSync(path.join(dir, 'receipt.json'), JSON.stringify({ createdAt }, null, 2), 'utf-8');
-            const date = new Date(createdAt);
-            fs.utimesSync(dir, date, date);
-        }
-        return dir;
-    }
-});
-function directorySize(dir) {
-    let total = 0;
-    for (const name of fs.readdirSync(dir)) {
-        const item = path.join(dir, name);
-        const stat = fs.lstatSync(item);
-        if (stat.isDirectory())
-            total += directorySize(item);
-        else
-            total += stat.size;
-    }
-    return total;
-}

package/dist/src/observation/ring-buffer.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { RingBuffer } from './ring-buffer.js';
-describe('RingBuffer', () => {
-    it('keeps items in event order and filters by time window', () => {
-        let now = 10_000;
-        const buffer = new RingBuffer({ maxAgeMs: 5_000, now: () => now });
-        buffer.push({ ts: 4_000, value: 'old' });
-        buffer.push({ ts: 7_000, value: 'kept' });
-        buffer.push({ ts: 9_000, value: 'new' });
-        expect(buffer.values().map((item) => item.value)).toEqual(['kept', 'new']);
-        expect(buffer.values({ since: 8_000 }).map((item) => item.value)).toEqual(['new']);
-        now = 13_000;
-        expect(buffer.values().map((item) => item.value)).toEqual(['new']);
-    });
-    it('caps by item count', () => {
-        const buffer = new RingBuffer({ maxItems: 2, maxAgeMs: 100_000, now: () => 10 });
-        buffer.push({ ts: 1, value: 1 });
-        buffer.push({ ts: 2, value: 2 });
-        buffer.push({ ts: 3, value: 3 });
-        expect(buffer.values().map((item) => item.value)).toEqual([2, 3]);
-    });
-});

package/dist/src/output.test.js

@@ -1,53 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
-import { render } from './output.js';
-describe('output TTY detection', () => {
-    const originalIsTTY = process.stdout.isTTY;
-    let logSpy;
-    beforeEach(() => {
-        logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: originalIsTTY, writable: true });
-        logSpy.mockRestore();
-    });
-    it('outputs YAML in non-TTY when format is default table', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-        // commanderAdapter always passes fmt:'table' as default — this must still trigger downgrade
-        render([{ name: 'alice', score: 10 }], { fmt: 'table', columns: ['name', 'score'] });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(out).toContain('name: alice');
-        expect(out).toContain('score: 10');
-    });
-    it('outputs table in TTY when format is default table', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: true, writable: true });
-        render([{ name: 'alice', score: 10 }], { fmt: 'table', columns: ['name', 'score'] });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(out).toContain('alice');
-    });
-    it('respects explicit -f json even in non-TTY', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-        render([{ name: 'alice' }], { fmt: 'json' });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(JSON.parse(out)).toEqual([{ name: 'alice' }]);
-    });
-    it('shows elapsed time when elapsed is 0', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: true, writable: true });
-        render([{ name: 'alice' }], { fmt: 'table', columns: ['name'], elapsed: 0 });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(out).toContain('0.0s');
-    });
-    it('explicit -f table overrides non-TTY auto-downgrade', () => {
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-        render([{ name: 'alice' }], { fmt: 'table', fmtExplicit: true, columns: ['name'] });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        // Should be table output, not YAML
-        expect(out).not.toContain('name: alice');
-        expect(out).toContain('alice');
-    });
-    it('prints single markdown payloads without wrapping them in a table', () => {
-        render([{ markdown: '# Title\n\nBody' }], { fmt: 'md' });
-        const out = logSpy.mock.calls.map((c) => c[0]).join('\n');
-        expect(out).toBe('# Title\n\nBody');
-        expect(out).not.toContain('| markdown |');
-    });
-});

package/dist/src/package-exports.test.js

@@ -1,112 +0,0 @@
-/**
- * Regression tests for package exports.
- *
- * Ensures adapter files use @sovovs/bycli/... package imports
- * (not fragile relative paths) and that all declared exports resolve
- * to real files. Prevents regressions like #788 / #791.
- */
-import { describe, it, expect } from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { builtinModules } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import ts from 'typescript';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const ROOT = path.resolve(__dirname, '..');
-const CLIS_DIR = path.join(ROOT, 'clis');
-/** Recursively collect all JS adapter files in a directory. */
-function collectAdapterFiles(dir, opts) {
-    const results = [];
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            results.push(...collectAdapterFiles(full, opts));
-        }
-        else if (entry.name.endsWith('.js') && !entry.name.endsWith('.d.js')) {
-            if (opts?.excludeTests && (entry.name.endsWith('.test.js') || entry.name.startsWith('test-')))
-                continue;
-            results.push(full);
-        }
-    }
-    return results;
-}
-const ALLOWED_BARE_IMPORTS = new Set([
-    '@sovovs/bycli',
-    ...builtinModules.flatMap((name) => name.startsWith('node:')
-        ? [name, name.slice(5)]
-        : [name, `node:${name}`]),
-]);
-function isAllowedImport(specifier) {
-    return specifier.startsWith('./')
-        || specifier.startsWith('../')
-        || specifier.startsWith('/')
-        || specifier.startsWith('@sovovs/bycli/')
-        || ALLOWED_BARE_IMPORTS.has(specifier);
-}
-/** Forbidden relative import patterns that should have been replaced.
- * Uses (?:\.\./)+ to catch any depth of ../ traversal.
- * Covers: import/export from, vi.mock(), vi.importActual(). */
-const FORBIDDEN_PATTERNS = [
-    /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+src\//,
-    /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+browser\//,
-    /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+download\//,
-    /(?:from|mock|importActual)\s*\(?['"](?:\.\.\/)+pipeline\//,
-];
-describe('adapter imports use package exports', () => {
-    const adapterFiles = collectAdapterFiles(CLIS_DIR);
-    const runtimeAdapterFiles = collectAdapterFiles(CLIS_DIR, { excludeTests: true });
-    it('found adapter files to check', () => {
-        expect(adapterFiles.length).toBeGreaterThan(100);
-    });
-    it('no adapter uses relative imports to src/, browser/, download/, or pipeline/', () => {
-        const violations = [];
-        for (const file of adapterFiles) {
-            const content = fs.readFileSync(file, 'utf-8');
-            for (const pattern of FORBIDDEN_PATTERNS) {
-                if (pattern.test(content)) {
-                    const rel = path.relative(ROOT, file);
-                    const match = content.match(pattern)?.[0];
-                    violations.push(`${rel}: ${match}`);
-                }
-            }
-        }
-        expect(violations).toEqual([]);
-    });
-    it('non-test adapters only import node builtins, relative modules, or bycli public APIs', () => {
-        const violations = [];
-        for (const file of runtimeAdapterFiles) {
-            const source = fs.readFileSync(file, 'utf-8');
-            const module = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
-            for (const stmt of module.statements) {
-                if (!ts.isImportDeclaration(stmt) && !ts.isExportDeclaration(stmt))
-                    continue;
-                const specifier = stmt.moduleSpecifier?.getText(module).slice(1, -1);
-                if (specifier && !isAllowedImport(specifier)) {
-                    violations.push({
-                        file: path.relative(ROOT, file),
-                        specifier,
-                    });
-                }
-            }
-        }
-        expect(violations).toEqual([]);
-    });
-});
-describe('package.json exports resolve to real files', () => {
-    const pkgJson = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
-    const exports = pkgJson.exports;
-    it('has exports defined', () => {
-        expect(Object.keys(exports).length).toBeGreaterThan(5);
-    });
-    for (const [exportPath, target] of Object.entries(exports)) {
-        it(`export "${exportPath}" → ${target} has a source file`, () => {
-            // Export targets point to dist/ (compiled). Verify the source .ts exists.
-            // dist/src/foo.js → src/foo.ts
-            const sourcePath = target
-                .replace(/^\.\/dist\//, './')
-                .replace(/\.js$/, '.ts');
-            const fullPath = path.join(ROOT, sourcePath);
-            expect(fs.existsSync(fullPath), `Missing source: ${sourcePath}`).toBe(true);
-        });
-    }
-});

package/dist/src/pipeline/executor.test.js

@@ -1,182 +0,0 @@
-/**
- * Tests for pipeline/executor.ts: pipeline execution with mock page.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { executePipeline } from './index.js';
-import { ConfigError } from '../errors.js';
-/** Create a minimal mock page for testing */
-function createMockPage(overrides = {}) {
-    return {
-        goto: vi.fn(),
-        evaluate: vi.fn().mockResolvedValue(null),
-        fetchJson: vi.fn().mockResolvedValue(null),
-        getCookies: vi.fn().mockResolvedValue([]),
-        snapshot: vi.fn().mockResolvedValue(''),
-        click: vi.fn(),
-        typeText: vi.fn(),
-        fillText: vi.fn(),
-        pressKey: vi.fn(),
-        getFormState: vi.fn().mockResolvedValue({}),
-        wait: vi.fn(),
-        tabs: vi.fn().mockResolvedValue([]),
-        selectTab: vi.fn(),
-        networkRequests: vi.fn().mockResolvedValue([]),
-        consoleMessages: vi.fn().mockResolvedValue(''),
-        scroll: vi.fn(),
-        scrollTo: vi.fn(),
-        autoScroll: vi.fn(),
-        installInterceptor: vi.fn(),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        screenshot: vi.fn().mockResolvedValue(''),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-        ...overrides,
-    };
-}
-describe('executePipeline', () => {
-    it('returns null for empty pipeline', async () => {
-        const result = await executePipeline(null, []);
-        expect(result).toBeNull();
-    });
-    it('skips null/invalid steps', async () => {
-        const result = await executePipeline(null, [null, undefined, 42]);
-        expect(result).toBeNull();
-    });
-    it('executes navigate step', async () => {
-        const page = createMockPage();
-        await executePipeline(page, [
-            { navigate: 'https://example.com' },
-        ]);
-        expect(page.goto).toHaveBeenCalledWith('https://example.com');
-    });
-    it('executes evaluate + select pipeline', async () => {
-        const page = createMockPage({
-            evaluate: vi.fn().mockResolvedValue({ data: { list: [{ name: 'a' }, { name: 'b' }] } }),
-        });
-        const result = await executePipeline(page, [
-            { evaluate: '() => ({ data: { list: [{name: "a"}, {name: "b"}] } })' },
-            { select: 'data.list' },
-        ]);
-        expect(result).toEqual([{ name: 'a' }, { name: 'b' }]);
-    });
-    it('executes map step to transform items', async () => {
-        const page = createMockPage({
-            evaluate: vi.fn().mockResolvedValue([
-                { title: 'Hello', count: 10 },
-                { title: 'World', count: 20 },
-            ]),
-        });
-        const result = await executePipeline(page, [
-            { evaluate: 'test' },
-            { map: { name: '${{ item.title }}', score: '${{ item.count }}' } },
-        ]);
-        expect(result).toEqual([
-            { name: 'Hello', score: 10 },
-            { name: 'World', score: 20 },
-        ]);
-    });
-    it('runs inline select inside map step', async () => {
-        const page = createMockPage({
-            evaluate: vi.fn().mockResolvedValue({
-                posts: [
-                    { title: 'First', rank: 1 },
-                    { title: 'Second', rank: 2 },
-                ],
-            }),
-        });
-        const result = await executePipeline(page, [
-            { evaluate: 'test' },
-            {
-                map: {
-                    select: 'posts',
-                    title: '${{ item.title }}',
-                    rank: '${{ item.rank }}',
-                },
-            },
-        ]);
-        expect(result).toEqual([
-            { title: 'First', rank: 1 },
-            { title: 'Second', rank: 2 },
-        ]);
-    });
-    it('executes limit step', async () => {
-        const page = createMockPage({
-            evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
-        });
-        const result = await executePipeline(page, [
-            { evaluate: 'test' },
-            { limit: '3' },
-        ]);
-        expect(result).toEqual([1, 2, 3]);
-    });
-    it('executes sort step', async () => {
-        const page = createMockPage({
-            evaluate: vi.fn().mockResolvedValue([{ n: 3 }, { n: 1 }, { n: 2 }]),
-        });
-        const result = await executePipeline(page, [
-            { evaluate: 'test' },
-            { sort: { by: 'n', order: 'asc' } },
-        ]);
-        expect(result).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
-    });
-    it('executes sort step with desc order', async () => {
-        const page = createMockPage({
-            evaluate: vi.fn().mockResolvedValue([{ n: 1 }, { n: 3 }, { n: 2 }]),
-        });
-        const result = await executePipeline(page, [
-            { evaluate: 'test' },
-            { sort: { by: 'n', order: 'desc' } },
-        ]);
-        expect(result).toEqual([{ n: 3 }, { n: 2 }, { n: 1 }]);
-    });
-    it('executes wait step with number', async () => {
-        const page = createMockPage();
-        await executePipeline(page, [
-            { wait: 2 },
-        ]);
-        expect(page.wait).toHaveBeenCalledWith(2);
-    });
-    it('fails fast on unknown steps', async () => {
-        await expect(executePipeline(null, [
-            { unknownStep: 'test' },
-        ], { debug: true })).rejects.toBeInstanceOf(ConfigError);
-        await expect(executePipeline(null, [
-            { unknownStep: 'test' },
-        ], { debug: true })).rejects.toThrow('Unknown pipeline step "unknownStep"');
-    });
-    it('passes args through template rendering', async () => {
-        const page = createMockPage({
-            evaluate: vi.fn().mockResolvedValue([1, 2, 3, 4, 5]),
-        });
-        const result = await executePipeline(page, [
-            { evaluate: 'test' },
-            { limit: '${{ args.count }}' },
-        ], { args: { count: 2 } });
-        expect(result).toEqual([1, 2]);
-    });
-    it('click step calls page.click', async () => {
-        const page = createMockPage();
-        await executePipeline(page, [
-            { click: '@5' },
-        ]);
-        expect(page.click).toHaveBeenCalledWith('5');
-    });
-    it('fill step calls page.fillText with raw rendered text', async () => {
-        const page = createMockPage();
-        await executePipeline(page, [
-            { fill: { ref: '@5', text: 'line1\\n/ / ${{ args.tail }}' } },
-        ], { args: { tail: 'raw' } });
-        expect(page.fillText).toHaveBeenCalledWith('5', 'line1\\n/ / raw');
-    });
-    it('navigate preserves existing data through pipeline', async () => {
-        const page = createMockPage({
-            evaluate: vi.fn().mockResolvedValue([{ a: 1 }]),
-        });
-        const result = await executePipeline(page, [
-            { evaluate: 'test' },
-            { navigate: 'https://example.com' },
-        ]);
-        // navigate should preserve existing data
-        expect(result).toEqual([{ a: 1 }]);
-        expect(page.goto).toHaveBeenCalledWith('https://example.com');
-    });
-});