@sovovs/bycli 1.8.0 → 2.0.0

package/dist/src/adapter-shadow.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { findShadowedUserAdapters, formatAdapterShadowIssue } from './adapter-shadow.js';
-describe('adapter shadow detection', () => {
-    it('reports user adapters that shadow packaged manifest commands', () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-adapter-shadow-'));
-        try {
-            const userClisDir = path.join(root, 'user-clis');
-            const builtinRoot = path.join(root, 'pkg');
-            const builtinClisDir = path.join(builtinRoot, 'clis');
-            fs.mkdirSync(path.join(userClisDir, 'instagram'), { recursive: true });
-            fs.mkdirSync(path.join(userClisDir, 'twitter'), { recursive: true });
-            fs.mkdirSync(path.join(builtinClisDir, 'instagram'), { recursive: true });
-            fs.mkdirSync(path.join(builtinClisDir, 'twitter'), { recursive: true });
-            fs.writeFileSync(path.join(userClisDir, 'instagram', 'saved.js'), '', 'utf-8');
-            fs.writeFileSync(path.join(userClisDir, 'instagram', 'utils.js'), '', 'utf-8');
-            fs.writeFileSync(path.join(userClisDir, 'twitter', 'search.js'), '', 'utf-8');
-            fs.writeFileSync(path.join(builtinClisDir, 'instagram', 'saved.js'), '', 'utf-8');
-            fs.writeFileSync(path.join(builtinClisDir, 'instagram', 'utils.js'), '', 'utf-8');
-            fs.writeFileSync(path.join(builtinClisDir, 'twitter', 'search.js'), '', 'utf-8');
-            fs.writeFileSync(path.join(builtinRoot, 'cli-manifest.json'), `${JSON.stringify([
-                { site: 'instagram', name: 'saved', sourceFile: 'instagram/saved.js' },
-            ])}\n`, 'utf-8');
-            expect(findShadowedUserAdapters({ userClisDir, builtinClisDir })).toEqual([
-                {
-                    name: 'instagram/saved',
-                    userPath: path.join(userClisDir, 'instagram', 'saved.js'),
-                    builtinPath: path.join(builtinClisDir, 'instagram', 'saved.js'),
-                },
-            ]);
-        }
-        finally {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    });
-    it('formats a concise doctor issue', () => {
-        const issue = formatAdapterShadowIssue([
-            {
-                name: 'instagram/saved',
-                userPath: '/home/me/.bycli/clis/instagram/saved.js',
-                builtinPath: '/pkg/clis/instagram/saved.js',
-            },
-        ]);
-        expect(issue).toContain('instagram/saved');
-        expect(issue).toContain('bycli adapter reset <site>');
-    });
-});

package/dist/src/adapter-source.test.js

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveAdapterSourcePath } from './adapter-source.js';
-function makeCmd(overrides = {}) {
-    return {
-        site: 'test-site',
-        name: 'test-cmd', access: 'read',
-        description: 'test',
-        args: [],
-        ...overrides,
-    };
-}
-describe('resolveAdapterSourcePath', () => {
-    it('returns source when it is a real file path (not manifest:)', () => {
-        const cmd = makeCmd({ source: '/home/user/.bycli/clis/arxiv/search.js' });
-        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.bycli/clis/arxiv/search.js');
-    });
-    it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
-        const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/clis/arxiv/search.js' });
-        expect(resolveAdapterSourcePath(cmd)).toBe('/pkg/clis/arxiv/search.js');
-    });
-    it('returns undefined when only manifest: pseudo-path and no _modulePath', () => {
-        const cmd = makeCmd({ source: 'manifest:test/cmd' });
-        expect(resolveAdapterSourcePath(cmd)).toBeUndefined();
-    });
-    it('returns _modulePath when it is the only path available', () => {
-        const cmd = makeCmd({ _modulePath: '/project/clis/site/cmd.js' });
-        expect(resolveAdapterSourcePath(cmd)).toBe('/project/clis/site/cmd.js');
-    });
-});

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

