@demigodmode/pi-web-agent 0.2.2 → 0.4.0

package/dist/tests/orchestration/research-orchestrator.test.js

@@ -1,298 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import * as researchTypes from '../../src/orchestration/research-types.js';
-import { createResearchOrchestrator } from '../../src/orchestration/research-orchestrator.js';
-describe('research orchestrator types', () => {
-    it('exports a runtime module for orchestration types', () => {
-        expect(researchTypes).toBeTypeOf('object');
-    });
-    it('supports evidence, gaps, and decisions for one bounded pass', () => {
-        const evidence = {
-            title: 'BrowserType | Playwright',
-            url: 'https://playwright.dev/docs/api/class-browsertype',
-            sourceKind: 'official-docs',
-            method: 'http',
-            summary: 'The API docs describe channel and executablePath.',
-            supports: ['Use channel for branded browsers', 'executablePath exists but is risky']
-        };
-        const gap = {
-            kind: 'needs-more-evidence',
-            message: 'Need one source showing the recommended Edge usage pattern.'
-        };
-        const result = {
-            searchQueries: ['playwright installed edge channel executablePath'],
-            evidence: [evidence],
-            gaps: [gap],
-            lowValueOutcomes: [],
-            suggestedHeadlessUrl: undefined,
-            exhaustedBudget: false
-        };
-        const decision = {
-            action: 'answer',
-            rationale: 'One official source is enough for this smoke test.',
-            approvedEvidence: result.evidence
-        };
-        expect(result.evidence[0].sourceKind).toBe('official-docs');
-        expect(decision.action).toBe('answer');
-    });
-    it('supports explicit low-value outcomes in worker results', () => {
-        const result = {
-            searchQueries: ['duckduckgo scraping node'],
-            evidence: [],
-            gaps: [{ kind: 'fetch-failed', message: 'Primary fetch failed.' }],
-            lowValueOutcomes: [
-                {
-                    kind: 'bot-check',
-                    url: 'https://www.npmjs.com/package/duck-duck-scrape',
-                    message: 'Headless hit a security verification page.'
-                }
-            ],
-            suggestedHeadlessUrl: undefined,
-            exhaustedBudget: false
-        };
-        expect(result.lowValueOutcomes[0]?.kind).toBe('bot-check');
-        expect(result.suggestedHeadlessUrl).toBeUndefined();
-    });
-    it('answers when one bounded pass returns enough official evidence', async () => {
-        const orchestrator = createResearchOrchestrator({
-            worker: {
-                run: vi.fn().mockResolvedValue({
-                    searchQueries: ['playwright edge channel'],
-                    evidence: [
-                        {
-                            title: 'Browsers | Playwright',
-                            url: 'https://playwright.dev/docs/browsers',
-                            sourceKind: 'official-docs',
-                            method: 'http',
-                            summary: 'Use branded browsers with channel values like msedge.',
-                            supports: ['Use msedge for Edge']
-                        },
-                        {
-                            title: 'BrowserType | Playwright',
-                            url: 'https://playwright.dev/docs/api/class-browsertype',
-                            sourceKind: 'official-api',
-                            method: 'http',
-                            summary: 'executablePath exists but is use-at-your-own-risk.',
-                            supports: ['executablePath is risky']
-                        }
-                    ],
-                    gaps: [],
-                    lowValueOutcomes: [],
-                    suggestedHeadlessUrl: undefined,
-                    exhaustedBudget: false
-                })
-            },
-            headlessFetch: vi.fn()
-        });
-        const result = await orchestrator.run({ query: 'playwright installed edge executablePath vs channel' });
-        expect(result.decision.action).toBe('answer');
-        expect(result.evidence).toHaveLength(2);
-    });
-    it('requests another pass when evidence is too thin', async () => {
-        const orchestrator = createResearchOrchestrator({
-            worker: {
-                run: vi.fn().mockResolvedValue({
-                    searchQueries: ['ambiguous query'],
-                    evidence: [
-                        {
-                            title: 'Some blog',
-                            url: 'https://example.com/post',
-                            sourceKind: 'community',
-                            method: 'http',
-                            summary: 'A single community source only.',
-                            supports: ['One weak source']
-                        }
-                    ],
-                    gaps: [{ kind: 'needs-more-evidence', message: 'Need at least one official source.' }],
-                    lowValueOutcomes: [],
-                    suggestedHeadlessUrl: undefined,
-                    exhaustedBudget: false
-                })
-            },
-            headlessFetch: vi.fn()
-        });
-        const result = await orchestrator.run({ query: 'ambiguous query' });
-        expect(result.decision.action).toBe('research-again');
-    });
-    it('escalates one specific page to headless only when approved by the orchestrator', async () => {
-        const headlessFetch = vi.fn().mockResolvedValue({
-            status: 'ok',
-            url: 'https://example.com/app',
-            content: { title: 'Dynamic App', text: 'Rendered content with enough detail.' },
-            metadata: {
-                method: 'headless',
-                cacheHit: false,
-                browser: 'edge',
-                navigationMs: 1200,
-                truncated: false
-            }
-        });
-        const orchestrator = createResearchOrchestrator({
-            worker: {
-                run: vi.fn().mockResolvedValue({
-                    searchQueries: ['dynamic app'],
-                    evidence: [],
-                    gaps: [{ kind: 'fetch-failed', message: 'HTTP was weak.' }],
-                    lowValueOutcomes: [],
-                    suggestedHeadlessUrl: 'https://example.com/app',
-                    exhaustedBudget: false
-                })
-            },
-            headlessFetch
-        });
-        const result = await orchestrator.run({ query: 'dynamic app' });
-        expect(result.decision.action).toBe('escalate-headless');
-        expect(headlessFetch).toHaveBeenCalledWith({ url: 'https://example.com/app' });
-    });
-    it('answers once two strong sources exist and one is official', async () => {
-        const orchestrator = createResearchOrchestrator({
-            worker: {
-                run: vi.fn().mockResolvedValue({
-                    searchQueries: ['playwright edge channel'],
-                    evidence: [
-                        {
-                            title: 'Browsers | Playwright',
-                            url: 'https://playwright.dev/docs/browsers',
-                            sourceKind: 'official-docs',
-                            method: 'http',
-                            summary: 'Official docs',
-                            supports: ['Use channel']
-                        },
-                        {
-                            title: 'Edge docs',
-                            url: 'https://learn.microsoft.com/en-us/microsoft-edge/playwright/',
-                            sourceKind: 'official-discussion',
-                            method: 'http',
-                            summary: 'Vendor guidance',
-                            supports: ['Use msedge']
-                        }
-                    ],
-                    gaps: [],
-                    lowValueOutcomes: [],
-                    suggestedHeadlessUrl: undefined,
-                    exhaustedBudget: false
-                })
-            },
-            headlessFetch: vi.fn()
-        });
-        const result = await orchestrator.run({ query: 'playwright edge channel' });
-        expect(result.decision.action).toBe('answer');
-    });
-    it('does not escalate to headless when strong http evidence already answers the question', async () => {
-        const headlessFetch = vi.fn();
-        const orchestrator = createResearchOrchestrator({
-            worker: {
-                run: vi.fn().mockResolvedValue({
-                    searchQueries: ['vitest coverage docs'],
-                    evidence: [
-                        {
-                            title: 'Coverage | Guide | Vitest',
-                            url: 'https://vitest.dev/guide/coverage.html',
-                            sourceKind: 'official-docs',
-                            method: 'http',
-                            summary: 'Coverage docs',
-                            supports: ['provider v8']
-                        },
-                        {
-                            title: 'Coverage package',
-                            url: 'https://vitest.dev/guide/coverage.html#provider',
-                            sourceKind: 'official-api',
-                            method: 'http',
-                            summary: 'Install @vitest/coverage-v8',
-                            supports: ['install package']
-                        }
-                    ],
-                    gaps: [{ kind: 'fetch-failed', message: 'One page was weak over HTTP.' }],
-                    lowValueOutcomes: [],
-                    suggestedHeadlessUrl: 'https://vitest.dev/guide/coverage.html',
-                    exhaustedBudget: false
-                })
-            },
-            headlessFetch
-        });
-        const result = await orchestrator.run({ query: 'vitest coverage docs' });
-        expect(result.decision.action).toBe('answer');
-        expect(headlessFetch).not.toHaveBeenCalled();
-    });
-    it('prefers stronger sources over package pages in approved evidence', async () => {
-        const orchestrator = createResearchOrchestrator({
-            worker: {
-                run: vi.fn().mockResolvedValue({
-                    searchQueries: ['duckduckgo scraping node'],
-                    evidence: [
-                        {
-                            title: 'npm package',
-                            url: 'https://www.npmjs.com/package/duck-duck-scrape',
-                            sourceKind: 'package-page',
-                            method: 'http',
-                            summary: 'Package page',
-                            supports: ['Install command']
-                        },
-                        {
-                            title: 'SearXNG docs',
-                            url: 'https://docs.searxng.org/dev/engines/online/duckduckgo.html',
-                            sourceKind: 'community',
-                            method: 'http',
-                            summary: 'vqd and pagination details',
-                            supports: ['vqd matters']
-                        },
-                        {
-                            title: 'ddg-search',
-                            url: 'https://github.com/camohiddendj/ddg-search',
-                            sourceKind: 'community',
-                            method: 'http',
-                            summary: 'Node implementation',
-                            supports: ['bot detection note']
-                        }
-                    ],
-                    gaps: [],
-                    lowValueOutcomes: [],
-                    suggestedHeadlessUrl: undefined,
-                    exhaustedBudget: false
-                })
-            },
-            headlessFetch: vi.fn()
-        });
-        const result = await orchestrator.run({ query: 'duckduckgo scraping node' });
-        expect(result.decision.action).toBe('research-again');
-        expect(result.evidence[0]?.sourceKind).not.toBe('package-page');
-    });
-    it('records low-value bot-check outcomes as a reason not to escalate again', async () => {
-        const headlessFetch = vi.fn().mockResolvedValue({
-            status: 'ok',
-            url: 'https://www.npmjs.com/package/duck-duck-scrape',
-            content: {
-                title: 'Just a moment...',
-                text: 'Performing security verification'
-            },
-            metadata: {
-                method: 'headless',
-                cacheHit: false,
-                browser: 'edge',
-                navigationMs: 5000,
-                truncated: false
-            }
-        });
-        const orchestrator = createResearchOrchestrator({
-            worker: {
-                run: vi.fn().mockResolvedValue({
-                    searchQueries: ['duckduckgo scraping node'],
-                    evidence: [],
-                    gaps: [{ kind: 'needs-more-evidence', message: 'Need one more technical source.' }],
-                    lowValueOutcomes: [
-                        {
-                            kind: 'bot-check',
-                            url: 'https://www.npmjs.com/package/duck-duck-scrape',
-                            message: 'Security verification wall.'
-                        }
-                    ],
-                    suggestedHeadlessUrl: 'https://www.npmjs.com/package/duck-duck-scrape',
-                    exhaustedBudget: false
-                })
-            },
-            headlessFetch
-        });
-        const result = await orchestrator.run({ query: 'duckduckgo scraping node' });
-        expect(result.decision.action).toBe('research-again');
-        expect(headlessFetch).not.toHaveBeenCalled();
-    });
-});

