@sovovs/bycli 1.8.0 → 2.0.0

package/dist/src/pipeline/steps/download.test.js

@@ -1,102 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import * as os from 'node:os';
-import * as path from 'node:path';
-const { mockHttpDownload, mockYtdlpDownload, mockExportCookiesToNetscape } = vi.hoisted(() => ({
-    mockHttpDownload: vi.fn(),
-    mockYtdlpDownload: vi.fn(),
-    mockExportCookiesToNetscape: vi.fn(),
-}));
-vi.mock('../../download/index.js', async () => {
-    const actual = await vi.importActual('../../download/index.js');
-    return {
-        ...actual,
-        httpDownload: mockHttpDownload,
-        ytdlpDownload: mockYtdlpDownload,
-        exportCookiesToNetscape: mockExportCookiesToNetscape,
-    };
-});
-import { stepDownload } from './download.js';
-function createMockPage(getCookies) {
-    return {
-        goto: vi.fn(),
-        evaluate: vi.fn().mockResolvedValue(null),
-        fetchJson: vi.fn().mockResolvedValue(null),
-        getCookies,
-        snapshot: vi.fn().mockResolvedValue(''),
-        click: vi.fn(),
-        typeText: vi.fn(),
-        fillText: vi.fn(),
-        pressKey: vi.fn(),
-        scrollTo: 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(),
-        autoScroll: vi.fn(),
-        installInterceptor: vi.fn(),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        screenshot: vi.fn().mockResolvedValue(''),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-    };
-}
-describe('stepDownload', () => {
-    beforeEach(() => {
-        mockHttpDownload.mockReset();
-        mockHttpDownload.mockResolvedValue({ success: true, size: 2 });
-        mockYtdlpDownload.mockReset();
-        mockYtdlpDownload.mockResolvedValue({ success: true, size: 2 });
-        mockExportCookiesToNetscape.mockReset();
-    });
-    it('scopes browser cookies to each direct-download target domain', async () => {
-        const page = createMockPage(vi.fn().mockImplementation(async (opts) => {
-            const domain = opts?.domain ?? 'unknown';
-            return [{ name: 'sid', value: domain, domain }];
-        }));
-        await stepDownload(page, {
-            url: '${{ item.url }}',
-            dir: path.join(os.tmpdir(), 'bycli-download-test'),
-            filename: '${{ index }}.txt',
-            progress: false,
-            concurrency: 1,
-        }, [
-            { url: 'https://a.example/file-1.txt' },
-            { url: 'https://b.example/file-2.txt' },
-        ], {});
-        expect(mockHttpDownload).toHaveBeenNthCalledWith(1, 'https://a.example/file-1.txt', path.join(os.tmpdir(), 'bycli-download-test', '0.txt'), expect.objectContaining({ cookies: 'sid=a.example' }));
-        expect(mockHttpDownload).toHaveBeenNthCalledWith(2, 'https://b.example/file-2.txt', path.join(os.tmpdir(), 'bycli-download-test', '1.txt'), expect.objectContaining({ cookies: 'sid=b.example' }));
-    });
-    it('builds yt-dlp cookies from all target domains instead of only the first item', async () => {
-        const getCookies = vi.fn().mockImplementation(async (opts) => {
-            const domain = opts?.domain ?? 'unknown';
-            return [{
-                    name: `sid-${domain}`,
-                    value: domain,
-                    domain,
-                    path: '/',
-                    secure: false,
-                    httpOnly: false,
-                }];
-        });
-        const page = createMockPage(getCookies);
-        await stepDownload(page, {
-            url: '${{ item.url }}',
-            dir: '/tmp/bycli-download-test',
-            filename: '${{ index }}.mp4',
-            progress: false,
-            concurrency: 1,
-        }, [
-            { url: 'https://www.youtube.com/watch?v=one' },
-            { url: 'https://www.bilibili.com/video/BV1xx411c7mD' },
-        ], {});
-        expect(getCookies).toHaveBeenCalledWith({ domain: 'www.youtube.com' });
-        expect(getCookies).toHaveBeenCalledWith({ domain: 'www.bilibili.com' });
-        expect(mockExportCookiesToNetscape).toHaveBeenCalledWith(expect.arrayContaining([
-            expect.objectContaining({ name: 'sid-www.youtube.com', domain: 'www.youtube.com' }),
-            expect.objectContaining({ name: 'sid-www.bilibili.com', domain: 'www.bilibili.com' }),
-        ]), expect.any(String));
-        expect(mockYtdlpDownload).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/src/pipeline/steps/fetch.test.js

@@ -1,117 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { CliError } from '../../errors.js';
-import { stepFetch } from './fetch.js';
-afterEach(() => {
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-});
-describe('stepFetch', () => {
-    // W1 + W4: non-browser single fetch throws CliError with FETCH_ERROR code and full message
-    it('throws CliError with FETCH_ERROR code on non-ok responses without a browser session', async () => {
-        const jsonMock = vi.fn().mockResolvedValue({ error: 'rate limited' });
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: false,
-            status: 429,
-            statusText: 'Too Many Requests',
-            json: jsonMock,
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const err = await stepFetch(null, { url: 'https://api.example.com/items' }, null, {}).catch((e) => e);
-        expect(err).toBeInstanceOf(CliError);
-        expect(err.code).toBe('FETCH_ERROR');
-        expect(err.message).toBe('HTTP 429 Too Many Requests from https://api.example.com/items');
-        expect(jsonMock).not.toHaveBeenCalled();
-    });
-    // W1 + W3: browser single fetch delegates to page.fetchJson, which owns browser-context fetch errors
-    it('throws CliError with FETCH_ERROR code on non-ok responses inside the browser session', async () => {
-        const page = {
-            fetchJson: vi.fn().mockRejectedValue(new CliError('FETCH_ERROR', 'HTTP 401 Unauthorized from https://api.example.com/items')),
-        };
-        const err = await stepFetch(page, { url: 'https://api.example.com/items' }, null, {}).catch((e) => e);
-        expect(err).toBeInstanceOf(CliError);
-        expect(err.code).toBe('FETCH_ERROR');
-        expect(err.message).toBe('HTTP 401 Unauthorized from https://api.example.com/items');
-        expect(page.fetchJson).toHaveBeenCalledWith('https://api.example.com/items', {
-            method: 'GET',
-            headers: {},
-        });
-    });
-    it('returns per-item HTTP errors for batch fetches without a browser session', async () => {
-        const jsonMock = vi.fn().mockResolvedValue({ error: 'upstream unavailable' });
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: false,
-            status: 503,
-            statusText: 'Service Unavailable',
-            json: jsonMock,
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        await expect(stepFetch(null, { url: 'https://api.example.com/items/${{ item.id }}' }, [{ id: 1 }], {})).resolves.toEqual([
-            { error: 'HTTP 503 Service Unavailable from https://api.example.com/items/1' },
-        ]);
-        expect(jsonMock).not.toHaveBeenCalled();
-    });
-    it('returns per-item HTTP errors for batch browser fetches', async () => {
-        const jsonMock = vi.fn().mockResolvedValue({ error: 'upstream unavailable' });
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: false,
-            status: 503,
-            statusText: 'Service Unavailable',
-            json: jsonMock,
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const page = {
-            evaluate: vi.fn(async (js) => Function(`return (${js})`)()()),
-        };
-        await expect(stepFetch(page, { url: 'https://api.example.com/items/${{ item.id }}' }, [{ id: 1 }], {})).resolves.toEqual([
-            { error: 'HTTP 503 Service Unavailable from https://api.example.com/items/1' },
-        ]);
-        expect(jsonMock).not.toHaveBeenCalled();
-    });
-    it('stringifies non-Error batch browser failures consistently', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockRejectedValue('socket hang up'));
-        const page = {
-            evaluate: vi.fn(async (js) => Function(`return (${js})`)()()),
-        };
-        await expect(stepFetch(page, { url: 'https://api.example.com/items/${{ item.id }}' }, [{ id: 1 }], {})).resolves.toEqual([
-            { error: 'socket hang up' },
-        ]);
-    });
-    it('stringifies non-Error batch non-browser failures consistently', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockRejectedValue('socket hang up'));
-        await expect(stepFetch(null, { url: 'https://api.example.com/items/${{ item.id }}' }, [{ id: 1 }], {})).resolves.toEqual([
-            { error: 'socket hang up' },
-        ]);
-    });
-    // W2: batch item failures emit a warning log
-    it('logs a warning for each failed batch item in non-browser mode', async () => {
-        const { log } = await import('../../logger.js');
-        const warnSpy = vi.spyOn(log, 'warn');
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: false,
-            status: 503,
-            statusText: 'Service Unavailable',
-            json: vi.fn(),
-        }));
-        await stepFetch(null, { url: 'https://api.example.com/items/${{ item.id }}' }, [{ id: 1 }, { id: 2 }], {});
-        expect(warnSpy).toHaveBeenCalledTimes(2);
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('https://api.example.com/items/1'));
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('https://api.example.com/items/2'));
-    });
-    it('logs a warning for each failed batch item in browser mode', async () => {
-        const { log } = await import('../../logger.js');
-        const warnSpy = vi.spyOn(log, 'warn');
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: false,
-            status: 502,
-            statusText: 'Bad Gateway',
-            json: vi.fn(),
-        }));
-        const page = {
-            evaluate: vi.fn(async (js) => Function(`return (${js})`)()()),
-        };
-        await stepFetch(page, { url: 'https://api.example.com/items/${{ item.id }}' }, [{ id: 1 }, { id: 2 }], {});
-        expect(warnSpy).toHaveBeenCalledTimes(2);
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('https://api.example.com/items/1'));
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('https://api.example.com/items/2'));
-    });
-});

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