@@ -1,166 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { analyzeSite, detectAntiBot, classifyPattern, findNearestAdapter, } from './analyze.js';
-function mkSignals(overrides = {}) {
-    return {
-        requestedUrl: 'https://example.com/',
-        finalUrl: 'https://example.com/',
-        cookieNames: [],
-        networkEntries: [],
-        initialState: {
-            __INITIAL_STATE__: false,
-            __NUXT__: false,
-            __NEXT_DATA__: false,
-            __APOLLO_STATE__: false,
-        },
-        title: 'Example',
-        ...overrides,
-    };
-}
-function mkCmd(site, name, domain) {
-    return {
-        site,
-        name,
-        access: 'read',
-        description: '',
-        domain,
-        browser: false,
-        args: [],
-    };
-}
-describe('detectAntiBot', () => {
-    it('flags Aliyun WAF from cookie', () => {
-        const v = detectAntiBot(mkSignals({ cookieNames: ['JSESSIONID', 'acw_sc__v2'] }));
-        expect(v.detected).toBe(true);
-        expect(v.vendor).toBe('aliyun_waf');
-        expect(v.evidence).toContain('cookie:acw_sc__v2');
-        expect(v.implication).toMatch(/browser context/i);
-    });
-    it('flags Aliyun WAF from challenge HTML body', () => {
-        const v = detectAntiBot(mkSignals({
-            networkEntries: [
-                {
-                    url: 'https://x.com/',
-                    status: 200,
-                    contentType: 'text/html',
-                    bodyPreview: "var arg1 = 'A1B2C3D4E5F6A7B8C9D0E1F2A3B4C5D6';",
-                },
-            ],
-        }));
-        expect(v.detected).toBe(true);
-        expect(v.vendor).toBe('aliyun_waf');
-    });
-    it('flags Cloudflare from cf_clearance cookie', () => {
-        const v = detectAntiBot(mkSignals({ cookieNames: ['cf_clearance'] }));
-        expect(v.vendor).toBe('cloudflare');
-        expect(v.implication).toMatch(/Cloudflare/i);
-    });
-    it('flags Akamai from _abck cookie', () => {
-        const v = detectAntiBot(mkSignals({ cookieNames: ['_abck', 'bm_sz'] }));
-        expect(v.vendor).toBe('akamai');
-    });
-    it('returns no-match verdict with actionable fallback advice', () => {
-        const v = detectAntiBot(mkSignals());
-        expect(v.detected).toBe(false);
-        expect(v.vendor).toBeNull();
-        expect(v.implication).toMatch(/Node-side COOKIE fetch first/);
-    });
-});
-describe('classifyPattern', () => {
-    it('returns A for JSON-heavy pages without SSR state', () => {
-        const v = classifyPattern(mkSignals({
-            networkEntries: [
-                { url: 'https://x.com/api/a', status: 200, contentType: 'application/json', bodyPreview: '{}' },
-                { url: 'https://x.com/api/b', status: 200, contentType: 'application/json;charset=utf-8', bodyPreview: '{}' },
-            ],
-        }));
-        expect(v.pattern).toBe('A');
-        expect(v.json_responses).toBe(2);
-    });
-    it('returns B when __INITIAL_STATE__ is present, beating JSON signals', () => {
-        const v = classifyPattern(mkSignals({
-            initialState: { __INITIAL_STATE__: true, __NUXT__: false, __NEXT_DATA__: false, __APOLLO_STATE__: false },
-            networkEntries: [
-                { url: 'https://x.com/api/a', status: 200, contentType: 'application/json', bodyPreview: '{}' },
-            ],
-        }));
-        expect(v.pattern).toBe('B');
-    });
-    it('returns D when auth failures dominate', () => {
-        const v = classifyPattern(mkSignals({
-            networkEntries: [
-                { url: 'https://x.com/api/a', status: 401, contentType: 'application/json', bodyPreview: '' },
-                { url: 'https://x.com/api/b', status: 403, contentType: 'application/json', bodyPreview: '' },
-            ],
-        }));
-        expect(v.pattern).toBe('D');
-        expect(v.auth_failures).toBe(2);
-    });
-    it('returns C by default for static pages', () => {
-        const v = classifyPattern(mkSignals());
-        expect(v.pattern).toBe('C');
-    });
-});
-describe('findNearestAdapter', () => {
-    it('matches by domain suffix', () => {
-        const reg = new Map([
-            ['51job search', mkCmd('51job', 'search', '51job.com')],
-            ['51job detail', mkCmd('51job', 'detail', '51job.com')],
-            ['xueqiu search', mkCmd('xueqiu', 'search', 'xueqiu.com')],
-        ]);
-        const v = findNearestAdapter('https://jobs.51job.com/', reg);
-        expect(v?.site).toBe('51job');
-        expect(v?.example_commands).toContain('51job search');
-    });
-    it('falls back to site-name containment when no domain is registered', () => {
-        const reg = new Map([
-            ['51job search', mkCmd('51job', 'search')],
-        ]);
-        const v = findNearestAdapter('https://we.51job.com/', reg);
-        expect(v?.site).toBe('51job');
-    });
-    it('returns null when no adapter matches', () => {
-        const reg = new Map([
-            ['xueqiu search', mkCmd('xueqiu', 'search', 'xueqiu.com')],
-        ]);
-        const v = findNearestAdapter('https://random-site.io/', reg);
-        expect(v).toBeNull();
-    });
-    it('prefers the site with the most commands', () => {
-        const reg = new Map([
-            ['a search', mkCmd('a', 'search', 'a.com')],
-            ['b search', mkCmd('b', 'search', 'a.com')],
-            ['b detail', mkCmd('b', 'detail', 'a.com')],
-            ['b company', mkCmd('b', 'company', 'a.com')],
-        ]);
-        const v = findNearestAdapter('https://jobs.a.com/', reg);
-        expect(v?.site).toBe('b');
-    });
-});
-describe('analyzeSite', () => {
-    it('recommends browser-context fetch when WAF is detected', () => {
-        const report = analyzeSite(mkSignals({ cookieNames: ['acw_sc__v2'] }), new Map());
-        expect(report.anti_bot.vendor).toBe('aliyun_waf');
-        expect(report.recommended_next_step).toMatch(/browser context/i);
-    });
-    it('recommends reading SSR state when Pattern B fires', () => {
-        const report = analyzeSite(mkSignals({
-            initialState: { __INITIAL_STATE__: false, __NUXT__: true, __NEXT_DATA__: false, __APOLLO_STATE__: false },
-        }), new Map());
-        expect(report.pattern.pattern).toBe('B');
-        expect(report.recommended_next_step).toMatch(/__NUXT__|__INITIAL_STATE__|__NEXT_DATA__/);
-    });
-    it('includes __APOLLO_STATE__ in Pattern B next-step guidance', () => {
-        const report = analyzeSite(mkSignals({
-            initialState: { __INITIAL_STATE__: false, __NUXT__: false, __NEXT_DATA__: false, __APOLLO_STATE__: true },
-        }), new Map());
-        expect(report.pattern.pattern).toBe('B');
-        expect(report.recommended_next_step).toMatch(/__APOLLO_STATE__/);
-    });
-    it('includes nearest_adapter when the registry has a match', () => {
-        const reg = new Map([
-            ['51job search', mkCmd('51job', 'search', '51job.com')],
-        ]);
-        const report = analyzeSite(mkSignals({ finalUrl: 'https://we.51job.com/' }), reg);
-        expect(report.nearest_adapter?.site).toBe('51job');
-    });
-});

