extension-develop 3.15.1 → 3.16.0

package/dist/946.mjs

@@ -0,0 +1,1670 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import pintor from "pintor";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+import dotenv from "dotenv";
+import { fetchExtensionFromStore } from "extension-from-store";
+import path_0 from "path";
+import { getSpecialFoldersData } from "browser-extension-manifest-fields";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+import * as __rspack_external_path from "path";
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_os from "os";
+import * as __rspack_external_vm from "vm";
+var package_namespaceObject = JSON.parse('{"rE":"3.16.0","El":{"@prefresh/core":"1.5.9","@prefresh/utils":"1.2.1","@rspack/core":"^2.0.1","@rspack/dev-server":"^2.0.1","@rspack/plugin-preact-refresh":"1.1.5","@rspack/plugin-react-refresh":"1.6.2","@swc/core":"^1.15.8","@swc/helpers":"^0.5.18","@vue/compiler-sfc":"3.5.26","adm-zip":"^0.5.16","browser-extension-manifest-fields":"^2.2.3","case-sensitive-paths-webpack-plugin":"^2.4.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","extension-from-store":"^0.1.1","go-git-it":"^5.1.5","ignore":"^7.0.5","less":"4.5.1","less-loader":"12.3.2","loader-utils":"^3.3.1","magic-string":"^0.30.21","parse5-utilities":"^1.0.0","pintor":"0.3.0","postcss":"8.5.10","postcss-loader":"8.2.1","postcss-preset-env":"11.1.1","postcss-scss":"4.0.9","preact":"10.27.3","react-refresh":"0.18.0","sass-loader":"16.0.7","schema-utils":"^4.3.3","svelte-loader":"3.2.4","tiny-glob":"^0.2.9","typescript":"5.9.3","unique-names-generator":"^4.7.1","vue":"3.5.26","vue-loader":"17.4.2","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3"}}');
+const fmt = {
+    heading: (title)=>pintor.underline(pintor.blue(title)),
+    label: (key)=>pintor.gray(key.toUpperCase()),
+    val: (value)=>pintor.underline(value),
+    code: (value)=>pintor.blue(value),
+    bullet: (value)=>`- ${value}`,
+    block (title, rows) {
+        const head = fmt.heading(title);
+        const body = rows.map(([key, value])=>`${fmt.label(key)} ${value}`).join('\n');
+        return `${head}\n${body}`;
+    },
+    truncate (input, max = 800) {
+        const s = (()=>{
+            try {
+                return 'string' == typeof input ? input : JSON.stringify(input);
+            } catch  {
+                return String(input);
+            }
+        })();
+        return s.length > max ? s.slice(0, max) + '…' : s;
+    }
+};
+function getLoggingPrefix(type) {
+    const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+    if (isAuthor) {
+        const base = 'error' === type ? 'ERROR Author says' : '⏵⏵⏵ Author says';
+        return pintor.brightMagenta(base);
+    }
+    if ('error' === type) return pintor.red('ERROR');
+    if ('warn' === type) return pintor.brightYellow('⏵⏵⏵');
+    if ('info' === type) return pintor.gray('⏵⏵⏵');
+    return pintor.green('⏵⏵⏵');
+}
+function isPathLike(input) {
+    return input.includes('/') || input.includes('\\') || __rspack_external_path.isAbsolute(input);
+}
+function manifestNotFoundError(manifestPath) {
+    return `${getLoggingPrefix('error')} Manifest file not found.\n${pintor.red('Ensure the path to your extension exists and try again.')}\n${pintor.red('NOT FOUND')}\n${pintor.gray('PATH')} ${pintor.underline(manifestPath)}`;
+}
+function previewing(browser) {
+    return `${getLoggingPrefix('info')} Previewing the extension on ${capitalizedBrowserName(browser)}...`;
+}
+function previewSkippedNoBrowser(browser) {
+    return `${getLoggingPrefix('info')} Skipping browser launch for ${capitalizedBrowserName(browser)} (no-browser).`;
+}
+function authorInstallNotice(target) {
+    return `${getLoggingPrefix('warn')} Author mode: installing ${target}.`;
+}
+function buildWebpack(projectDir, stats, browser) {
+    const statsJson = stats?.toJson({
+        all: false,
+        assets: true,
+        time: true
+    });
+    const outputPath = 'string' == typeof stats?.compilation?.outputOptions?.path ? stats.compilation.outputOptions.path : '';
+    const manifestPath = outputPath ? __rspack_external_path.join(outputPath, 'manifest.json') : __rspack_external_path.join(projectDir, 'manifest.json');
+    const manifest = JSON.parse(__rspack_external_fs.readFileSync(manifestPath, 'utf8'));
+    const assets = statsJson?.assets;
+    const heading = `${getLoggingPrefix('info')} Building ${pintor.blue(manifest.name)} extension using ${capitalizedBrowserName(browser)} defaults...\n`;
+    const buildTime = `\nBuild completed in ${((statsJson?.time || 0) / 1000).toFixed(2)} seconds.\n`;
+    const buildTarget = `Build Target: ${pintor.gray(capitalizedBrowserName(browser))}\n`;
+    const buildStatus = `Build Status: ${stats?.hasErrors() ? pintor.red('Failed') : pintor.green('Success')}\n`;
+    const version = `\nVersion: ${pintor.gray(manifest.version)}\n`;
+    const size = `Size: ${pintor.gray(getAssetsSize(assets))}\n`;
+    let output = '';
+    output += heading;
+    output += getAssetsTree(assets);
+    output += version;
+    output += size;
+    output += buildTarget;
+    output += buildStatus;
+    output += buildTime;
+    return output;
+}
+function buildSuccess() {
+    return `${getLoggingPrefix('success')} Build succeeded with no warnings. Your extension is ${pintor.green('ready for deployment')}.`;
+}
+function getWarningMessage(warning) {
+    if (!warning) return '';
+    if ('string' == typeof warning) return warning.trim();
+    const candidates = [
+        warning.message,
+        warning.details,
+        warning.reason,
+        warning.description
+    ];
+    for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return candidate.trim();
+    return '';
+}
+function getWarningSource(warning) {
+    if (!warning || 'string' == typeof warning) return 'bundler';
+    const candidates = [
+        warning.name,
+        warning.moduleName,
+        warning.moduleIdentifier,
+        warning.originName,
+        warning.pluginName
+    ];
+    for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return candidate.trim();
+    return 'bundler';
+}
+function getWarningArtifact(warning) {
+    if (!warning || 'string' == typeof warning) return '';
+    const candidates = [
+        warning.file,
+        warning.chunkName,
+        warning.moduleName
+    ];
+    for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return candidate.trim();
+    return '';
+}
+function classifyWarning(message, source) {
+    const haystack = `${message} ${source}`.toLowerCase();
+    if (haystack.includes('performance') || haystack.includes('asset size') || haystack.includes('entrypoint size') || haystack.includes('exceeds the recommended size') || haystack.includes('hints')) return 'Performance';
+    if (haystack.includes('deprecat') || haystack.includes('[dep_') || haystack.includes('legacy')) return 'Deprecation';
+    if (haystack.includes('invalid') || haystack.includes('unknown option') || haystack.includes('configuration') || haystack.includes('schema')) return 'Configuration';
+    if (haystack.includes('manifest') || haystack.includes('browser') || haystack.includes('target')) return 'Compatibility';
+    if (haystack.includes('runtime') || haystack.includes('will fail') || haystack.includes('cannot resolve') || haystack.includes('service_worker')) return 'Runtime-risk';
+    return 'Warning';
+}
+function suggestedHintForWarning(category) {
+    if ('Performance' === category) return 'Inspect the largest startup bundles and split optional code paths.';
+    if ('Deprecation' === category) return 'Move to the supported API or plugin path before the next update.';
+    if ('Configuration' === category) return 'Review extension and bundler config keys, then remove or rename invalid options.';
+    if ('Compatibility' === category) return 'Verify browser target and manifest compatibility for this build.';
+    if ('Runtime-risk' === category) return 'Address this before release; it may fail or degrade at runtime.';
+    return 'Re-run with EXTENSION_VERBOSE=1 to inspect full warning details.';
+}
+function buildSuccessWithWarnings(warningCount) {
+    return `${getLoggingPrefix('warn')} Build succeeded with ${warningCount} warning(s). Your extension is ${pintor.green('ready for deployment')}.`;
+}
+function buildWarningsDetails(warnings) {
+    if (!Array.isArray(warnings) || 0 === warnings.length) return '';
+    const blocks = [];
+    warnings.forEach((warning, index)=>{
+        const message = getWarningMessage(warning);
+        const source = getWarningSource(warning);
+        const artifact = getWarningArtifact(warning);
+        const category = classifyWarning(message, source);
+        const hint = suggestedHintForWarning(category);
+        if (!message) return void blocks.push(`${getLoggingPrefix('warn')} Warning ${index + 1}: details were suppressed by tool output.\n${formatWarningLabelLine('Source', pintor.gray(source))}\n${formatWarningLabelLine('Hint', 'Re-run with EXTENSION_VERBOSE=1 to inspect full warning messages.')}`);
+        const performanceWarning = parsePerformanceWarning(warning, source, artifact);
+        if (performanceWarning) return void blocks.push(performanceWarning);
+        const oneLine = message.replace(/\s+/g, ' ').trim();
+        const artifactSuffix = artifact ? ` ${pintor.gray(`(${artifact})`)}` : '';
+        blocks.push(`${getLoggingPrefix('warn')} ${category}: ${oneLine}${artifactSuffix}\n${formatWarningLabelLine('Source', pintor.gray(source))}\n${formatWarningLabelLine('Hint', hint)}`);
+    });
+    return blocks.join('\n\n');
+}
+function fetchingProjectPath(owner, project) {
+    return fmt.block('Fetching project', [
+        [
+            'URL',
+            fmt.val(`https://github.com/${owner}/${project}`)
+        ]
+    ]);
+}
+function downloadingProjectPath(projectName) {
+    const formatted = isPathLike(projectName) ? pintor.underline(projectName) : pintor.yellow(projectName);
+    return `${getLoggingPrefix('info')} Downloading ${formatted}...`;
+}
+function creatingProjectPath(projectPath) {
+    return `${getLoggingPrefix('info')} Creating a new browser extension...\n${pintor.gray('PATH')} ${pintor.underline(projectPath)}`;
+}
+function downloadedProjectFolderNotFound(cwd, candidates) {
+    return `${getLoggingPrefix('error')} Downloaded project folder not found.\n${pintor.gray('PATH')} ${pintor.underline(cwd)}\n${pintor.gray('Tried')} ${pintor.underline(candidates.join(', '))}`;
+}
+function packagingSourceFiles(zipPath) {
+    return `${getLoggingPrefix('info')} Packaging source files. Files in ${pintor.yellow('.gitignore')} will be excluded...\n${pintor.gray('PATH')} ${pintor.underline(zipPath)}.`;
+}
+function packagingDistributionFiles(zipPath) {
+    return `${getLoggingPrefix('info')} Packaging extension distribution files...\n${pintor.gray('PATH')} ${pintor.underline(zipPath)}`;
+}
+function treeWithSourceAndDistFiles(browser, name, sourceZip, destZip) {
+    return `📦 Package name: ${pintor.blue(`${name}`)}, Target Browser: ${capitalizedBrowserName(browser)}\n   ${pintor.gray('└─')} ${pintor.underline(`${sourceZip}`)} ${pintor.gray('(source)')}\n   ${pintor.gray('└─')} ${pintor.underline(`${destZip}`)} ${pintor.gray('(distribution)')}`;
+}
+function treeWithDistFilesbrowser(name, ext, browser, zipPath) {
+    return `📦 Package name: ${pintor.blue(`${name}.${ext}`)}, Target Browser: ${capitalizedBrowserName(browser)}\n   ${pintor.gray('└─')} ${pintor.underline(`${zipPath}`)} ${pintor.gray('(distribution)')}`;
+}
+function treeWithSourceFiles(name, ext, browser, zipPath) {
+    return `📦 Package name: ${pintor.blue(`${name}-source.${ext}`)}, Target Browser: ${capitalizedBrowserName(browser)}\n   ${pintor.gray('└─')} ${pintor.underline(`${zipPath}`)} ${pintor.gray('(source)')}`;
+}
+function writingTypeDefinitions(manifest) {
+    return `${getLoggingPrefix('info')} Writing type definitions for ${pintor.blue(manifest.name || '')}...`;
+}
+function writingTypeDefinitionsError(error) {
+    return `${getLoggingPrefix('error')} Failed to write the extension type definition.\n${pintor.red(error)}`;
+}
+function downloadingText(url) {
+    return fmt.block('Downloading extension', [
+        [
+            'URL',
+            fmt.val(url)
+        ]
+    ]);
+}
+function unpackagingExtension(zipFilePath) {
+    return `${getLoggingPrefix('info')} Unpackaging browser extension...\n${pintor.gray('PATH')} ${pintor.underline(zipFilePath)}`;
+}
+function unpackagedSuccessfully() {
+    return `${getLoggingPrefix('info')} Browser extension unpackaged ${pintor.green('successfully')}.`;
+}
+function failedToDownloadOrExtractZIPFileError(error) {
+    return `${getLoggingPrefix('error')} Failed to download or extract ZIP file.\n${pintor.red(error)}`;
+}
+function invalidRemoteZip(url, contentType) {
+    return `${getLoggingPrefix('error')} Remote URL does not appear to be a ZIP archive.\n${pintor.gray('URL')} ${pintor.underline(url)}\n${pintor.gray('Content-Type')} ${pintor.underline(contentType || 'unknown')}`;
+}
+function capitalizedBrowserName(browser) {
+    const b = String(browser || '');
+    const cap = b.charAt(0).toUpperCase() + b.slice(1);
+    return pintor.yellow(`${cap}`);
+}
+function getFileSize(fileSizeInBytes) {
+    return `${(fileSizeInBytes / 1024).toFixed(2)}KB`;
+}
+function getAssetsSize(assets) {
+    let totalSize = 0;
+    assets?.forEach((asset)=>{
+        totalSize += asset.size;
+    });
+    return getFileSize(totalSize);
+}
+function printTree(node, prefix = '') {
+    let output = '';
+    Object.keys(node).forEach((key, index, array)=>{
+        const isLast = index === array.length - 1;
+        const connector = isLast ? '└─' : '├─';
+        const sizeInKB = node[key].size ? ` (${getFileSize(node[key].size)})` : '';
+        output += `${pintor.gray(prefix)}${pintor.gray(connector)} ${key}${pintor.gray(sizeInKB)}\n`;
+        if ('object' == typeof node[key] && !node[key].size) output += printTree(node[key], `${prefix}${isLast ? '   ' : pintor.gray('│  ')}`);
+    });
+    return output;
+}
+function getAssetsTree(assets) {
+    const assetTree = {};
+    assets?.forEach((asset)=>{
+        const paths = asset.name.split('/');
+        let currentLevel = assetTree;
+        paths.forEach((part, index)=>{
+            if (!currentLevel[part]) currentLevel[part] = {};
+            if (index === paths.length - 1) currentLevel[part] = {
+                size: asset.size
+            };
+            else currentLevel = currentLevel[part];
+        });
+    });
+    return `.\n${printTree(assetTree)}`;
+}
+function formatWarningLabelLine(label, value) {
+    return `${pintor.gray('│')}  ${pintor.gray(`${label}:`)} ${value}`;
+}
+function parsePerformanceWarning(warning, source, _artifact) {
+    const normalized = getWarningBody(warning).replace(/\r/g, '');
+    const lower = normalized.toLowerCase();
+    const threshold = normalized.match(/\(([\d.]+\s(?:KiB|MiB|GiB|KB|MB|GB))\)/)?.[1] || '';
+    if (lower.includes('asset size limit')) return formatPerformanceWarningBlock({
+        title: 'asset size limit exceeded',
+        threshold,
+        impact: 'Large emitted files can increase package size and slow extension startup.',
+        source,
+        hint: 'Inspect the largest startup bundles and split optional code paths.'
+    });
+    if (lower.includes('entrypoint size limit')) return formatPerformanceWarningBlock({
+        title: 'entrypoint size limit exceeded',
+        threshold,
+        impact: 'Startup entrypoints are heavier than recommended.',
+        source,
+        hint: 'Keep startup entrypoints thin and defer non-critical code.'
+    });
+}
+function formatPerformanceWarningBlock(options) {
+    const lines = [
+        `${getLoggingPrefix('warn')} Performance: ${options.title}`
+    ];
+    if (options.threshold) lines.push(formatWarningLabelLine('Threshold', options.threshold));
+    lines.push(formatWarningLabelLine('Impact', options.impact));
+    lines.push(pintor.gray('│'));
+    lines.push(formatWarningLabelLine('Source', pintor.gray(options.source)));
+    lines.push(formatWarningLabelLine('Hint', options.hint));
+    return lines.join('\n');
+}
+function getWarningBody(warning) {
+    if (!warning) return '';
+    if ('string' == typeof warning) return warning;
+    return [
+        warning.message,
+        warning.details,
+        warning.reason,
+        warning.description
+    ].filter((value)=>'string' == typeof value && value.trim().length > 0).join('\n');
+}
+function isUsingExperimentalConfig(integration) {
+    return `${getLoggingPrefix('info')} Using ${pintor.yellow(integration)}.`;
+}
+function debugDirs(manifestDir, packageJsonDir) {
+    return `${getLoggingPrefix('info')} Directories\n${pintor.gray('MANIFEST_DIR')} ${pintor.underline(manifestDir)}\n${pintor.gray('PACKAGE_JSON_DIR')} ${pintor.underline(packageJsonDir)}`;
+}
+function debugBrowser(browser, chromiumBinary, geckoBinary) {
+    return `${getLoggingPrefix('info')} Browser Target\n${pintor.gray('BROWSER')} ${pintor.yellow(String(browser))}\n${pintor.gray('CHROMIUM_BINARY')} ${pintor.underline(String(chromiumBinary || 'auto'))}\n${pintor.gray('GECKO_BINARY')} ${pintor.underline(String(geckoBinary || 'auto'))}`;
+}
+function debugOutputPath(pathValue) {
+    return `${getLoggingPrefix('info')} Output Path\n${pintor.gray('PATH')} ${pintor.underline(pathValue)}`;
+}
+function debugPreviewOutput(outputPath, distPath) {
+    return `${getLoggingPrefix('info')} Preview Output\n${pintor.gray('OUTPUT')} ${pintor.underline(outputPath)}\n${pintor.gray('DIST')} ${pintor.underline(distPath)}`;
+}
+function debugContextPath(packageJsonDir) {
+    return `${getLoggingPrefix('info')} Context\n${pintor.gray('CONTEXT')} ${pintor.underline(packageJsonDir)}`;
+}
+function debugExtensionsToLoad(extensions) {
+    const header = `${getLoggingPrefix('info')} Extensions To Load (${extensions.length})`;
+    const list = extensions.map((e)=>`- ${pintor.underline(e)}`).join('\n');
+    return `${header}\n${list}`;
+}
+function noCompanionExtensionsResolved() {
+    return `${getLoggingPrefix('warn')} No companion extensions resolved from ${pintor.underline('extensions')} config.\n${pintor.gray('Ensure each companion extension is an unpacked extension directory containing a manifest.json (e.g., ./extensions/<name>/manifest.json).')}`;
+}
+function configLoadingError(configPath, error) {
+    return `${pintor.red('ERROR')} ${pintor.brightBlue('config load failed')}\n${fmt.label('PATH')} ${fmt.val(configPath)}\n` + pintor.red(fmt.truncate(error, 1200));
+}
+function buildCommandFailed(error) {
+    const message = (()=>{
+        if (error instanceof Error && error.message) return error.message;
+        return String(error || 'Unknown error');
+    })();
+    return `${getLoggingPrefix('error')} Build failed.\n${pintor.red(fmt.truncate(message, 1200))}`;
+}
+function managedDependencyConflict(duplicates, userPackageJsonPath) {
+    const list = duplicates.map((d)=>`- ${pintor.yellow(d)}`).join('\n');
+    return `${getLoggingPrefix('error')} Your project declares dependencies that are managed by ${pintor.blue('Extension.js')} and referenced in ${pintor.underline('extension.config.js')}\n${pintor.red('This can cause version conflicts and break the development/build process.')}\n\n${pintor.gray('Managed dependencies (remove these from your package.json):')}\n${list}\n\n${pintor.gray('PATH')} ${pintor.underline(userPackageJsonPath)}\nIf you need a different version, open an issue so we can consider bundling it safely.\nOperation aborted.`;
+}
+async function findUpLocal(filename, options) {
+    const root = __rspack_external_path.parse(options.cwd).root;
+    let currentDir = options.cwd;
+    while(true){
+        const candidate = __rspack_external_path.join(currentDir, filename);
+        try {
+            const stat = await __rspack_external_fs.promises.stat(candidate);
+            if (stat.isFile()) return candidate;
+        } catch  {}
+        if (currentDir === root) return;
+        currentDir = __rspack_external_path.dirname(currentDir);
+    }
+}
+async function findNearestPackageJson(manifestPath) {
+    try {
+        const manifestDir = __rspack_external_path.dirname(manifestPath);
+        const packageJsonPath = await findUpLocal('package.json', {
+            cwd: manifestDir
+        });
+        return packageJsonPath || null;
+    } catch (error) {
+        console.warn('Failed to find package.json:', error);
+        return null;
+    }
+}
+function validatePackageJson(packageJsonPath) {
+    try {
+        if (!__rspack_external_fs.existsSync(packageJsonPath)) return false;
+        const content = __rspack_external_fs.readFileSync(packageJsonPath, 'utf-8');
+        JSON.parse(content);
+        return true;
+    } catch (error) {
+        console.warn('Invalid package.json at:', packageJsonPath, error);
+        return false;
+    }
+}
+const isUrl = (url)=>{
+    try {
+        new URL(url);
+        return true;
+    } catch (e) {
+        return false;
+    }
+};
+async function importUrlSourceFromGithub(pathOrRemoteUrl, text) {
+    const cwd = process.cwd();
+    const url = new URL(pathOrRemoteUrl);
+    const segments = url.pathname.split('/').filter(Boolean);
+    const repoName = segments.length >= 2 ? segments[1] : segments[segments.length - 1];
+    const treeIndex = segments.indexOf('tree');
+    const expectedName = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments[segments.length - 1] : repoName;
+    const expectedPath = __rspack_external_path.resolve(cwd, expectedName);
+    if (__rspack_external_fs.existsSync(expectedPath)) try {
+        const entries = __rspack_external_fs.readdirSync(expectedPath);
+        if (0 === entries.length) __rspack_external_fs.rmSync(expectedPath, {
+            recursive: true,
+            force: true
+        });
+        else {
+            const hasManifest = (dir)=>{
+                const stack = [
+                    dir
+                ];
+                while(stack.length){
+                    const current = stack.pop();
+                    const items = __rspack_external_fs.readdirSync(current, {
+                        withFileTypes: true
+                    });
+                    for (const it of items){
+                        if (it.isFile() && 'manifest.json' === it.name) return true;
+                        if (it.isDirectory() && 'node_modules' !== it.name && 'dist' !== it.name && !it.name.startsWith('.')) stack.push(__rspack_external_path.join(current, it.name));
+                    }
+                }
+                return false;
+            };
+            if (hasManifest(expectedPath)) return expectedPath;
+            __rspack_external_fs.rmSync(expectedPath, {
+                recursive: true,
+                force: true
+            });
+        }
+    } catch  {}
+    async function tryGitClone() {
+        const { default: goGitIt } = await import("go-git-it");
+        await goGitIt(pathOrRemoteUrl, cwd, text);
+    }
+    async function tryZipFallback() {
+        const branch = -1 !== treeIndex && segments.length > treeIndex + 1 ? segments[treeIndex + 1] : 'main';
+        const owner = segments[0];
+        const repo = segments[1];
+        const subdir = -1 !== treeIndex && segments.length > treeIndex + 2 ? segments.slice(treeIndex + 2).join('/') : '';
+        const zipUrl = `https://codeload.github.com/${owner}/${repo}/zip/refs/heads/${branch}`;
+        const extractedPath = await importUrlSourceFromZip(zipUrl);
+        const extractedDirs = __rspack_external_fs.readdirSync(extractedPath, {
+            withFileTypes: true
+        }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+        const repoRootDir = extractedDirs.find((d)=>d.startsWith(`${repo}-${branch}`));
+        const repoRoot = repoRootDir ? __rspack_external_path.join(extractedPath, repoRootDir) : extractedPath;
+        return subdir ? __rspack_external_path.join(repoRoot, subdir) : repoRoot;
+    }
+    try {
+        await tryGitClone();
+    } catch  {
+        return await tryZipFallback();
+    }
+    const candidates = [];
+    if (-1 !== treeIndex && segments.length > treeIndex + 2) candidates.push(segments[segments.length - 1]);
+    candidates.push(repoName);
+    for (const name of candidates){
+        const p = __rspack_external_path.resolve(cwd, name);
+        if (__rspack_external_fs.existsSync(p)) return p;
+    }
+    const dirs = __rspack_external_fs.readdirSync(cwd, {
+        withFileTypes: true
+    }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+    for (const dir of dirs){
+        const manifestPath = __rspack_external_path.join(cwd, dir, 'manifest.json');
+        if (__rspack_external_fs.existsSync(manifestPath)) return __rspack_external_path.join(cwd, dir);
+    }
+    try {
+        const dirs = __rspack_external_fs.readdirSync(cwd, {
+            withFileTypes: true
+        }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+        const ghRoot = dirs.find((d)=>/-main$|-master$/.test(d));
+        if (ghRoot) return __rspack_external_path.join(cwd, ghRoot);
+    } catch  {}
+    throw new Error(downloadedProjectFolderNotFound(cwd, candidates));
+}
+async function importUrlSourceFromZip(pathOrRemoteUrl) {
+    const cwd = process.cwd();
+    const { downloadAndExtractZip } = await import("./0~zip.mjs");
+    const extractedPath = await downloadAndExtractZip(pathOrRemoteUrl, cwd);
+    return extractedPath;
+}
+async function getProjectPath(pathOrRemoteUrl) {
+    if (!pathOrRemoteUrl) return process.cwd();
+    if (isUrl(pathOrRemoteUrl)) {
+        const url = new URL(pathOrRemoteUrl);
+        if (url.protocol.startsWith('http')) {
+            const pathname = url.pathname.toLowerCase();
+            if (pathname.endsWith('.zip')) return await importUrlSourceFromZip(pathOrRemoteUrl);
+            if ('https://github.com' !== url.origin) {
+                const urlSource = await importUrlSourceFromZip(pathOrRemoteUrl);
+                return urlSource;
+            }
+            const urlData = url.pathname.split('/');
+            const owner = urlData.slice(1, 3)[0];
+            const project = urlData.slice(1, 3)[1];
+            console.log(fetchingProjectPath(owner, project));
+            const projectName = __rspack_external_path.basename(url.pathname);
+            const urlSource = await importUrlSourceFromGithub(pathOrRemoteUrl, downloadingProjectPath(projectName));
+            console.log(creatingProjectPath(url.pathname));
+            return urlSource;
+        }
+    }
+    return __rspack_external_path.resolve(process.cwd(), pathOrRemoteUrl);
+}
+async function getProjectStructure(pathOrRemoteUrl) {
+    const projectPath = await getProjectPath(pathOrRemoteUrl);
+    const isUnderDir = (baseDir, candidatePath)=>{
+        const rel = __rspack_external_path.relative(baseDir, candidatePath);
+        return Boolean(rel && !rel.startsWith('..') && !__rspack_external_path.isAbsolute(rel));
+    };
+    const packageJsonPathFromProject = await findNearestPackageJson(__rspack_external_path.join(projectPath, 'manifest.json'));
+    const packageJsonDirFromProject = packageJsonPathFromProject ? __rspack_external_path.dirname(packageJsonPathFromProject) : void 0;
+    const rootManifestPath = __rspack_external_path.join(projectPath, 'manifest.json');
+    const srcManifestPath = __rspack_external_path.join(projectPath, 'src', 'manifest.json');
+    let manifestPath = __rspack_external_fs.existsSync(srcManifestPath) ? srcManifestPath : rootManifestPath;
+    if (!__rspack_external_fs.existsSync(manifestPath)) {
+        if (packageJsonDirFromProject) throw new Error(manifestNotFoundError(manifestPath));
+        const findManifest = (dir)=>{
+            const files = __rspack_external_fs.readdirSync(dir, {
+                withFileTypes: true
+            });
+            for (const file of files){
+                if (file.isFile() && 'manifest.json' === file.name) return __rspack_external_path.join(dir, file.name);
+                if (file.isDirectory() && !file.name.startsWith('.') && 'node_modules' !== file.name && 'dist' !== file.name && 'public' !== file.name) {
+                    const found = findManifest(__rspack_external_path.join(dir, file.name));
+                    if (found) return found;
+                }
+            }
+            return null;
+        };
+        const foundManifest = findManifest(projectPath);
+        if (foundManifest) manifestPath = foundManifest;
+        else throw new Error(manifestNotFoundError(manifestPath));
+    }
+    const packageJsonPath = await findNearestPackageJson(manifestPath);
+    const packageJsonDir = packageJsonPath ? __rspack_external_path.dirname(packageJsonPath) : void 0;
+    if (packageJsonDir) {
+        const publicRoot = __rspack_external_path.join(packageJsonDir, 'public');
+        if (isUnderDir(publicRoot, manifestPath)) {
+            const fallbackSrc = __rspack_external_path.join(packageJsonDir, 'src', 'manifest.json');
+            const fallbackRoot = __rspack_external_path.join(packageJsonDir, 'manifest.json');
+            if (__rspack_external_fs.existsSync(fallbackSrc)) manifestPath = fallbackSrc;
+            else if (__rspack_external_fs.existsSync(fallbackRoot)) manifestPath = fallbackRoot;
+            else throw new Error(manifestNotFoundError(fallbackRoot));
+        }
+    }
+    if (!packageJsonPath || !validatePackageJson(packageJsonPath)) return {
+        manifestPath
+    };
+    return {
+        manifestPath,
+        packageJsonPath
+    };
+}
+function loadCommonJsConfigWithStableDirname(absolutePath) {
+    const code = __rspack_external_fs.readFileSync(absolutePath, 'utf-8');
+    const dirname = __rspack_external_path.dirname(absolutePath);
+    const requireFn = createRequire(absolutePath);
+    const module = {
+        exports: {}
+    };
+    const exports = module.exports;
+    const wrapped = `(function (exports, require, module, __filename, __dirname) {\n${code}\n})`;
+    const fn = new __rspack_external_vm.Script(wrapped, {
+        filename: absolutePath
+    }).runInThisContext();
+    fn(exports, requireFn, module, absolutePath, dirname);
+    return module.exports?.default || module.exports;
+}
+function findNearestWorkspaceRoot(startDir) {
+    let current = __rspack_external_path.resolve(startDir);
+    while(true){
+        if (__rspack_external_fs.existsSync(__rspack_external_path.join(current, 'pnpm-workspace.yaml'))) return current;
+        const parent = __rspack_external_path.dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+}
+function preloadEnvFilesFromDir(envDir, options) {
+    let loadedAny = false;
+    try {
+        const defaultsPath = __rspack_external_path.join(envDir, '.env.defaults');
+        if (__rspack_external_fs.existsSync(defaultsPath)) {
+            dotenv.config({
+                path: defaultsPath,
+                override: Boolean(options?.override),
+                quiet: true
+            });
+            loadedAny = true;
+        }
+        const envCandidates = [
+            '.env.development',
+            '.env.local',
+            '.env'
+        ];
+        for (const filename of envCandidates){
+            const filePath = __rspack_external_path.join(envDir, filename);
+            if (__rspack_external_fs.existsSync(filePath)) {
+                dotenv.config({
+                    path: filePath,
+                    override: Boolean(options?.override),
+                    quiet: true
+                });
+                loadedAny = true;
+                break;
+            }
+        }
+    } catch  {}
+    return {
+        loadedAny,
+        envDir
+    };
+}
+function findConfigFile(projectPath) {
+    const candidates = [
+        __rspack_external_path.join(projectPath, 'extension.config.js'),
+        __rspack_external_path.join(projectPath, 'extension.config.mjs'),
+        __rspack_external_path.join(projectPath, 'extension.config.cjs')
+    ];
+    return candidates.find((p)=>__rspack_external_fs.existsSync(p));
+}
+function preloadEnvFiles(projectDir) {
+    const local = preloadEnvFilesFromDir(projectDir);
+    if (local.loadedAny) return local;
+    const workspaceRoot = findNearestWorkspaceRoot(projectDir);
+    if (workspaceRoot && workspaceRoot !== projectDir) return preloadEnvFilesFromDir(workspaceRoot);
+    return local;
+}
+async function loadConfigFile(configPath) {
+    const absolutePath = __rspack_external_path.resolve(configPath);
+    const projectDir = __rspack_external_path.dirname(absolutePath);
+    preloadEnvFiles(projectDir);
+    try {
+        if (absolutePath.endsWith('.cjs')) {
+            const requireFn = createRequire(import.meta.url);
+            const required = requireFn(absolutePath);
+            return required?.default || required;
+        }
+        let esmImportPath = absolutePath;
+        try {
+            const originalContent = __rspack_external_fs.readFileSync(absolutePath, 'utf-8');
+            if (originalContent.includes('import.meta.env')) {
+                const tmpDir = __rspack_external_fs.mkdtempSync(__rspack_external_path.join(__rspack_external_os.tmpdir(), 'extension-config-esm-'));
+                const tmpPath = __rspack_external_path.join(tmpDir, __rspack_external_path.basename(absolutePath));
+                const envObjectLiteral = JSON.stringify(Object.fromEntries(Object.entries(process.env).map(([k, v])=>[
+                        k,
+                        v
+                    ])), null, 0);
+                const shimHeader = `const __IMPORT_META_ENV__ = Object.freeze(${envObjectLiteral});\n`;
+                const replaced = originalContent.replace(/import\.meta\.env/g, '__IMPORT_META_ENV__');
+                __rspack_external_fs.writeFileSync(tmpPath, `${shimHeader}${replaced}`, 'utf-8');
+                esmImportPath = tmpPath;
+            }
+        } catch  {}
+        const module = await import(pathToFileURL(esmImportPath).href);
+        return module.default || module;
+    } catch (err) {
+        const error = err;
+        try {
+            if (!absolutePath.endsWith('.mjs')) {
+                const requireFn = createRequire(import.meta.url);
+                let required;
+                try {
+                    required = requireFn(absolutePath);
+                } catch (requireErr) {
+                    const message = String(error?.message || '') + ' ' + String(requireErr?.message || '');
+                    const looksLikeCommonJsInEsm = message.includes('require is not defined in ES module scope') || message.includes('Cannot use import statement outside a module') || message.includes('ERR_REQUIRE_ESM');
+                    if (looksLikeCommonJsInEsm) try {
+                        required = loadCommonJsConfigWithStableDirname(absolutePath);
+                    } catch  {
+                        const tmpDir = __rspack_external_fs.mkdtempSync(__rspack_external_path.join(__rspack_external_os.tmpdir(), 'extension-config-'));
+                        const tmpCjsPath = __rspack_external_path.join(tmpDir, __rspack_external_path.basename(absolutePath, __rspack_external_path.extname(absolutePath)) + '.cjs');
+                        __rspack_external_fs.copyFileSync(absolutePath, tmpCjsPath);
+                        required = requireFn(tmpCjsPath);
+                    }
+                    else throw requireErr;
+                }
+                return required?.default || required;
+            }
+        } catch  {}
+        try {
+            const content = __rspack_external_fs.readFileSync(absolutePath, 'utf-8');
+            return JSON.parse(content);
+        } catch (jsonErr) {
+            throw new Error(`Failed to load config file: ${configPath}\nError: ${error.message || error}`);
+        }
+    }
+}
+async function loadCustomConfig(projectPath) {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (await config_loader_isUsingExperimentalConfig(projectPath)) try {
+            const userConfig = await loadConfigFile(configPath);
+            if (userConfig && 'function' == typeof userConfig.config) return userConfig.config;
+            if (userConfig && userConfig.config && 'object' == typeof userConfig.config) {
+                const partial = userConfig.config;
+                return (config)=>{
+                    const requireFn = createRequire(import.meta.url);
+                    const { merge } = requireFn('webpack-merge');
+                    return merge(config, partial);
+                };
+            }
+        } catch (err) {
+            const error = err;
+            console.error(configLoadingError(configPath, error));
+            throw err;
+        }
+    }
+    return (config)=>config;
+}
+async function loadCommandConfig(projectPath, command) {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (await config_loader_isUsingExperimentalConfig(projectPath)) try {
+            const userConfig = await loadConfigFile(configPath);
+            const baseExtensions = userConfig && userConfig.extensions ? {
+                extensions: userConfig.extensions
+            } : {};
+            const baseTranspilePackages = userConfig && Array.isArray(userConfig.transpilePackages) ? {
+                transpilePackages: userConfig.transpilePackages
+            } : {};
+            const perCommand = userConfig && userConfig.commands && userConfig.commands[command] ? userConfig.commands[command] : {};
+            return {
+                ...baseExtensions,
+                ...baseTranspilePackages,
+                ...perCommand
+            };
+        } catch (err) {
+            const error = err;
+            console.error(configLoadingError(configPath, error));
+            throw err;
+        }
+    }
+    return {};
+}
+async function loadBrowserConfig(projectPath, browser = 'chrome') {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (await config_loader_isUsingExperimentalConfig(projectPath)) try {
+            const userConfig = await loadConfigFile(configPath);
+            if (userConfig && userConfig.browser) {
+                const browsers = userConfig.browser;
+                if ('chromium-based' === browser) {
+                    if (browsers['chromium-based']) return browsers['chromium-based'];
+                    if (browsers.chromium) return browsers.chromium;
+                } else if ('gecko-based' === browser) {
+                    if (browsers['gecko-based']) return browsers['gecko-based'];
+                    if (browsers.firefox) return browsers.firefox;
+                } else {
+                    const direct = browsers[browser];
+                    if (direct) return direct;
+                }
+            }
+        } catch (err) {
+            const error = err;
+            console.error(configLoadingError(configPath, error));
+            throw err;
+        }
+    }
+    return {
+        browser: browser || 'chrome'
+    };
+}
+let userMessageDelivered = false;
+async function config_loader_isUsingExperimentalConfig(projectPath) {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (!userMessageDelivered) {
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(isUsingExperimentalConfig('extension.config.js'));
+            userMessageDelivered = true;
+        }
+        return true;
+    }
+    return false;
+}
+function assertNoManagedDependencyConflicts(userPackageJsonPath, projectPath) {
+    try {
+        const raw = __rspack_external_fs.readFileSync(userPackageJsonPath, 'utf-8');
+        const userPackageJson = JSON.parse(raw);
+        const userDeps = Array.from(new Set([
+            ...Object.keys(userPackageJson.dependencies || {}),
+            ...Object.keys(userPackageJson.devDependencies || {}),
+            ...Object.keys(userPackageJson.optionalDependencies || {}),
+            ...Object.keys(userPackageJson.peerDependencies || {})
+        ]));
+        const managedDeps = new Set([
+            ...Object.keys(package_namespaceObject.El || {}),
+            ...Object.keys(package_namespaceObject.optionalDependencies || {})
+        ]);
+        managedDeps.delete('webpack');
+        const userConfigJs = __rspack_external_path.join(projectPath, 'extension.config.js');
+        const userConfigMjs = __rspack_external_path.join(projectPath, 'extension.config.mjs');
+        const hasConfig = __rspack_external_fs.existsSync(userConfigJs) || __rspack_external_fs.existsSync(userConfigMjs);
+        if (!hasConfig) return;
+        const configPath = __rspack_external_fs.existsSync(userConfigJs) ? userConfigJs : userConfigMjs;
+        const configSource = __rspack_external_fs.readFileSync(configPath, 'utf-8');
+        const duplicates = userDeps.filter((d)=>managedDeps.has(d)).filter((d)=>configSource.includes(d)).sort();
+        if (duplicates.length > 0) {
+            console.error(managedDependencyConflict(duplicates, userPackageJsonPath));
+            process.exit(1);
+        }
+    } catch (error) {
+        if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(error);
+    }
+}
+function asAbsolute(p) {
+    return __rspack_external_path.isAbsolute(p) ? p : __rspack_external_path.resolve(p);
+}
+function getDirs(struct) {
+    const manifestDir = asAbsolute(__rspack_external_path.dirname(struct.manifestPath));
+    const packageJsonDir = asAbsolute(struct.packageJsonPath ? __rspack_external_path.dirname(struct.packageJsonPath) : manifestDir);
+    return {
+        manifestDir,
+        packageJsonDir
+    };
+}
+function getNodeModulesDir(packageJsonDir) {
+    return asAbsolute(__rspack_external_path.join(packageJsonDir, 'node_modules'));
+}
+function needsInstall(packageJsonDir) {
+    const nm = getNodeModulesDir(packageJsonDir);
+    const packageJsonPath = __rspack_external_path.join(packageJsonDir, 'package.json');
+    if (!__rspack_external_fs.existsSync(packageJsonPath)) return false;
+    try {
+        const raw = __rspack_external_fs.readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(raw);
+        const depsCount = Object.keys(packageJson?.dependencies || {}).length;
+        const devDepsCount = Object.keys(packageJson?.devDependencies || {}).length;
+        if (depsCount + devDepsCount === 0) return false;
+        if (!__rspack_external_fs.existsSync(nm)) return true;
+        const deps = Object.keys(packageJson?.dependencies || {});
+        const devDeps = Object.keys(packageJson?.devDependencies || {});
+        if (__rspack_external_fs.existsSync(__rspack_external_path.join(nm, '.pnpm'))) return false;
+        if (__rspack_external_fs.existsSync(__rspack_external_path.join(nm, '.modules.yaml'))) return false;
+        const hasInstalledDep = [
+            ...deps,
+            ...devDeps
+        ].some((dep)=>__rspack_external_fs.existsSync(__rspack_external_path.join(nm, dep)));
+        return !hasInstalledDep;
+    } catch  {
+        return true;
+    }
+}
+function normalizeBrowser(browser, chromiumBinary, geckoBinary) {
+    const requested = String(browser || '');
+    if (chromiumBinary) {
+        if (!requested || 'chromium-based' === requested) return 'chromium-based';
+        if ('chromium' === requested) return 'chromium';
+        if ('edge' === requested) return 'edge';
+        if ('chrome' === requested) return 'chrome';
+    }
+    if (geckoBinary) {
+        if (!requested || 'gecko-based' === requested || 'firefox-based' === requested) return 'gecko-based';
+        if ('firefox' === requested) return 'firefox';
+    }
+    switch(requested){
+        case 'chrome':
+            return 'chrome';
+        case 'edge':
+            return 'edge';
+        case 'chromium':
+            return 'chromium';
+        case 'chromium-based':
+            return 'chromium-based';
+        case 'firefox':
+            return 'firefox';
+        case 'gecko-based':
+        case 'firefox-based':
+            return 'gecko-based';
+        default:
+            return browser || 'chrome';
+    }
+}
+function getDistPath(packageJsonDir, browser) {
+    return asAbsolute(__rspack_external_path.join(packageJsonDir, 'dist', browser));
+}
+function computePreviewOutputPath(struct, browser, explicitOutputPath) {
+    const { manifestDir, packageJsonDir } = getDirs(struct);
+    if (explicitOutputPath) return asAbsolute(explicitOutputPath);
+    if (struct.packageJsonPath) {
+        const distDir = getDistPath(packageJsonDir, browser);
+        try {
+            if (__rspack_external_fs.existsSync(__rspack_external_path.join(distDir, 'manifest.json'))) return distDir;
+        } catch  {}
+    }
+    return manifestDir;
+}
+function devtoolsEngineFor(browser) {
+    switch(browser){
+        case 'chrome':
+            return 'chrome';
+        case 'edge':
+            return 'edge';
+        case 'chromium':
+        case 'chromium-based':
+            return 'chromium';
+        case 'firefox':
+        case 'gecko-based':
+            return 'firefox';
+        default:
+            return 'chrome';
+    }
+}
+function isDir(p) {
+    try {
+        return __rspack_external_fs.existsSync(p) && __rspack_external_fs.statSync(p).isDirectory();
+    } catch  {
+        return false;
+    }
+}
+function isFile(p) {
+    try {
+        return __rspack_external_fs.existsSync(p) && __rspack_external_fs.statSync(p).isFile();
+    } catch  {
+        return false;
+    }
+}
+function toAbs(projectRoot, p) {
+    return __rspack_external_path.isAbsolute(p) ? p : __rspack_external_path.resolve(projectRoot, p);
+}
+function isValidExtensionRoot(dir) {
+    if (!isDir(dir)) return false;
+    return isFile(__rspack_external_path.join(dir, 'manifest.json'));
+}
+function normalizeCompanionConfig(config) {
+    const explicitPaths = [];
+    let scanDir;
+    if (Array.isArray(config)) explicitPaths.push(...config.filter((p)=>'string' == typeof p));
+    else if (config && 'object' == typeof config) {
+        if (Array.isArray(config.paths)) explicitPaths.push(...config.paths.filter((p)=>'string' == typeof p));
+        if ('string' == typeof config.dir && config.dir.trim().length > 0) scanDir = config.dir.trim();
+    }
+    return {
+        dir: scanDir,
+        paths: explicitPaths
+    };
+}
+function resolve_config_isPathLike(value) {
+    if (__rspack_external_path.isAbsolute(value)) return true;
+    if (value.startsWith('./') || value.startsWith('../')) return true;
+    return value.includes('/') || value.includes('\\');
+}
+function isSubpathOf(parent, child) {
+    const rel = __rspack_external_path.relative(parent, child);
+    return '' !== rel && !rel.startsWith('..') && !__rspack_external_path.isAbsolute(rel);
+}
+function getBrowserFolder(browser) {
+    if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return 'firefox';
+    if ('edge' === browser) return 'edge';
+    return 'chrome';
+}
+function parseChromeWebStoreId(url) {
+    if ('chromewebstore.google.com' !== url.hostname) return null;
+    const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
+    return match ? match[1] : null;
+}
+function parseEdgeAddonsId(url) {
+    if ('microsoftedge.microsoft.com' !== url.hostname) return null;
+    const match = url.pathname.match(/\/([a-z]{32})(?:\/|$)/i);
+    return match ? match[1] : null;
+}
+function parseAmoSlug(url) {
+    if ('addons.mozilla.org' !== url.hostname) return null;
+    const match = url.pathname.match(/\/addon\/([^/]+)(?:\/|$)/i);
+    return match ? match[1] : null;
+}
+function parseStoreUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    } catch  {
+        return null;
+    }
+    const chromeId = parseChromeWebStoreId(url);
+    if (chromeId) return {
+        browser: 'chrome',
+        id: chromeId
+    };
+    const edgeId = parseEdgeAddonsId(url);
+    if (edgeId) return {
+        browser: 'edge',
+        id: edgeId
+    };
+    const amoSlug = parseAmoSlug(url);
+    if (amoSlug) return {
+        browser: 'firefox',
+        id: amoSlug
+    };
+    return null;
+}
+function ensurePathsUnderExtensions(projectRoot, paths) {
+    const extensionsRoot = __rspack_external_path.resolve(projectRoot, 'extensions');
+    return paths.map((p)=>{
+        const abs = toAbs(projectRoot, p);
+        if (abs !== extensionsRoot && !isSubpathOf(extensionsRoot, abs) && __rspack_external_path.resolve(abs) !== extensionsRoot) throw new Error(`Companion extensions must be inside ${extensionsRoot}.\nInvalid path: ${abs}`);
+        return abs;
+    });
+}
+function findExtensionRoots(dir, maxDepth = 3) {
+    const found = [];
+    function walk(current, depth) {
+        if (depth > maxDepth) return;
+        if (!isDir(current)) return;
+        if (isValidExtensionRoot(current)) return void found.push(current);
+        let entries = [];
+        try {
+            entries = __rspack_external_fs.readdirSync(current, {
+                withFileTypes: true
+            });
+        } catch  {
+            return;
+        }
+        for (const ent of entries)if (ent.isDirectory()) {
+            if (!ent.name.startsWith('.')) walk(__rspack_external_path.join(current, ent.name), depth + 1);
+        }
+    }
+    walk(dir, 0);
+    return found;
+}
+async function runExtensionFromStore(url, outDir) {
+    const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+    await fetchExtensionFromStore(url, {
+        outDir,
+        extract: true,
+        logger: isAuthor ? {
+            onInfo: (message)=>console.log(message),
+            onWarn: (message)=>console.warn(message),
+            onError: (message, error)=>console.error(message, error)
+        } : void 0
+    });
+}
+async function resolveStoreExtensionToPath(opts) {
+    const { projectRoot, storeUrl, browser, id } = opts;
+    const extensionsRoot = __rspack_external_path.resolve(projectRoot, 'extensions');
+    const targetRoot = __rspack_external_path.join(extensionsRoot, browser, id);
+    const manifestPath = __rspack_external_path.join(targetRoot, 'manifest.json');
+    if (isFile(manifestPath)) return targetRoot;
+    await runExtensionFromStore(storeUrl, __rspack_external_path.join(extensionsRoot, browser));
+    const candidates = findExtensionRoots(__rspack_external_path.join(extensionsRoot, browser));
+    let selected;
+    if (1 === candidates.length) selected = candidates[0];
+    else if (candidates.length > 1) {
+        const directMatch = candidates.find((c)=>__rspack_external_path.basename(c) === id);
+        const versionedMatch = candidates.find((c)=>__rspack_external_path.basename(c).startsWith(`${id}@`));
+        if (directMatch) selected = directMatch;
+        else if (versionedMatch) selected = versionedMatch;
+    }
+    if (!selected) throw new Error(`Could not locate an unpacked extension from ${storeUrl}.`);
+    __rspack_external_fs.mkdirSync(__rspack_external_path.dirname(targetRoot), {
+        recursive: true
+    });
+    if (__rspack_external_path.basename(selected).startsWith(`${id}@`)) __rspack_external_fs.renameSync(selected, targetRoot);
+    return targetRoot;
+}
+async function resolveCompanionExtensionsConfig(opts) {
+    const { projectRoot, browser, config } = opts;
+    if (!config) return;
+    const normalized = normalizeCompanionConfig(config);
+    const runtimeBrowser = getBrowserFolder(browser);
+    const resolvedPaths = [];
+    const localPaths = [];
+    for (const entry of normalized.paths){
+        const parsedStore = parseStoreUrl(entry);
+        if (parsedStore) {
+            if (parsedStore.browser !== runtimeBrowser) continue;
+            const resolvedPath = await resolveStoreExtensionToPath({
+                projectRoot,
+                storeUrl: entry,
+                browser: parsedStore.browser,
+                id: parsedStore.id
+            });
+            resolvedPaths.push(resolvedPath);
+            continue;
+        }
+        if (resolve_config_isPathLike(entry)) localPaths.push(entry);
+    }
+    if (localPaths.length > 0) {
+        const absLocalPaths = ensurePathsUnderExtensions(projectRoot, localPaths);
+        resolvedPaths.push(...absLocalPaths);
+    }
+    const output = {};
+    if ('string' == typeof normalized.dir) {
+        const absDir = toAbs(projectRoot, normalized.dir);
+        const extensionsRoot = __rspack_external_path.resolve(projectRoot, 'extensions');
+        if (absDir !== extensionsRoot && !isSubpathOf(extensionsRoot, absDir)) throw new Error(`extensions.dir must be inside ${extensionsRoot}.\nInvalid dir: ${absDir}`);
+        output.dir = normalized.dir;
+    }
+    if (resolvedPaths.length > 0) output.paths = resolvedPaths;
+    return output;
+}
+function isUnderPublicDir(entry, projectRoot, publicDir) {
+    if (!entry) return false;
+    const normalizedEntry = String(entry);
+    const candidate = path_0.isAbsolute(normalizedEntry) ? normalizedEntry : path_0.join(projectRoot, normalizedEntry);
+    const rel = path_0.relative(publicDir, candidate);
+    return Boolean(rel && !rel.startsWith('..') && !path_0.isAbsolute(rel));
+}
+function filterPublicEntrypoints(list, projectRoot, publicDir) {
+    const next = {};
+    for (const [key, value] of Object.entries(list || {})){
+        if (Array.isArray(value)) {
+            const filtered = value.filter((entry)=>!isUnderPublicDir(String(entry), projectRoot, publicDir));
+            if (filtered.length > 0) next[key] = filtered;
+            continue;
+        }
+        if ('string' == typeof value) {
+            if (!isUnderPublicDir(value, projectRoot, publicDir)) next[key] = value;
+            continue;
+        }
+    }
+    return next;
+}
+function getSpecialFoldersDataForCompiler(compiler) {
+    const projectRoot = compiler.options.context || '';
+    const publicDir = path_0.join(projectRoot, 'public');
+    const data = getSpecialFoldersData({
+        manifestPath: path_0.join(projectRoot, 'package.json')
+    });
+    return finalizeSpecialFoldersData(data, projectRoot, publicDir);
+}
+function getSpecialFoldersDataForProjectRoot(projectRoot) {
+    const publicDir = path_0.join(projectRoot, 'public');
+    const data = getSpecialFoldersData({
+        manifestPath: path_0.join(projectRoot, 'package.json')
+    });
+    return finalizeSpecialFoldersData(data, projectRoot, publicDir);
+}
+function finalizeSpecialFoldersData(data, projectRoot, publicDir) {
+    return {
+        ...data,
+        pages: filterPublicEntrypoints(data.pages, projectRoot, publicDir),
+        scripts: filterPublicEntrypoints(data.scripts, projectRoot, publicDir),
+        extensions: {
+            dir: './extensions'
+        }
+    };
+}
+function sanitize(obj) {
+    return Object.fromEntries(Object.entries(obj || {}).filter(([, value])=>void 0 !== value));
+}
+function nowISO() {
+    return new Date().toISOString();
+}
+function createRunId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function plugin_playwright_ensureDirSync(dirPath) {
+    try {
+        __rspack_external_fs.mkdirSync(dirPath, {
+            recursive: true
+        });
+    } catch  {}
+}
+function writeJsonAtomic(filePath, value) {
+    try {
+        const tmpPath = `${filePath}.tmp-${process.pid}`;
+        __rspack_external_fs.writeFileSync(tmpPath, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+        __rspack_external_fs.renameSync(tmpPath, filePath);
+    } catch  {}
+}
+function getPlaywrightMetadataDir(packageJsonDir, browser) {
+    return asAbsolute(__rspack_external_path.join(packageJsonDir, 'dist', 'extension-js', browser));
+}
+function createPlaywrightMetadataWriter(options) {
+    const metadataDir = getPlaywrightMetadataDir(options.packageJsonDir, options.browser);
+    const readyPath = asAbsolute(__rspack_external_path.join(metadataDir, 'ready.json'));
+    const eventsPath = asAbsolute(__rspack_external_path.join(metadataDir, 'events.ndjson'));
+    const base = {
+        command: options.command,
+        browser: options.browser,
+        runId: createRunId(),
+        startedAt: nowISO(),
+        distPath: options.distPath,
+        manifestPath: options.manifestPath,
+        port: (()=>{
+            if ('number' == typeof options.port && Number.isFinite(options.port)) return options.port;
+            if ('string' == typeof options.port) {
+                const parsed = parseInt(options.port, 10);
+                return Number.isFinite(parsed) ? parsed : null;
+            }
+            return null;
+        })()
+    };
+    function writeReady(status, extra) {
+        plugin_playwright_ensureDirSync(metadataDir);
+        const payload = {
+            ...base,
+            status,
+            pid: process.pid,
+            ts: nowISO(),
+            compiledAt: extra?.compiledAt ?? null,
+            errors: Array.isArray(extra?.errors) ? extra.errors : []
+        };
+        if (extra?.code) payload.code = extra.code;
+        if (extra?.message) payload.message = extra.message;
+        writeJsonAtomic(readyPath, payload);
+    }
+    function appendEvent(event) {
+        plugin_playwright_ensureDirSync(metadataDir);
+        try {
+            __rspack_external_fs.appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, 'utf-8');
+        } catch  {}
+    }
+    return {
+        metadataDir,
+        readyPath,
+        eventsPath,
+        writeStarting () {
+            writeReady('starting');
+        },
+        writeReady (compiledAt) {
+            writeReady('ready', {
+                compiledAt: compiledAt || nowISO()
+            });
+        },
+        writeError (code, message, errors) {
+            writeReady('error', {
+                code,
+                message,
+                errors: Array.isArray(errors) ? errors : [],
+                compiledAt: null
+            });
+        },
+        appendEvent
+    };
+}
+class PlaywrightPlugin {
+    static name = 'plugin-playwright';
+    writer;
+    command;
+    browser;
+    constructor(options){
+        this.browser = String(options.browser || 'chromium');
+        this.command = options.command || ('development' === options.mode ? 'dev' : 'start');
+        this.writer = createPlaywrightMetadataWriter({
+            packageJsonDir: options.packageJsonDir,
+            browser: this.browser,
+            command: this.command,
+            distPath: options.outputPath,
+            manifestPath: options.manifestPath,
+            port: options.port
+        });
+    }
+    apply(compiler) {
+        this.writer.writeStarting();
+        compiler.hooks.compile.tap(PlaywrightPlugin.name, ()=>{
+            this.writer.appendEvent({
+                type: 'compile_start',
+                ts: nowISO(),
+                command: this.command,
+                browser: this.browser
+            });
+        });
+        compiler.hooks.done.tap(PlaywrightPlugin.name, (stats)=>{
+            const durationMs = Number((stats?.compilation?.endTime || 0) - (stats?.compilation?.startTime || 0));
+            const hasErrors = Boolean(stats?.hasErrors?.());
+            const errorsCount = Number(Array.isArray(stats?.toJson?.({
+                all: false,
+                errors: true
+            })?.errors) ? stats.toJson({
+                all: false,
+                errors: true
+            }).errors.length : 0);
+            if (hasErrors) {
+                this.writer.appendEvent({
+                    type: 'compile_error',
+                    ts: nowISO(),
+                    command: this.command,
+                    browser: this.browser,
+                    durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
+                    errorCount: Number.isFinite(errorsCount) ? errorsCount : 1
+                });
+                this.writer.writeError('compile_error', 'Compilation failed', [
+                    `errors: ${String(errorsCount || 1)}`
+                ]);
+                return;
+            }
+            this.writer.appendEvent({
+                type: 'compile_success',
+                ts: nowISO(),
+                command: this.command,
+                browser: this.browser,
+                durationMs: Number.isFinite(durationMs) ? durationMs : void 0,
+                errorCount: 0
+            });
+            this.writer.writeReady(nowISO());
+        });
+        compiler.hooks.failed.tap(PlaywrightPlugin.name, (error)=>{
+            this.writer.appendEvent({
+                type: 'compile_error',
+                ts: nowISO(),
+                command: this.command,
+                browser: this.browser,
+                errorCount: 1
+            });
+            this.writer.writeError('compile_failed', error instanceof Error ? error.message : String(error));
+        });
+        compiler.hooks.watchClose.tap(PlaywrightPlugin.name, ()=>{
+            this.writer.appendEvent({
+                type: 'shutdown',
+                ts: nowISO(),
+                command: this.command,
+                browser: this.browser
+            });
+        });
+    }
+}
+function resolveCompanionExtensionDirs(opts) {
+    const { projectRoot, config } = opts;
+    const normalized = normalizeCompanionConfig(config);
+    const explicitPaths = normalized.paths;
+    const scanDir = normalized.dir;
+    const found = [];
+    for (const p of explicitPaths){
+        const abs = toAbs(projectRoot, p);
+        if (isValidExtensionRoot(abs)) found.push(abs);
+    }
+    if (scanDir) {
+        const absScan = toAbs(projectRoot, scanDir);
+        if (isDir(absScan)) {
+            let entries = [];
+            try {
+                entries = __rspack_external_fs.readdirSync(absScan, {
+                    withFileTypes: true
+                });
+            } catch  {
+                entries = [];
+            }
+            const scanOneLevel = (rootDir)=>{
+                let dirEntries = [];
+                try {
+                    dirEntries = __rspack_external_fs.readdirSync(rootDir, {
+                        withFileTypes: true
+                    });
+                } catch  {
+                    dirEntries = [];
+                }
+                for (const ent of dirEntries){
+                    if (!ent.isDirectory()) continue;
+                    if (ent.name.startsWith('.')) continue;
+                    const candidate = __rspack_external_path.join(rootDir, ent.name);
+                    if (isValidExtensionRoot(candidate)) found.push(candidate);
+                }
+            };
+            scanOneLevel(absScan);
+            if ('extensions' === __rspack_external_path.basename(absScan)) for (const ent of entries){
+                if (!ent.isDirectory()) continue;
+                if (ent.name.startsWith('.')) continue;
+                const browserDir = __rspack_external_path.join(absScan, ent.name);
+                scanOneLevel(browserDir);
+            }
+        }
+    }
+    const unique = [];
+    const seen = new Set();
+    for (const p of found)if (!seen.has(p)) {
+        seen.add(p);
+        unique.push(p);
+    }
+    return unique;
+}
+function hasNewTabOverride(extensionDir) {
+    const manifestPath = __rspack_external_path.join(extensionDir, 'manifest.json');
+    if (!__rspack_external_fs.existsSync(manifestPath)) return false;
+    try {
+        const raw = __rspack_external_fs.readFileSync(manifestPath, 'utf-8');
+        const manifest = JSON.parse(raw);
+        const newtab = manifest?.chrome_url_overrides?.newtab;
+        return 'string' == typeof newtab && newtab.trim().length > 0;
+    } catch  {
+        return false;
+    }
+}
+function resolveBuiltInExtensionForBrowser(input) {
+    const engine = devtoolsEngineFor(input.browser);
+    const packageRelativeCandidates = [
+        __rspack_external_path.join('dist', input.packageName, engine)
+    ];
+    const normalizedBaseDir = __rspack_external_path.normalize(input.baseDir);
+    const parentName = __rspack_external_path.basename(__rspack_external_path.dirname(normalizedBaseDir));
+    const baseName = __rspack_external_path.basename(normalizedBaseDir);
+    if ('programs' === parentName && 'develop' === baseName) packageRelativeCandidates.push(__rspack_external_path.join('..', '..', 'extensions', input.packageName, 'dist', engine));
+    for (const rel of packageRelativeCandidates){
+        const candidate = __rspack_external_path.resolve(input.baseDir, rel);
+        if (__rspack_external_fs.existsSync(candidate)) return candidate;
+    }
+}
+const RESERVED_BUILT_IN_NAMES = new Set([
+    'extension-js-devtools',
+    'extension-js-theme'
+]);
+function isReservedBuiltInPath(extensionPath) {
+    const base = __rspack_external_path.basename(__rspack_external_path.normalize(extensionPath));
+    if (RESERVED_BUILT_IN_NAMES.has(base)) return true;
+    const segments = __rspack_external_path.normalize(extensionPath).split(__rspack_external_path.sep);
+    return segments.some((segment)=>RESERVED_BUILT_IN_NAMES.has(segment));
+}
+function dedupeByResolvedPath(paths) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of paths){
+        const resolved = __rspack_external_path.resolve(entry);
+        if (!seen.has(resolved)) {
+            seen.add(resolved);
+            result.push(entry);
+        }
+    }
+    return result;
+}
+function computeExtensionsToLoad(baseDir, mode, browser, userExtensionOutputPath, extraExtensionDirs = [], userManifestPath) {
+    const list = [];
+    try {
+        const devtoolsForBrowser = resolveBuiltInExtensionForBrowser({
+            baseDir,
+            packageName: 'extension-js-devtools',
+            browser
+        });
+        const themeForBrowser = resolveBuiltInExtensionForBrowser({
+            baseDir,
+            packageName: 'extension-js-theme',
+            browser
+        });
+        const userHasNewTabOverride = hasNewTabOverride(userExtensionOutputPath) || ('string' == typeof userManifestPath ? hasNewTabOverride(__rspack_external_path.dirname(userManifestPath)) : false);
+        const devtoolsHasNewTabOverride = devtoolsForBrowser ? hasNewTabOverride(devtoolsForBrowser) : false;
+        const shouldSkipDevtoolsForNtpConflict = userHasNewTabOverride && devtoolsHasNewTabOverride;
+        if (devtoolsForBrowser && !shouldSkipDevtoolsForNtpConflict) list.push(devtoolsForBrowser);
+        if (themeForBrowser) list.push(themeForBrowser);
+    } catch  {}
+    for (const p of extraExtensionDirs)if (!isReservedBuiltInPath(p)) list.push(p);
+    list.push(userExtensionOutputPath);
+    return dedupeByResolvedPath(list);
+}
+function getDarkModeDefaults(browser) {
+    if ('chrome' === browser || 'edge' === browser || 'chromium' === browser || 'chromium-based' === browser) return {
+        browserFlags: [
+            '--force-dark-mode',
+            '--enable-features=WebUIDarkMode'
+        ],
+        preferences: {}
+    };
+    if ('firefox' === browser || 'gecko-based' === browser || 'firefox-based' === browser) return {
+        browserFlags: [],
+        preferences: {
+            'ui.systemUsesDarkTheme': 1,
+            'layout.css.prefers-color-scheme.content-override': 2,
+            'devtools.theme': 'dark'
+        }
+    };
+    return {
+        browserFlags: [],
+        preferences: {}
+    };
+}
+function withDarkMode(config) {
+    const defaults = getDarkModeDefaults(config.browser);
+    const existingFlags = Array.isArray(config.browserFlags) ? [
+        ...config.browserFlags
+    ] : [];
+    const nextFlags = [
+        ...existingFlags
+    ];
+    for (const flag of defaults.browserFlags || [])if (!nextFlags.some((f)=>String(f).trim() === flag)) nextFlags.push(flag);
+    const nextPreferences = {
+        ...config.preferences || {},
+        ...Object.fromEntries(Object.entries(defaults.preferences || {}).filter(([k])=>!(k in (config.preferences || {}))))
+    };
+    return {
+        ...config,
+        browserFlags: nextFlags,
+        preferences: nextPreferences
+    };
+}
+const cjsRequire = createRequire(import.meta.url);
+function messages_getLoggingPrefix(type) {
+    const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+    if (isAuthor) {
+        const base = 'error' === type ? 'ERROR Author says' : '⏵⏵⏵ Author says';
+        return pintor.brightMagenta(base);
+    }
+    if ('error' === type) return pintor.red('ERROR');
+    if ('warn' === type) return pintor.brightYellow('⏵⏵⏵');
+    if ('info' === type) return pintor.gray('⏵⏵⏵');
+    return pintor.green('⏵⏵⏵');
+}
+function messages_ready(mode, browser) {
+    const key = String(browser || '').toLowerCase();
+    const extensionOutput = 'firefox' === key || 'gecko-based' === key || 'firefox-based' === key || 'edge' === key ? 'Add-on' : 'Extension';
+    const cap = 'firefox' === key || 'gecko-based' === key || 'firefox-based' === key ? 'Firefox' : String(browser || '').charAt(0).toUpperCase() + String(browser || '').slice(1);
+    const pretty = pintor.green('ready for ' + mode);
+    return `${messages_getLoggingPrefix('info')} ${cap} ${extensionOutput} ${pretty}.`;
+}
+function readJsonRecord(filePath) {
+    try {
+        return JSON.parse(__rspack_external_fs.readFileSync(filePath, 'utf8'));
+    } catch  {
+        return null;
+    }
+}
+function capitalizeToken(value) {
+    return value.split('-').filter(Boolean).map((token)=>token.charAt(0).toUpperCase() + token.slice(1)).join('-');
+}
+function getExtensionVersion() {
+    return process.env.EXTENSION_DEVELOP_VERSION || process.env.EXTENSION_CLI_VERSION || (()=>{
+        try {
+            return cjsRequire('../package.json').version;
+        } catch  {
+            return 'unknown';
+        }
+    })();
+}
+function browserRunnerDisabled(args) {
+    const manifest = readJsonRecord(args.manifestPath);
+    const ready = readJsonRecord(args.readyPath);
+    const browserLabel = capitalizeToken(String(args.browser || 'unknown'));
+    const runId = String(ready?.runId || '').trim();
+    const pid = Number.isInteger(ready?.pid) ? String(ready?.pid) : '';
+    const runLabel = runId ? `${pintor.gray(runId)}${pid ? ` · ${pintor.gray(`PID ${pid}`)}` : ''}` : pid ? pintor.gray(`PID ${pid}`) : pintor.gray('n/a');
+    const extensionName = String(manifest?.name || 'Extension');
+    const extensionVersion = String(manifest?.version || '').trim();
+    const extensionLabel = extensionVersion ? `${extensionName} ${extensionVersion}` : extensionName;
+    const extensionJsVersion = getExtensionVersion();
+    return [
+        ` 🧩 ${pintor.brightBlue('Extension.js')} ${pintor.gray(extensionJsVersion)}`,
+        `    Browser        ${pintor.gray(args.browserModeLabel || `${browserLabel} (build-only mode)`)}`,
+        `    Extension      ${pintor.gray(extensionLabel)}`,
+        `    Run ID         ${runLabel}`
+    ].join('\n');
+}
+function portInUse(requestedPort, newPort) {
+    return `Port: Requested port ${pintor.brightBlue(requestedPort.toString())} is in use; using ${pintor.brightBlue(newPort.toString())} instead.`;
+}
+function extensionJsRunnerError(error) {
+    return `Extension.js Runner Error:\n${pintor.red(String(error))}`;
+}
+function autoExitModeEnabled(ms) {
+    return `Auto-exit enabled. Will exit after ${pintor.brightBlue(ms.toString())} ms if idle.`;
+}
+function autoExitTriggered(ms) {
+    return `Auto-exit triggered after ${pintor.brightBlue(ms.toString())} ms. Cleaning up...`;
+}
+function autoExitForceKill(ms) {
+    return `Force-killing process after ${pintor.brightBlue(ms.toString())} ms to ensure exit.`;
+}
+function devServerStartTimeout(ms) {
+    return [
+        `Dev server startup is taking longer than expected (${pintor.brightBlue(ms.toString())} ms).`,
+        "The bundler may have encountered an error before emitting the first build.",
+        `If nothing else prints, try setting ${pintor.brightBlue('EXTENSION_VERBOSE=1')} for more logs.`
+    ].join('\n');
+}
+function bundlerFatalError(error) {
+    const text = error instanceof Error ? error.stack || error.message : String(error);
+    return `Build failed to start:\n${pintor.red(text)}`;
+}
+function bundlerRecompiling() {
+    return "Recompiling due to file changes…";
+}
+function noEntrypointsDetected(port) {
+    return [
+        "No entrypoints or assets were produced by the initial compilation.",
+        `The dev server is running on 127.0.0.1:${pintor.brightBlue(port.toString())}, but nothing is being built.`,
+        "Possible causes:",
+        "  • Empty or missing entry configuration.",
+        "  • Extension-related plugins are disabled (entries not derived from manifest).",
+        "  • All sources are ignored or excluded.",
+        `Try enabling verbose logs with ${pintor.brightBlue('EXTENSION_VERBOSE=1')} or review your extension config.`
+    ].join('\n');
+}
+function spacerLine() {
+    return ' ';
+}
+var command_preview_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+async function extensionPreview(pathOrRemoteUrl, previewOptions, browserLauncher) {
+    const projectStructure = await getProjectStructure(pathOrRemoteUrl);
+    const debug = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+    const { manifestDir, packageJsonDir } = getDirs(projectStructure);
+    if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, packageJsonDir);
+    const browser = normalizeBrowser(previewOptions.browser || 'chrome', previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary);
+    const outputPath = computePreviewOutputPath(projectStructure, browser, previewOptions.outputPath);
+    const distPath = getDistPath(packageJsonDir, browser);
+    const metadataCommand = 'start' === previewOptions.metadataCommand ? 'start' : 'preview';
+    const metadata = createPlaywrightMetadataWriter({
+        packageJsonDir,
+        browser: String(browser),
+        command: metadataCommand,
+        distPath,
+        manifestPath: projectStructure.manifestPath,
+        port: 'number' == typeof previewOptions.port ? previewOptions.port : 'string' == typeof previewOptions.port ? parseInt(previewOptions.port, 10) : null
+    });
+    metadata.writeStarting();
+    if (debug) {
+        console.log(debugDirs(manifestDir, packageJsonDir));
+        console.log(debugBrowser(browser, previewOptions.chromiumBinary, previewOptions.geckoBinary || previewOptions.firefoxBinary));
+        console.log(debugPreviewOutput(outputPath, distPath));
+    }
+    const manifestAtOutput = __rspack_external_path.join(outputPath, 'manifest.json');
+    if (!__rspack_external_fs.existsSync(manifestAtOutput)) {
+        metadata.writeError('preview_manifest_missing', `Expected manifest at ${manifestAtOutput}`);
+        throw new Error(`Preview is run-only and does not compile.\nExpected an unpacked extension at:\n  ${manifestAtOutput}\n\nRun \`extension build\` or \`extension dev\` first, or pass --output-path to an existing unpacked extension directory.`);
+    }
+    const commandConfig = await loadCommandConfig(packageJsonDir, metadataCommand);
+    const browserConfig = await loadBrowserConfig(packageJsonDir, browser);
+    console.log(previewing(browser));
+    if (previewOptions.noBrowser) {
+        console.log(previewSkippedNoBrowser(browser));
+        metadata.writeReady();
+        console.log(spacerLine());
+        const browserLabel = String(browser || 'unknown');
+        console.log(browserRunnerDisabled({
+            browser: browserLabel,
+            manifestPath: projectStructure.manifestPath,
+            readyPath: metadata.readyPath,
+            browserModeLabel: `${browserLabel.charAt(0).toUpperCase() + browserLabel.slice(1)} (no-browser mode)`
+        }));
+        return;
+    }
+    const safeBrowserConfig = sanitize(browserConfig);
+    const safeCommandConfig = sanitize(commandConfig);
+    const safePreviewOptions = sanitize(previewOptions);
+    const specialFoldersData = getSpecialFoldersDataForProjectRoot(packageJsonDir);
+    const mergedExtensionsConfig = safePreviewOptions.extensions ?? safeCommandConfig.extensions ?? safeBrowserConfig.extensions ?? specialFoldersData.extensions;
+    const resolvedExtensionsConfig = await resolveCompanionExtensionsConfig({
+        projectRoot: packageJsonDir,
+        browser,
+        config: mergedExtensionsConfig
+    });
+    const mergedGeckoBinary = safePreviewOptions.geckoBinary || safePreviewOptions.firefoxBinary || safeCommandConfig.geckoBinary || safeCommandConfig.firefoxBinary || safeBrowserConfig.geckoBinary || safeBrowserConfig.firefoxBinary;
+    const mergedChromiumBinary = safePreviewOptions.chromiumBinary || safeCommandConfig.chromiumBinary || safeBrowserConfig.chromiumBinary;
+    const merged = {
+        ...safeBrowserConfig,
+        ...safeCommandConfig,
+        ...safePreviewOptions,
+        extensions: resolvedExtensionsConfig,
+        chromiumBinary: mergedChromiumBinary,
+        geckoBinary: mergedGeckoBinary
+    };
+    const darkDefaults = withDarkMode({
+        browser,
+        browserFlags: merged.browserFlags,
+        preferences: merged.preferences
+    });
+    const companionUnpackedExtensionDirs = resolveCompanionExtensionDirs({
+        projectRoot: packageJsonDir,
+        config: merged.extensions
+    });
+    const unpackedExtensionDirsToLoad = computeExtensionsToLoad(__rspack_external_path.resolve(command_preview_dirname, '..'), 'production', browser, outputPath, companionUnpackedExtensionDirs, projectStructure.manifestPath);
+    const resolvedOpts = {
+        browser,
+        outPath: outputPath,
+        contextDir: packageJsonDir,
+        readyPath: metadata.readyPath,
+        extensionsToLoad: unpackedExtensionDirsToLoad,
+        noOpen: merged.noOpen,
+        profile: merged.profile,
+        persistProfile: merged.persistProfile,
+        preferences: darkDefaults.preferences,
+        browserFlags: darkDefaults.browserFlags,
+        excludeBrowserFlags: merged.excludeBrowserFlags,
+        startingUrl: merged.startingUrl,
+        chromiumBinary: merged.chromiumBinary,
+        geckoBinary: merged.geckoBinary,
+        instanceId: merged.instanceId,
+        port: merged.port,
+        dryRun: merged.dryRun
+    };
+    if (!browserLauncher) throw new Error("extensionPreview requires a browserLauncher callback. The browser launch code has moved to programs/extension/browsers/.");
+    await browserLauncher(resolvedOpts);
+    metadata.writeReady();
+}
+export { PlaywrightPlugin, asAbsolute, assertNoManagedDependencyConflicts, authorInstallNotice, autoExitForceKill, autoExitModeEnabled, autoExitTriggered, browserRunnerDisabled, buildCommandFailed, buildSuccess, buildSuccessWithWarnings, buildWarningsDetails, buildWebpack, bundlerFatalError, bundlerRecompiling, computeExtensionsToLoad, createPlaywrightMetadataWriter, debugBrowser, debugContextPath, debugDirs, debugExtensionsToLoad, debugOutputPath, devServerStartTimeout, downloadingText, extensionJsRunnerError, extensionPreview, failedToDownloadOrExtractZIPFileError, getDirs, getDistPath, getProjectStructure, getSpecialFoldersDataForCompiler, getSpecialFoldersDataForProjectRoot, invalidRemoteZip, loadBrowserConfig, loadCommandConfig, loadCustomConfig, messages_ready, needsInstall, noCompanionExtensionsResolved, noEntrypointsDetected, normalizeBrowser, package_namespaceObject, packagingDistributionFiles, packagingSourceFiles, portInUse, resolveCompanionExtensionsConfig, sanitize, spacerLine, treeWithDistFilesbrowser, treeWithSourceAndDistFiles, treeWithSourceFiles, unpackagedSuccessfully, unpackagingExtension, writingTypeDefinitions, writingTypeDefinitionsError };