package/dist/tests/orchestration/research-worker.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/orchestration/research-worker.test.js

@@ -1,171 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createResearchWorker } from '../../src/orchestration/research-worker.js';
-describe('research worker', () => {
-    it('runs one bounded search/fetch pass and summarizes evidence', async () => {
-        const worker = createResearchWorker({
-            search: vi.fn().mockResolvedValue({
-                status: 'ok',
-                results: [
-                    {
-                        title: 'Browsers | Playwright',
-                        url: 'https://playwright.dev/docs/browsers',
-                        snippet: 'Playwright can operate against branded Chrome and Edge browsers.'
-                    },
-                    {
-                        title: 'Use Playwright to automate and test in Microsoft Edge',
-                        url: 'https://learn.microsoft.com/en-us/microsoft-edge/playwright/',
-                        snippet: 'Use channel msedge to run in Edge.'
-                    }
-                ],
-                metadata: { backend: 'duckduckgo', cacheHit: false }
-            }),
-            fetchPage: vi.fn()
-                .mockResolvedValueOnce({
-                status: 'ok',
-                url: 'https://playwright.dev/docs/browsers',
-                content: {
-                    title: 'Browsers | Playwright',
-                    text: 'Playwright can operate against branded Google Chrome and Microsoft Edge browsers available on the machine.'
-                },
-                metadata: { method: 'http', cacheHit: false, contentType: 'text/html', truncated: false }
-            })
-                .mockResolvedValueOnce({
-                status: 'ok',
-                url: 'https://learn.microsoft.com/en-us/microsoft-edge/playwright/',
-                content: {
-                    title: 'Use Playwright to automate and test in Microsoft Edge',
-                    text: 'Use channel: msedge to run tests in Microsoft Edge.'
-                },
-                metadata: { method: 'http', cacheHit: false, contentType: 'text/html', truncated: false }
-            })
-        });
-        const result = await worker.run({
-            query: 'playwright installed edge executablePath vs channel',
-            maxSearchRounds: 1,
-            maxFetches: 2
-        });
-        expect(result.searchQueries).toEqual(['playwright installed edge executablePath vs channel']);
-        expect(result.evidence).toHaveLength(2);
-        expect(result.evidence[0].summary.length).toBeGreaterThan(0);
-        expect(result.exhaustedBudget).toBe(false);
-    });
-    it('flags a likely headless candidate when http fetch is weak', async () => {
-        const worker = createResearchWorker({
-            search: vi.fn().mockResolvedValue({
-                status: 'ok',
-                results: [
-                    {
-                        title: 'Dynamic docs site',
-                        url: 'https://example.com/app',
-                        snippet: 'JS-heavy docs app'
-                    }
-                ],
-                metadata: { backend: 'duckduckgo', cacheHit: false }
-            }),
-            fetchPage: vi.fn().mockResolvedValue({
-                status: 'needs_headless',
-                url: 'https://example.com/app',
-                metadata: { method: 'http', cacheHit: false, contentType: 'text/html' },
-                error: { code: 'WEAK_EXTRACTION', message: 'HTTP extraction was not reliable enough.' }
-            })
-        });
-        const result = await worker.run({
-            query: 'dynamic docs app',
-            maxSearchRounds: 1,
-            maxFetches: 1
-        });
-        expect(result.suggestedHeadlessUrl).toBe('https://example.com/app');
-        expect(result.gaps[0]?.kind).toBe('fetch-failed');
-    });
-    it('records empty search results as a low-value outcome', async () => {
-        const worker = createResearchWorker({
-            search: vi.fn().mockResolvedValue({
-                status: 'ok',
-                results: [],
-                metadata: { backend: 'duckduckgo', cacheHit: false }
-            }),
-            fetchPage: vi.fn()
-        });
-        const result = await worker.run({
-            query: 'vitest coverage docs',
-            maxSearchRounds: 1,
-            maxFetches: 2
-        });
-        expect(result.lowValueOutcomes).toEqual([
-            {
-                kind: 'empty-search',
-                message: 'Search returned no results for this pass.'
-            }
-        ]);
-        expect(result.evidence).toHaveLength(0);
-    });
-    it('limits headless suggestion to one flagged url even if multiple fetches are weak', async () => {
-        const worker = createResearchWorker({
-            search: vi.fn().mockResolvedValue({
-                status: 'ok',
-                results: [
-                    { title: 'Page A', url: 'https://example.com/a', snippet: 'A' },
-                    { title: 'Page B', url: 'https://example.com/b', snippet: 'B' }
-                ],
-                metadata: { backend: 'duckduckgo', cacheHit: false }
-            }),
-            fetchPage: vi.fn()
-                .mockResolvedValueOnce({
-                status: 'needs_headless',
-                url: 'https://example.com/a',
-                metadata: { method: 'http', cacheHit: false, contentType: 'text/html' },
-                error: { code: 'WEAK_EXTRACTION', message: 'Weak A' }
-            })
-                .mockResolvedValueOnce({
-                status: 'needs_headless',
-                url: 'https://example.com/b',
-                metadata: { method: 'http', cacheHit: false, contentType: 'text/html' },
-                error: { code: 'WEAK_EXTRACTION', message: 'Weak B' }
-            })
-        });
-        const result = await worker.run({
-            query: 'two weak pages',
-            maxSearchRounds: 1,
-            maxFetches: 2
-        });
-        expect(result.suggestedHeadlessUrl).toBe('https://example.com/a');
-        expect(result.gaps).toHaveLength(2);
-    });
-    it('classifies npm package pages as low-value when they do not add useful evidence', async () => {
-        const worker = createResearchWorker({
-            search: vi.fn().mockResolvedValue({
-                status: 'ok',
-                results: [
-                    {
-                        title: 'duck-duck-scrape - npm',
-                        url: 'https://www.npmjs.com/package/duck-duck-scrape',
-                        snippet: 'Package page'
-                    }
-                ],
-                metadata: { backend: 'duckduckgo', cacheHit: false }
-            }),
-            fetchPage: vi.fn().mockResolvedValue({
-                status: 'ok',
-                url: 'https://www.npmjs.com/package/duck-duck-scrape',
-                content: {
-                    title: 'duck-duck-scrape - npm',
-                    text: 'Package page, install instructions, version history.'
-                },
-                metadata: { method: 'http', cacheHit: false, contentType: 'text/html', truncated: false }
-            })
-        });
-        const result = await worker.run({
-            query: 'duckduckgo scraping node',
-            maxSearchRounds: 1,
-            maxFetches: 1
-        });
-        expect(result.evidence).toHaveLength(0);
-        expect(result.lowValueOutcomes).toEqual([
-            {
-                kind: 'low-value-page',
-                url: 'https://www.npmjs.com/package/duck-duck-scrape',
-                message: 'Fetched page did not add strong research evidence.'
-            }
-        ]);
-    });
-});