package/dist/src/browser/article-extract.e2e.test.js

@@ -1,105 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { JSDOM } from 'jsdom';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { buildExtractArticleJs } from './article-extract.js';
-import { downloadArticle } from '../download/article-download.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const fixturesDir = path.join(__dirname, '__fixtures__', 'article-extract');
-const tempDirs = [];
-afterEach(() => {
-    for (const dir of tempDirs)
-        fs.rmSync(dir, { recursive: true, force: true });
-    tempDirs.length = 0;
-});
-function loadFixture(name) {
-    return fs.readFileSync(path.join(fixturesDir, name), 'utf8');
-}
-function escapeHtml(text) {
-    return text.replace(/[&<>]/g, ch => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[ch]));
-}
-function runExtract(html, url, options = {}, contentType) {
-    const dom = new JSDOM(html, {
-        url,
-        contentType: 'text/html',
-        pretendToBeVisual: true,
-        runScripts: 'outside-only',
-    });
-    if (contentType) {
-        Object.defineProperty(dom.window.document, 'contentType', {
-            value: contentType,
-            configurable: true,
-        });
-    }
-    return dom.window.eval(buildExtractArticleJs(options));
-}
-async function renderMarkdown(article, url, options = {}) {
-    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'bycli-article-e2e-'));
-    tempDirs.push(tempDir);
-    const result = await downloadArticle({
-        title: article.title || 'untitled',
-        contentHtml: article.html,
-        sourceUrl: url,
-    }, {
-        output: tempDir,
-        downloadImages: false,
-        cleanSelectors: options.cleanSelectors,
-    });
-    expect(result[0].status).toBe('success');
-    return fs.readFileSync(result[0].saved, 'utf8');
-}
-describe('article extract → markdown e2e fixtures', () => {
-    it('extracts a Wikipedia article fixture and keeps infobox/reference noise out of markdown', async () => {
-        const url = 'https://en.wikipedia.org/wiki/Markdown';
-        const cleanSelectors = ['.infobox', '.navbox', '.reference', '.mw-editsection', '.metadata'];
-        const article = runExtract(loadFixture('wikipedia-markdown.html'), url, { cleanSelectors });
-        expect(article?.source).toBe('readability');
-        expect(article?.title).toBe('Markdown');
-        if (!article)
-            throw new Error('expected extracted article');
-        const md = await renderMarkdown(article, url, { cleanSelectors });
-        expect(md).toContain('lightweight markup language');
-        expect(md).toContain('John Gruber');
-        expect(md).not.toContain('Syntax description');
-        expect(md).not.toContain('Standard file extension');
-    });
-    it('extracts a Deno blog fixture, preserves embedded iframes as markdown links, and drops page chrome', async () => {
-        const url = 'https://deno.com/blog/v2.0';
-        const article = runExtract(loadFixture('deno-v2.html'), url);
-        expect(article?.source).toBe('readability');
-        expect(article?.title).toBe('Announcing Deno 2 | Deno');
-        if (!article)
-            throw new Error('expected extracted article');
-        const md = await renderMarkdown(article, url);
-        expect(md).toContain('## Announcing Deno 2');
-        expect(md).toContain('The web is humanity’s largest software platform');
-        expect(md).toMatch(/\]\(https:\/\/www\.youtube(?:-nocookie)?\.com\/embed\/[^)]+\)/);
-        expect(md).not.toContain('Skip to main content');
-    });
-    it('short-circuits non-HTML raw text pages end-to-end', async () => {
-        const url = 'https://raw.githubusercontent.com/openai/openai-cookbook/main/README.md';
-        const text = loadFixture('openai-cookbook-readme.txt');
-        const html = `<html><head><title>OpenAI Cookbook README</title></head><body><pre>${escapeHtml(text)}</pre></body></html>`;
-        const article = runExtract(html, url, {}, 'text/plain');
-        expect(article?.source).toBe('raw-text');
-        if (!article)
-            throw new Error('expected extracted article');
-        const md = await renderMarkdown(article, url);
-        expect(md).toContain('OPENAI\\_API\\_KEY');
-        expect(md).toContain('Example code and guides for accomplishing common tasks');
-    });
-    it('short-circuits a single-pre document end-to-end', async () => {
-        const url = 'https://raw.githubusercontent.com/openai/openai-cookbook/main/README.md';
-        const text = loadFixture('openai-cookbook-readme.txt');
-        const html = `<html><head><title>OpenAI Cookbook README</title></head><body><pre>${escapeHtml(text)}</pre></body></html>`;
-        const article = runExtract(html, url);
-        expect(article?.source).toBe('pre');
-        if (!article)
-            throw new Error('expected extracted article');
-        const md = await renderMarkdown(article, url);
-        expect(md).toContain('OPENAI\\_API\\_KEY');
-        expect(md).toContain('Most code examples are written in Python');
-    });
-});

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