@@ -1,175 +0,0 @@
-/**
- * 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('resolves root path', () => {
-        expect(resolvePath('root.items', { root: { 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('evaluates chained || fallback (issue #303)', () => {
-        // When first two are falsy, should evaluate through to the string literal
-        expect(evalExpr("item.a || item.b || 'default'", { item: {} })).toBe('default');
-    });
-    it('evaluates chained || with middle value truthy', () => {
-        expect(evalExpr("item.a || item.b || 'default'", { item: { b: 'middle' } })).toBe('middle');
-    });
-    it('evaluates chained || with first value truthy', () => {
-        expect(evalExpr("item.a || item.b || 'default'", { item: { a: 'first', b: 'middle' } })).toBe('first');
-    });
-    it('evaluates || with 0 as falsy left (JS semantics)', () => {
-        expect(evalExpr("item.count || 'N/A'", { item: { count: 0 } })).toBe('N/A');
-    });
-    it('evaluates || with empty string as falsy left', () => {
-        expect(evalExpr("item.name || 'unknown'", { item: { name: '' } })).toBe('unknown');
-    });
-    it('evaluates || with numeric fallback returning number type', () => {
-        expect(evalExpr('item.a || 42', { item: {} })).toBe(42);
-    });
-    it('evaluates 4-way chained ||', () => {
-        expect(evalExpr("item.a || item.b || item.c || 'last'", { item: { c: 'third' } })).toBe('third');
-    });
-    it('handles || combined with pipe filter', () => {
-        expect(evalExpr("item.a || item.b | upper", { item: { b: 'hello' } })).toBe('HELLO');
-    });
-    it('resolves simple path', () => {
-        expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
-    });
-    it('evaluates JS helper expressions', () => {
-        expect(evalExpr('encodeURIComponent(args.keyword)', { args: { keyword: 'hello world' } })).toBe('hello%20world');
-    });
-    it('evaluates ternary expressions', () => {
-        expect(evalExpr("args.kind === 'tech' ? 'technology' : args.kind", { args: { kind: 'tech' } })).toBe('technology');
-    });
-    it('evaluates method calls on values', () => {
-        expect(evalExpr("args.username.startsWith('@') ? args.username : '@' + args.username", { args: { username: 'alice' } })).toBe('@alice');
-    });
-    it('rejects constructor-based sandbox escapes', () => {
-        expect(evalExpr("args['cons' + 'tructor']['constructor']('return process')()", { args: {} })).toBeUndefined();
-    });
-    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);
-    });
-    it('applies json filter to strings with quotes', () => {
-        expect(evalExpr('args.keyword | json', { args: { keyword: "O'Reilly" } })).toBe('"O\'Reilly"');
-    });
-    it('applies json filter to nullish values', () => {
-        expect(evalExpr('args.keyword | json', { args: {} })).toBe('null');
-    });
-});
-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');
-    });
-    it('renders inline helper expressions', () => {
-        expect(render('https://example.com/search?q=${{ encodeURIComponent(args.keyword) }}', { args: { keyword: 'hello world' } })).toBe('https://example.com/search?q=hello%20world');
-    });
-    it('renders full multiline expressions', () => {
-        expect(render("${{\n  args.topic ? `https://medium.com/tag/${args.topic}` : 'https://medium.com/tag/technology'\n}}", { args: { topic: 'ai' } })).toBe('https://medium.com/tag/ai');
-    });
-    it('renders block expressions with surrounding whitespace', () => {
-        expect(render("\n  ${{ args.kind === 'tech' ? 'technology' : args.kind }}\n", { args: { kind: 'tech' } })).toBe('technology');
-    });
-});
-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/src/pipeline/transform.test.js

@@ -1,133 +0,0 @@
-/**
- * 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();
-    });
-    it('supports inline select before mapping', async () => {
-        const result = await stepMap(null, {
-            select: 'posts',
-            title: '${{ item.title }}',
-            rank: '${{ index + 1 }}',
-        }, { posts: [{ title: 'One' }, { title: 'Two' }] }, {});
-        expect(result).toEqual([
-            { title: 'One', rank: 1 },
-            { title: 'Two', rank: 2 },
-        ]);
-    });
-    it('keeps data bound to the selected source and exposes root separately', async () => {
-        const result = await stepMap(null, {
-            select: 'bids',
-            bid_price: '${{ data[index][0] }}',
-            ask_price: '${{ root.asks[index][0] }}',
-        }, {
-            bids: [['100', '2'], ['99', '3']],
-            asks: [['101', '1'], ['102', '4']],
-        }, {});
-        expect(result).toEqual([
-            { bid_price: '100', ask_price: '101' },
-            { bid_price: '99', ask_price: '102' },
-        ]);
-    });
-});
-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);
-    });
-    it('sorts string-encoded numbers naturally by default', async () => {
-        const data = [
-            { name: 'A', volume: '99' },
-            { name: 'B', volume: '1000' },
-            { name: 'C', volume: '250' },
-        ];
-        const result = await stepSort(null, { by: 'volume', order: 'desc' }, data, {});
-        expect(result.map((r) => r.name)).toEqual(['B', 'C', 'A']);
-    });
-    it('handles missing fields gracefully', async () => {
-        const data = [
-            { name: 'A', value: '10' },
-            { name: 'B' },
-            { name: 'C', value: '5' },
-        ];
-        const result = await stepSort(null, { by: 'value', order: 'asc' }, data, {});
-        expect(result.map((r) => r.name)).toEqual(['B', 'C', 'A']);
-    });
-});
-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');
-    });
-});