package/dist/tests/orchestration/research-workflow.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/orchestration/research-workflow.test.js

@@ -1,119 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createResearchWorkflow } from '../../src/orchestration/index.js';
-describe('research workflow composition', () => {
-    it('can compose the orchestrator from existing search and fetch capabilities', async () => {
-        const workflow = createResearchWorkflow({
-            search: async () => ({
-                status: 'ok',
-                results: [],
-                metadata: { backend: 'duckduckgo', cacheHit: false }
-            }),
-            fetchPage: async () => ({
-                status: 'unsupported',
-                url: 'https://example.com',
-                metadata: { method: 'http', cacheHit: false, contentType: 'text/html' }
-            }),
-            headlessFetch: async () => ({
-                status: 'error',
-                url: 'https://example.com',
-                metadata: { method: 'headless', cacheHit: false },
-                error: { code: 'BROWSER_NOT_FOUND', message: 'No browser found.' }
-            })
-        });
-        const result = await workflow.run({ query: 'example query' });
-        expect(result.decision.action).toBeDefined();
-    });
-    it('does not spend headless on a low-value npm package page when other technical sources exist', async () => {
-        const workflow = createResearchWorkflow({
-            search: async () => ({
-                status: 'ok',
-                results: [
-                    {
-                        title: 'ddg-search',
-                        url: 'https://github.com/camohiddendj/ddg-search',
-                        snippet: 'Node scraper'
-                    },
-                    {
-                        title: 'duck-duck-scrape - npm',
-                        url: 'https://www.npmjs.com/package/duck-duck-scrape',
-                        snippet: 'Package page'
-                    }
-                ],
-                metadata: { backend: 'duckduckgo', cacheHit: false }
-            }),
-            fetchPage: async ({ url }) => {
-                if (url.includes('github.com/camohiddendj/ddg-search')) {
-                    return {
-                        status: 'ok',
-                        url,
-                        content: {
-                            title: 'ddg-search',
-                            text: 'DuckDuckGo HTML search scraper with bot-detection and pagination notes.'
-                        },
-                        metadata: { method: 'http', cacheHit: false, contentType: 'text/html', truncated: false }
-                    };
-                }
-                return {
-                    status: 'needs_headless',
-                    url,
-                    metadata: { method: 'http', cacheHit: false, contentType: 'text/html' },
-                    error: { code: 'WEAK_EXTRACTION', message: 'Weak extraction.' }
-                };
-            },
-            headlessFetch: async () => ({
-                status: 'ok',
-                url: 'https://www.npmjs.com/package/duck-duck-scrape',
-                content: { title: 'Just a moment...', text: 'Security verification' },
-                metadata: {
-                    method: 'headless',
-                    cacheHit: false,
-                    browser: 'edge',
-                    navigationMs: 4000,
-                    truncated: false
-                }
-            })
-        });
-        const result = await workflow.run({ query: 'duckduckgo scraping node pitfalls' });
-        expect(result.decision.action).toBe('research-again');
-    });
-    it('produces enough approved evidence for web_explore to format a compact research result', async () => {
-        const workflow = createResearchWorkflow({
-            search: async () => ({
-                status: 'ok',
-                results: [
-                    {
-                        title: 'Coverage | Guide | Vitest',
-                        url: 'https://vitest.dev/guide/coverage.html',
-                        snippet: 'Coverage docs'
-                    },
-                    {
-                        title: 'coverage | Config | Vitest',
-                        url: 'https://vitest.dev/config/coverage',
-                        snippet: 'Coverage config'
-                    }
-                ],
-                metadata: { backend: 'duckduckgo', cacheHit: false }
-            }),
-            fetchPage: async ({ url }) => ({
-                status: 'ok',
-                url,
-                content: {
-                    title: url.includes('/config/') ? 'coverage | Config | Vitest' : 'Coverage | Guide | Vitest',
-                    text: url.includes('/config/')
-                        ? 'coverage.enabled and coverage.provider can be configured here.'
-                        : 'Set coverage.provider to v8 and install @vitest/coverage-v8.'
-                },
-                metadata: { method: 'http', cacheHit: false, contentType: 'text/html', truncated: false }
-            }),
-            headlessFetch: async () => ({
-                status: 'error',
-                url: 'https://example.com',
-                metadata: { method: 'headless', cacheHit: false },
-                error: { code: 'BROWSER_NOT_FOUND', message: 'No browser found.' }
-            })
-        });
-        const result = await workflow.run({ query: 'vitest coverage docs' });
-        expect(result.decision.action).toBe('answer');
-        expect(result.evidence.length).toBeGreaterThanOrEqual(2);
-    });
-});