@@ -1,94 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildExtractArticleJs, extractArticle, DEFAULT_FALLBACK_SELECTORS, } from './article-extract.js';
-function fakePage(response) {
-    const state = { lastJs: null };
-    return {
-        lastJs: null,
-        async evaluate(js) {
-            state.lastJs = js;
-            Object.assign(this, state);
-            return response;
-        },
-    };
-}
-describe('buildExtractArticleJs', () => {
-    it('embeds Readability + Readerable sources once per evaluation', () => {
-        const js = buildExtractArticleJs();
-        // Both libs should be inlined (matched by identifying strings from the
-        // upstream @mozilla/readability sources).
-        expect(js).toContain('function Readability(doc, options)');
-        expect(js).toContain('function isProbablyReaderable');
-    });
-    it('serializes caller-supplied options into the evaluated JS', () => {
-        const js = buildExtractArticleJs({
-            cleanSelectors: ['.ads', '#banner'],
-            fallbackSelectors: ['article', 'body'],
-            force: true,
-        });
-        expect(js).toContain('[".ads","#banner"]');
-        expect(js).toContain('["article","body"]');
-        expect(js).toContain('const force = true;');
-    });
-    it('uses the default fallback chain when none is supplied', () => {
-        const js = buildExtractArticleJs();
-        for (const sel of DEFAULT_FALLBACK_SELECTORS) {
-            expect(js).toContain(JSON.stringify(sel));
-        }
-    });
-    it('runs fallback selection against the cleaned clone', () => {
-        const js = buildExtractArticleJs({ cleanSelectors: ['.noise'] });
-        expect(js).toContain('el = cloneDoc.querySelector(sel);');
-        expect(js).not.toContain('el = document.querySelector(sel);');
-    });
-    it('produces syntactically valid JavaScript', () => {
-        // Parsing via the Function constructor rejects any syntax error in the
-        // generated code — including accidental template-literal break-outs from
-        // the embedded Readability sources.
-        expect(() => new Function(buildExtractArticleJs())).not.toThrow();
-        expect(() => new Function(buildExtractArticleJs({ force: true }))).not.toThrow();
-        expect(() => new Function(buildExtractArticleJs({
-            cleanSelectors: ['.a', '.b'],
-            fallbackSelectors: ['main', 'body'],
-        }))).not.toThrow();
-    });
-});
-describe('extractArticle (host-side)', () => {
-    it('returns a normalized ExtractedArticle when the page responds with one', async () => {
-        const page = fakePage({
-            source: 'readability',
-            html: '<p>hello</p>',
-            title: 'Hello',
-            byline: 'Alice',
-            publishedTime: '2026-04-22',
-            siteName: 'Example',
-        });
-        const res = await extractArticle(page);
-        expect(res).toEqual({
-            source: 'readability',
-            html: '<p>hello</p>',
-            title: 'Hello',
-            byline: 'Alice',
-            publishedTime: '2026-04-22',
-            siteName: 'Example',
-        });
-    });
-    it('drops undefined optional fields cleanly', async () => {
-        const page = fakePage({ source: 'fallback', html: '<main>x</main>', title: 't' });
-        const res = await extractArticle(page);
-        expect(res).toEqual({ source: 'fallback', html: '<main>x</main>', title: 't' });
-        expect(res).not.toHaveProperty('byline');
-        expect(res).not.toHaveProperty('publishedTime');
-    });
-    it('returns null on a missing body or malformed payload', async () => {
-        expect(await extractArticle(fakePage(null))).toBeNull();
-        expect(await extractArticle(fakePage('oops'))).toBeNull();
-        expect(await extractArticle(fakePage({ source: 'readability' }))).toBeNull();
-        expect(await extractArticle(fakePage({ html: '<p>x</p>' }))).toBeNull();
-    });
-    it('defaults title to empty string when the page omits it', async () => {
-        const page = fakePage({ source: 'pre', html: '<body><pre>x</pre></body>' });
-        const res = await extractArticle(page);
-        expect(res?.title).toBe('');
-        expect(res?.source).toBe('pre');
-    });
-});

