@jackwener/opencli 0.1.1 → 0.2.0

package/dist/pipeline/steps/tap.js

@@ -0,0 +1,130 @@
+/**
+ * Pipeline step: tap — declarative Store Action Bridge.
+ *
+ * Generates a self-contained IIFE that:
+ * 1. Injects fetch + XHR dual interception proxy
+ * 2. Finds the Pinia/Vuex store and calls the action
+ * 3. Captures the response matching the URL pattern
+ * 4. Auto-cleans up interception in finally block
+ * 5. Returns the captured data (optionally sub-selected)
+ */
+import { render } from '../template.js';
+export async function stepTap(page, params, data, args) {
+    const cfg = typeof params === 'object' ? params : {};
+    const storeName = String(render(cfg.store ?? '', { args, data }));
+    const actionName = String(render(cfg.action ?? '', { args, data }));
+    const capturePattern = String(render(cfg.capture ?? '', { args, data }));
+    const timeout = cfg.timeout ?? 5;
+    const selectPath = cfg.select ? String(render(cfg.select, { args, data })) : null;
+    const framework = cfg.framework ?? null;
+    const actionArgs = cfg.args ?? [];
+    if (!storeName || !actionName)
+        throw new Error('tap: store and action are required');
+    // Build select chain for the captured response
+    const selectChain = selectPath
+        ? selectPath.split('.').map((p) => `?.[${JSON.stringify(p)}]`).join('')
+        : '';
+    // Serialize action arguments
+    const actionArgsRendered = actionArgs.map((a) => {
+        const rendered = render(a, { args, data });
+        return JSON.stringify(rendered);
+    });
+    const actionCall = actionArgsRendered.length
+        ? `store[${JSON.stringify(actionName)}](${actionArgsRendered.join(', ')})`
+        : `store[${JSON.stringify(actionName)}]()`;
+    const js = `
+    async () => {
+      // ── 1. Setup capture proxy (fetch + XHR dual interception) ──
+      let captured = null;
+      const capturePattern = ${JSON.stringify(capturePattern)};
+
+      // Intercept fetch API
+      const origFetch = window.fetch;
+      window.fetch = async function(...fetchArgs) {
+        const resp = await origFetch.apply(this, fetchArgs);
+        try {
+          const url = typeof fetchArgs[0] === 'string' ? fetchArgs[0]
+            : fetchArgs[0] instanceof Request ? fetchArgs[0].url : String(fetchArgs[0]);
+          if (capturePattern && url.includes(capturePattern) && !captured) {
+            try { captured = await resp.clone().json(); } catch {}
+          }
+        } catch {}
+        return resp;
+      };
+
+      // Intercept XMLHttpRequest
+      const origXhrOpen = XMLHttpRequest.prototype.open;
+      const origXhrSend = XMLHttpRequest.prototype.send;
+      XMLHttpRequest.prototype.open = function(method, url) {
+        this.__tapUrl = String(url);
+        return origXhrOpen.apply(this, arguments);
+      };
+      XMLHttpRequest.prototype.send = function(body) {
+        if (capturePattern && this.__tapUrl?.includes(capturePattern)) {
+          const xhr = this;
+          const origHandler = xhr.onreadystatechange;
+          xhr.onreadystatechange = function() {
+            if (xhr.readyState === 4 && !captured) {
+              try { captured = JSON.parse(xhr.responseText); } catch {}
+            }
+            if (origHandler) origHandler.apply(this, arguments);
+          };
+          const origOnload = xhr.onload;
+          xhr.onload = function() {
+            if (!captured) { try { captured = JSON.parse(xhr.responseText); } catch {} }
+            if (origOnload) origOnload.apply(this, arguments);
+          };
+        }
+        return origXhrSend.apply(this, arguments);
+      };
+
+      try {
+        // ── 2. Find store ──
+        let store = null;
+        const storeName = ${JSON.stringify(storeName)};
+        const fw = ${JSON.stringify(framework)};
+
+        const app = document.querySelector('#app');
+        if (!fw || fw === 'pinia') {
+          try {
+            const pinia = app?.__vue_app__?.config?.globalProperties?.$pinia;
+            if (pinia?._s) store = pinia._s.get(storeName);
+          } catch {}
+        }
+        if (!store && (!fw || fw === 'vuex')) {
+          try {
+            const vuexStore = app?.__vue_app__?.config?.globalProperties?.$store
+              ?? app?.__vue__?.$store;
+            if (vuexStore) {
+              store = { [${JSON.stringify(actionName)}]: (...a) => vuexStore.dispatch(storeName + '/' + ${JSON.stringify(actionName)}, ...a) };
+            }
+          } catch {}
+        }
+
+        if (!store) return { error: 'Store not found: ' + storeName, hint: 'Page may not be fully loaded or store name may be incorrect' };
+        if (typeof store[${JSON.stringify(actionName)}] !== 'function') {
+          return { error: 'Action not found: ' + ${JSON.stringify(actionName)} + ' on store ' + storeName,
+            hint: 'Available: ' + Object.keys(store).filter(k => typeof store[k] === 'function' && !k.startsWith('$') && !k.startsWith('_')).join(', ') };
+        }
+
+        // ── 3. Call store action ──
+        await ${actionCall};
+
+        // ── 4. Wait for network response ──
+        const deadline = Date.now() + ${timeout} * 1000;
+        while (!captured && Date.now() < deadline) {
+          await new Promise(r => setTimeout(r, 200));
+        }
+      } finally {
+        // ── 5. Always restore originals ──
+        window.fetch = origFetch;
+        XMLHttpRequest.prototype.open = origXhrOpen;
+        XMLHttpRequest.prototype.send = origXhrSend;
+      }
+
+      if (!captured) return { error: 'No matching response captured for pattern: ' + capturePattern };
+      return captured${selectChain} ?? captured;
+    }
+  `;
+    return page.evaluate(js);
+}