package/dist/tests/package-manifest.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/package-manifest.test.js

@@ -1,29 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-const packageJsonPath = path.join(process.cwd(), 'package.json');
-const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-describe('package manifest', () => {
-    it('is configured for publishing as a public pi package', () => {
-        expect(packageJson.private).not.toBe(true);
-        expect(packageJson.name).toBe('@demigodmode/pi-web-agent');
-        expect(packageJson.keywords).toContain('pi-package');
-        expect(packageJson.publishConfig).toEqual({ access: 'public' });
-    });
-    it('points pi to the packaged runtime entrypoint', () => {
-        expect(packageJson.pi).toEqual({
-            extensions: ['./dist/extension.js']
-        });
-    });
-    it('declares a clean package surface', () => {
-        expect(packageJson.main).toBe('./dist/extension.js');
-        expect(packageJson.types).toBe('./dist/extension.d.ts');
-        expect(packageJson.exports).toEqual({
-            '.': {
-                types: './dist/extension.d.ts',
-                import: './dist/extension.js'
-            }
-        });
-        expect(packageJson.files).toEqual(['dist', 'README.md']);
-    });
-});

package/dist/tests/release-foundation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/release-foundation.test.js

@@ -1,16 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-const root = process.cwd();
-const packageJson = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8'));
-describe('release foundation', () => {
-    it('has a changelog file checked into the repo', () => {
-        expect(existsSync(path.join(root, 'CHANGELOG.md'))).toBe(true);
-    });
-    it('has a license file checked into the repo', () => {
-        expect(existsSync(path.join(root, 'LICENSE'))).toBe(true);
-    });
-    it('keeps package metadata compatible with open source publishing', () => {
-        expect(packageJson.license).toBe('AGPL-3.0-only');
-    });
-});

package/dist/tests/release-script.test.d.ts

@@ -1 +0,0 @@
-export {};