package/dist/src/browser/ax-snapshot.test.js

@@ -1,91 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildAxSnapshot, buildAxSnapshotFromTrees, findAxRefReplacement } from './ax-snapshot.js';
-describe('AX snapshot prototype', () => {
-    it('builds compact refs from Accessibility.getFullAXTree output', () => {
-        const result = buildAxSnapshot({
-            nodes: [
-                { nodeId: '1', role: { value: 'RootWebArea' }, name: { value: 'Example' }, childIds: ['2', '3'] },
-                { nodeId: '2', role: { value: 'heading' }, name: { value: 'Expenses' }, backendDOMNodeId: 20 },
-                {
-                    nodeId: '3',
-                    role: { value: 'combobox' },
-                    name: { value: 'Category' },
-                    backendDOMNodeId: 30,
-                    properties: [{ name: 'expanded', value: { value: false } }],
-                },
-            ],
-        });
-        expect(result.text).toContain('source: ax');
-        expect(result.text).toContain('[1]heading "Expenses"');
-        expect(result.text).toContain('[2]combobox "Category" expanded=false');
-        expect(result.refs.get('2')).toEqual({
-            ref: '2',
-            backendNodeId: 30,
-            role: 'combobox',
-            name: 'Category',
-        });
-    });
-    it('tracks nth only for duplicate role/name pairs', () => {
-        const result = buildAxSnapshot({
-            nodes: [
-                { nodeId: '1', role: { value: 'RootWebArea' }, childIds: ['2', '3'] },
-                { nodeId: '2', role: { value: 'button' }, name: { value: 'Save' }, backendDOMNodeId: 10 },
-                { nodeId: '3', role: { value: 'button' }, name: { value: 'Save' }, backendDOMNodeId: 11 },
-            ],
-        });
-        expect(result.refs.get('1')).toMatchObject({ role: 'button', name: 'Save', nth: 0 });
-        expect(result.refs.get('2')).toMatchObject({ role: 'button', name: 'Save', nth: 1 });
-    });
-    it('finds stale ref replacements by role/name/nth', () => {
-        const replacement = findAxRefReplacement({
-            nodes: [
-                { nodeId: '1', role: { value: 'button' }, name: { value: 'Save' }, backendDOMNodeId: 10 },
-                { nodeId: '2', role: { value: 'button' }, name: { value: 'Save' }, backendDOMNodeId: 42 },
-            ],
-        }, {
-            ref: '2',
-            role: 'button',
-            name: 'Save',
-            backendNodeId: 11,
-            nth: 1,
-        });
-        expect(replacement).toMatchObject({ ref: '2', backendNodeId: 42, role: 'button', name: 'Save', nth: 1 });
-    });
-    it('combines frame AX trees while keeping ref metadata frame-scoped', () => {
-        const result = buildAxSnapshotFromTrees([
-            {
-                tree: {
-                    nodes: [
-                        { nodeId: '1', role: { value: 'RootWebArea' }, childIds: ['2'] },
-                        { nodeId: '2', role: { value: 'button' }, name: { value: 'Save' }, backendDOMNodeId: 10 },
-                    ],
-                },
-            },
-            {
-                frame: { frameId: 'frame-1', url: 'https://app.example/embed' },
-                tree: {
-                    nodes: [
-                        { nodeId: '1', role: { value: 'RootWebArea' }, childIds: ['2'] },
-                        { nodeId: '2', role: { value: 'button' }, name: { value: 'Save' }, backendDOMNodeId: 20 },
-                    ],
-                },
-            },
-        ]);
-        expect(result.text).toContain('[1]button "Save"');
-        expect(result.text).toContain('frame "https://app.example/embed":');
-        expect(result.text).toContain('  [2]button "Save"');
-        expect(result.refs.get('1')).toEqual({
-            ref: '1',
-            backendNodeId: 10,
-            role: 'button',
-            name: 'Save',
-        });
-        expect(result.refs.get('2')).toEqual({
-            ref: '2',
-            backendNodeId: 20,
-            role: 'button',
-            name: 'Save',
-            frame: { frameId: 'frame-1', url: 'https://app.example/embed' },
-        });
-    });
-});