package/dist/pipeline/steps/transform.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pipeline steps: data transforms — select, map, filter, sort, limit.
+ */
+export declare function stepSelect(_page: any, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepMap(_page: any, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepFilter(_page: any, params: any, data: any, args: Record<string, any>): Promise<any>;
+export declare function stepSort(_page: any, params: any, data: any, _args: Record<string, any>): Promise<any>;
+export declare function stepLimit(_page: any, params: any, data: any, args: Record<string, any>): Promise<any>;

package/dist/pipeline/steps/transform.js

@@ -0,0 +1,53 @@
+/**
+ * Pipeline steps: data transforms — select, map, filter, sort, limit.
+ */
+import { render, evalExpr } from '../template.js';
+export async function stepSelect(_page, params, data, args) {
+    const pathStr = String(render(params, { args, data }));
+    if (data && typeof data === 'object') {
+        let current = data;
+        for (const part of pathStr.split('.')) {
+            if (current && typeof current === 'object' && !Array.isArray(current))
+                current = current[part];
+            else if (Array.isArray(current) && /^\d+$/.test(part))
+                current = current[parseInt(part, 10)];
+            else
+                return null;
+        }
+        return current;
+    }
+    return data;
+}
+export async function stepMap(_page, params, data, args) {
+    if (!data || typeof data !== 'object')
+        return data;
+    let items = Array.isArray(data) ? data : [data];
+    if (!Array.isArray(data) && typeof data === 'object' && 'data' in data)
+        items = data.data;
+    const result = [];
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const row = {};
+        for (const [key, template] of Object.entries(params))
+            row[key] = render(template, { args, data, item, index: i });
+        result.push(row);
+    }
+    return result;
+}
+export async function stepFilter(_page, params, data, args) {
+    if (!Array.isArray(data))
+        return data;
+    return data.filter((item, i) => evalExpr(String(params), { args, item, index: i }));
+}
+export async function stepSort(_page, params, data, _args) {
+    if (!Array.isArray(data))
+        return data;
+    const key = typeof params === 'object' ? (params.by ?? '') : String(params);
+    const reverse = typeof params === 'object' ? params.order === 'desc' : false;
+    return [...data].sort((a, b) => { const va = a[key] ?? ''; const vb = b[key] ?? ''; const cmp = va < vb ? -1 : va > vb ? 1 : 0; return reverse ? -cmp : cmp; });
+}
+export async function stepLimit(_page, params, data, args) {
+    if (!Array.isArray(data))
+        return data;
+    return data.slice(0, Number(render(params, { args, data })));
+}

package/dist/pipeline/template.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pipeline template engine: ${{ ... }} expression rendering.
+ */
+export interface RenderContext {
+    args?: Record<string, any>;
+    data?: any;
+    item?: any;
+    index?: number;
+}
+export declare function render(template: any, ctx: RenderContext): any;
+export declare function evalExpr(expr: string, ctx: RenderContext): any;
+export declare function resolvePath(pathStr: string, ctx: RenderContext): any;
+/**
+ * Normalize JavaScript source for browser evaluate() calls.
+ */
+export declare function normalizeEvaluateSource(source: string): string;

package/dist/pipeline/template.js

@@ -0,0 +1,172 @@
+/**
+ * Pipeline template engine: ${{ ... }} expression rendering.
+ */
+export function render(template, ctx) {
+    if (typeof template !== 'string')
+        return template;
+    // Full expression: entire string is a single ${{ ... }}
+    // Use [^}] to prevent matching across }} boundaries (e.g. "${{ a }}-${{ b }}")
+    const fullMatch = template.match(/^\$\{\{\s*([^}]*(?:\}[^}][^}]*)*)\s*\}\}$/);
+    if (fullMatch && !template.includes('}}-') && !template.includes('}}${{'))
+        return evalExpr(fullMatch[1].trim(), ctx);
+    // Check if the entire string is a single expression (no other text around it)
+    const singleExpr = template.match(/^\$\{\{\s*([\s\S]*?)\s*\}\}$/);
+    if (singleExpr) {
+        // Verify it's truly a single expression (no other ${{ inside)
+        const inner = singleExpr[1];
+        if (!inner.includes('${{'))
+            return evalExpr(inner.trim(), ctx);
+    }
+    return template.replace(/\$\{\{\s*(.*?)\s*\}\}/g, (_m, expr) => String(evalExpr(expr.trim(), ctx)));
+}
+export function evalExpr(expr, ctx) {
+    const args = ctx.args ?? {};
+    const item = ctx.item ?? {};
+    const data = ctx.data;
+    const index = ctx.index ?? 0;
+    // ── Pipe filters: expr | filter1(arg) | filter2 ──
+    // Supports: default(val), join(sep), upper, lower, truncate(n), trim, replace(old,new)
+    if (expr.includes('|') && !expr.includes('||')) {
+        const segments = expr.split('|').map(s => s.trim());
+        const mainExpr = segments[0];
+        let result = resolvePath(mainExpr, { args, item, data, index });
+        for (let i = 1; i < segments.length; i++) {
+            result = applyFilter(segments[i], result);
+        }
+        return result;
+    }
+    // Arithmetic: index + 1
+    const arithMatch = expr.match(/^([\w][\w.]*)\s*([+\-*/])\s*(\d+)$/);
+    if (arithMatch) {
+        const [, varName, op, numStr] = arithMatch;
+        const val = resolvePath(varName, { args, item, data, index });
+        if (val !== null && val !== undefined) {
+            const numVal = Number(val);
+            const num = Number(numStr);
+            if (!isNaN(numVal)) {
+                switch (op) {
+                    case '+': return numVal + num;
+                    case '-': return numVal - num;
+                    case '*': return numVal * num;
+                    case '/': return num !== 0 ? numVal / num : 0;
+                }
+            }
+        }
+    }
+    // JS-like fallback expression: item.tweetCount || 'N/A'
+    const orMatch = expr.match(/^(.+?)\s*\|\|\s*(.+)$/);
+    if (orMatch) {
+        const left = evalExpr(orMatch[1].trim(), ctx);
+        if (left)
+            return left;
+        const right = orMatch[2].trim();
+        return right.replace(/^['"]|['"]$/g, '');
+    }
+    return resolvePath(expr, { args, item, data, index });
+}
+/**
+ * Apply a named filter to a value.
+ * Supported filters:
+ *   default(val), join(sep), upper, lower, truncate(n), trim,
+ *   replace(old,new), keys, length, first, last
+ */
+function applyFilter(filterExpr, value) {
+    const match = filterExpr.match(/^(\w+)(?:\((.+)\))?$/);
+    if (!match)
+        return value;
+    const [, name, rawArgs] = match;
+    const filterArg = rawArgs?.replace(/^['"]|['"]$/g, '') ?? '';
+    switch (name) {
+        case 'default': {
+            if (value === null || value === undefined || value === '') {
+                const intVal = parseInt(filterArg, 10);
+                if (!isNaN(intVal) && String(intVal) === filterArg.trim())
+                    return intVal;
+                return filterArg;
+            }
+            return value;
+        }
+        case 'join':
+            return Array.isArray(value) ? value.join(filterArg || ', ') : value;
+        case 'upper':
+            return typeof value === 'string' ? value.toUpperCase() : value;
+        case 'lower':
+            return typeof value === 'string' ? value.toLowerCase() : value;
+        case 'trim':
+            return typeof value === 'string' ? value.trim() : value;
+        case 'truncate': {
+            const n = parseInt(filterArg, 10) || 50;
+            return typeof value === 'string' && value.length > n ? value.slice(0, n) + '...' : value;
+        }
+        case 'replace': {
+            if (typeof value !== 'string')
+                return value;
+            const parts = rawArgs?.split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')) ?? [];
+            return parts.length >= 2 ? value.replaceAll(parts[0], parts[1]) : value;
+        }
+        case 'keys':
+            return value && typeof value === 'object' ? Object.keys(value) : value;
+        case 'length':
+            return Array.isArray(value) ? value.length : typeof value === 'string' ? value.length : value;
+        case 'first':
+            return Array.isArray(value) ? value[0] : value;
+        case 'last':
+            return Array.isArray(value) ? value[value.length - 1] : value;
+        default:
+            return value;
+    }
+}
+export function resolvePath(pathStr, ctx) {
+    const args = ctx.args ?? {};
+    const item = ctx.item ?? {};
+    const data = ctx.data;
+    const index = ctx.index ?? 0;
+    const parts = pathStr.split('.');
+    const rootName = parts[0];
+    let obj;
+    let rest;
+    if (rootName === 'args') {
+        obj = args;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'item') {
+        obj = item;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'data') {
+        obj = data;
+        rest = parts.slice(1);
+    }
+    else if (rootName === 'index')
+        return index;
+    else {
+        obj = item;
+        rest = parts;
+    }
+    for (const part of rest) {
+        if (obj && typeof obj === 'object' && !Array.isArray(obj))
+            obj = obj[part];
+        else if (Array.isArray(obj) && /^\d+$/.test(part))
+            obj = obj[parseInt(part, 10)];
+        else
+            return null;
+    }
+    return obj;
+}
+/**
+ * Normalize JavaScript source for browser evaluate() calls.
+ */
+export function normalizeEvaluateSource(source) {
+    const stripped = source.trim();
+    if (!stripped)
+        return '() => undefined';
+    if (stripped.startsWith('(') && stripped.endsWith(')()'))
+        return `() => (${stripped})`;
+    if (/^(async\s+)?\([^)]*\)\s*=>/.test(stripped))
+        return stripped;
+    if (/^(async\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=>/.test(stripped))
+        return stripped;
+    if (stripped.startsWith('function ') || stripped.startsWith('async function '))
+        return stripped;
+    return `() => (${stripped})`;
+}

package/dist/pipeline/template.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for the pipeline template engine: render, evalExpr, resolvePath.
+ */
+export {};

package/dist/pipeline/template.test.js

@@ -0,0 +1,120 @@
+/**
+ * Tests for the pipeline template engine: render, evalExpr, resolvePath.
+ */
+import { describe, it, expect } from 'vitest';
+import { render, evalExpr, resolvePath, normalizeEvaluateSource } from './template.js';
+describe('resolvePath', () => {
+    it('resolves args path', () => {
+        expect(resolvePath('args.limit', { args: { limit: 20 } })).toBe(20);
+    });
+    it('resolves nested args path', () => {
+        expect(resolvePath('args.query.keyword', { args: { query: { keyword: 'test' } } })).toBe('test');
+    });
+    it('resolves item path', () => {
+        expect(resolvePath('item.title', { item: { title: 'Hello' } })).toBe('Hello');
+    });
+    it('resolves implicit item path (no prefix)', () => {
+        expect(resolvePath('title', { item: { title: 'World' } })).toBe('World');
+    });
+    it('resolves index', () => {
+        expect(resolvePath('index', { index: 5 })).toBe(5);
+    });
+    it('resolves data path', () => {
+        expect(resolvePath('data.items', { data: { items: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('returns null for missing path', () => {
+        expect(resolvePath('args.missing', { args: {} })).toBeUndefined();
+    });
+    it('resolves array index', () => {
+        expect(resolvePath('data.0', { data: ['a', 'b'] })).toBe('a');
+    });
+});
+describe('evalExpr', () => {
+    it('evaluates default filter', () => {
+        expect(evalExpr('args.limit | default(20)', { args: {} })).toBe(20);
+    });
+    it('uses actual value over default', () => {
+        expect(evalExpr('args.limit | default(20)', { args: { limit: 10 } })).toBe(10);
+    });
+    it('evaluates string default', () => {
+        expect(evalExpr("args.name | default('unknown')", { args: {} })).toBe('unknown');
+    });
+    it('evaluates arithmetic: index + 1', () => {
+        expect(evalExpr('index + 1', { index: 0 })).toBe(1);
+    });
+    it('evaluates arithmetic: index * 2', () => {
+        expect(evalExpr('index * 2', { index: 5 })).toBe(10);
+    });
+    it('evaluates || fallback', () => {
+        expect(evalExpr("item.name || 'N/A'", { item: {} })).toBe('N/A');
+    });
+    it('evaluates || with truthy left', () => {
+        expect(evalExpr("item.name || 'N/A'", { item: { name: 'Alice' } })).toBe('Alice');
+    });
+    it('resolves simple path', () => {
+        expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
+    });
+    it('applies join filter', () => {
+        expect(evalExpr('item.tags | join(,)', { item: { tags: ['a', 'b', 'c'] } })).toBe('a,b,c');
+    });
+    it('applies upper filter', () => {
+        expect(evalExpr('item.name | upper', { item: { name: 'hello' } })).toBe('HELLO');
+    });
+    it('applies lower filter', () => {
+        expect(evalExpr('item.name | lower', { item: { name: 'HELLO' } })).toBe('hello');
+    });
+    it('applies truncate filter', () => {
+        expect(evalExpr('item.text | truncate(5)', { item: { text: 'Hello World!' } })).toBe('Hello...');
+    });
+    it('chains filters', () => {
+        expect(evalExpr('item.name | upper | truncate(3)', { item: { name: 'hello' } })).toBe('HEL...');
+    });
+    it('applies length filter', () => {
+        expect(evalExpr('item.items | length', { item: { items: [1, 2, 3] } })).toBe(3);
+    });
+});
+describe('render', () => {
+    it('renders full expression', () => {
+        expect(render('${{ args.limit }}', { args: { limit: 30 } })).toBe(30);
+    });
+    it('renders inline expression in string', () => {
+        expect(render('Hello ${{ item.name }}!', { item: { name: 'World' } })).toBe('Hello World!');
+    });
+    it('renders multiple inline expressions', () => {
+        expect(render('${{ item.first }}-${{ item.second }}', { item: { first: 'X', second: 'Y' } })).toBe('X-Y');
+    });
+    it('returns non-string values as-is', () => {
+        expect(render(42, {})).toBe(42);
+        expect(render(null, {})).toBeNull();
+        expect(render(undefined, {})).toBeUndefined();
+    });
+    it('returns full expression result as native type', () => {
+        expect(render('${{ args.list }}', { args: { list: [1, 2, 3] } })).toEqual([1, 2, 3]);
+    });
+    it('renders URL template', () => {
+        expect(render('https://api.example.com/search?q=${{ args.keyword }}', { args: { keyword: 'test' } })).toBe('https://api.example.com/search?q=test');
+    });
+});
+describe('normalizeEvaluateSource', () => {
+    it('wraps bare expression', () => {
+        expect(normalizeEvaluateSource('document.title')).toBe('() => (document.title)');
+    });
+    it('passes through arrow function', () => {
+        expect(normalizeEvaluateSource('() => 42')).toBe('() => 42');
+    });
+    it('passes through async arrow function', () => {
+        const src = 'async () => { return 1; }';
+        expect(normalizeEvaluateSource(src)).toBe(src);
+    });
+    it('passes through named function', () => {
+        const src = 'function foo() { return 1; }';
+        expect(normalizeEvaluateSource(src)).toBe(src);
+    });
+    it('wraps IIFE pattern', () => {
+        const src = '(async () => { return 1; })()';
+        expect(normalizeEvaluateSource(src)).toBe(`() => (${src})`);
+    });
+    it('handles empty string', () => {
+        expect(normalizeEvaluateSource('')).toBe('() => undefined');
+    });
+});

package/dist/pipeline/transform.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+export {};

package/dist/pipeline/transform.test.js

@@ -0,0 +1,90 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+import { describe, it, expect } from 'vitest';
+import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
+const SAMPLE_DATA = [
+    { title: 'Alpha', score: 10, author: 'Alice' },
+    { title: 'Beta', score: 30, author: 'Bob' },
+    { title: 'Gamma', score: 20, author: 'Charlie' },
+];
+describe('stepSelect', () => {
+    it('selects nested path', async () => {
+        const data = { result: { items: [1, 2, 3] } };
+        const result = await stepSelect(null, 'result.items', data, {});
+        expect(result).toEqual([1, 2, 3]);
+    });
+    it('selects array by index', async () => {
+        const data = { list: ['a', 'b', 'c'] };
+        const result = await stepSelect(null, 'list.1', data, {});
+        expect(result).toBe('b');
+    });
+    it('returns null for missing path', async () => {
+        const result = await stepSelect(null, 'missing.path', { foo: 1 }, {});
+        expect(result).toBeNull();
+    });
+    it('returns data as-is for non-object', async () => {
+        const result = await stepSelect(null, 'foo', 'string-data', {});
+        expect(result).toBe('string-data');
+    });
+});
+describe('stepMap', () => {
+    it('maps array items', async () => {
+        const result = await stepMap(null, {
+            name: '${{ item.title }}',
+            rank: '${{ index + 1 }}',
+        }, SAMPLE_DATA, {});
+        expect(result).toEqual([
+            { name: 'Alpha', rank: 1 },
+            { name: 'Beta', rank: 2 },
+            { name: 'Gamma', rank: 3 },
+        ]);
+    });
+    it('handles single object', async () => {
+        const result = await stepMap(null, {
+            name: '${{ item.title }}',
+        }, { title: 'Solo' }, {});
+        expect(result).toEqual([{ name: 'Solo' }]);
+    });
+    it('returns null/undefined as-is', async () => {
+        expect(await stepMap(null, { x: '${{ item.x }}' }, null, {})).toBeNull();
+    });
+});
+describe('stepFilter', () => {
+    it('filters by expression', async () => {
+        const result = await stepFilter(null, 'item.score', SAMPLE_DATA, {});
+        expect(result).toHaveLength(3); // all truthy
+    });
+    it('returns non-array as-is', async () => {
+        const result = await stepFilter(null, 'item.x', 'not-array', {});
+        expect(result).toBe('not-array');
+    });
+});
+describe('stepSort', () => {
+    it('sorts ascending by key', async () => {
+        const result = await stepSort(null, 'score', SAMPLE_DATA, {});
+        expect(result.map((r) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
+    });
+    it('sorts descending', async () => {
+        const result = await stepSort(null, { by: 'score', order: 'desc' }, SAMPLE_DATA, {});
+        expect(result.map((r) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
+    });
+    it('does not mutate original', async () => {
+        const original = [...SAMPLE_DATA];
+        await stepSort(null, 'score', SAMPLE_DATA, {});
+        expect(SAMPLE_DATA).toEqual(original);
+    });
+});
+describe('stepLimit', () => {
+    it('limits array to N items', async () => {
+        const result = await stepLimit(null, '2', SAMPLE_DATA, {});
+        expect(result).toHaveLength(2);
+    });
+    it('limits using template expression', async () => {
+        const result = await stepLimit(null, '${{ args.limit }}', SAMPLE_DATA, { limit: 1 });
+        expect(result).toHaveLength(1);
+    });
+    it('returns non-array as-is', async () => {
+        expect(await stepLimit(null, '5', 'string', {})).toBe('string');
+    });
+});

package/dist/pipeline.d.ts

@@ -1,9 +1,7 @@
 /**
- * YAML pipeline executor.
- * Steps: fetch, navigate, evaluate, map, filter, sort, limit, select, snapshot, click, type, wait, press, intercept.
+ * YAML pipeline executor — re-exports from modular pipeline system.
+ *
+ * This file exists for backward compatibility. All logic has been
+ * refactored into src/pipeline/ with modular step handlers.
  */
-export interface PipelineContext {
-    args?: Record<string, any>;
-    debug?: boolean;
-}
-export declare function executePipeline(page: any, pipeline: any[], ctx?: PipelineContext): Promise<any>;
+export { executePipeline, type PipelineContext } from './pipeline/index.js';