extension-develop 4.1.12 → 4.1.14

package/dist/77.mjs

@@ -0,0 +1,933 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import pintor from "pintor";
+import { spawnSync } from "node:child_process";
+import { fmt, prefix as messaging_prefix, artifactNoun } from "./349.mjs";
+import { findNearestDenoConfigSync, validateDenoConfig, PROJECT_MANIFEST_FILENAMES, readProjectDependencies } from "./80.mjs";
+import { parseJsonSafe } from "./23.mjs";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+function getLoggingPrefix(type) {
+    return messaging_prefix(type);
+}
+function isPathLike(input) {
+    return input.includes('/') || input.includes('\\') || __rspack_external_node_path_c5b9b54f.isAbsolute(input);
+}
+function resolvedWorkspaceManifest(projectPath, manifestPath) {
+    const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const packageDir = 'src' === __rspack_external_node_path_c5b9b54f.basename(manifestDir) ? __rspack_external_node_path_c5b9b54f.dirname(manifestDir) : manifestDir;
+    const display = __rspack_external_node_path_c5b9b54f.relative(projectPath, packageDir) || packageDir;
+    return `${getLoggingPrefix('info')} ${pintor.gray('Workspace root detected.')}\n${pintor.gray('PACKAGE')} ${pintor.underline(display)}`;
+}
+function remoteFetchTimedOut(target, ms) {
+    return `${getLoggingPrefix('error')} Timed out after ${Math.round(ms / 1000)} s fetching the remote file.\n${pintor.gray('URL')} ${pintor.underline(target)}\nCheck your network, or set ${pintor.blue('EXTENSION_FETCH_TIMEOUT_MS')} to allow more time.`;
+}
+function manifestInvalidJson(manifestPath, error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return `${getLoggingPrefix('error')} Couldn't parse manifest.json as JSON.\n${pintor.gray('PATH')} ${pintor.underline(manifestPath)}\n${pintor.gray('REASON')} ${pintor.red(detail)}\nFix the syntax error, then run the command again.`;
+}
+function notAnExtensionManifestError(manifestPath) {
+    return `${getLoggingPrefix('error')} manifest.json isn't a browser extension manifest.\nIt has no ${pintor.blue('manifest_version')} field, so it looks like a PWA web-app manifest.\n${pintor.gray('PATH')} ${pintor.underline(manifestPath)}\nPoint Extension.js at the directory that contains your extension manifest.`;
+}
+function manifestNotFoundError(manifestPath, candidates = []) {
+    const base = `${getLoggingPrefix('error')} Manifest file not found.\n${pintor.gray('NOT FOUND')} ${pintor.underline(manifestPath)}\nEnsure the path to your extension exists, then try again.`;
+    if (!candidates.length) return base;
+    const projectRoot = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+    const hint = 1 === candidates.length ? "Did you mean to point at this workspace package?" : "Did you mean to point at one of these workspace packages?";
+    const suggestions = candidates.map((candidate)=>{
+        const dir = 'manifest.json' === __rspack_external_node_path_c5b9b54f.basename(candidate) ? __rspack_external_node_path_c5b9b54f.dirname(candidate) : candidate;
+        const normalized = 'src' === __rspack_external_node_path_c5b9b54f.basename(dir) ? __rspack_external_node_path_c5b9b54f.dirname(dir) : dir;
+        const display = __rspack_external_node_path_c5b9b54f.isAbsolute(normalized) ? __rspack_external_node_path_c5b9b54f.relative(projectRoot, normalized) || normalized : normalized;
+        return `  extension dev ${display}`;
+    }).join('\n');
+    return `${base}\n\n${pintor.gray(hint)}\n${pintor.blue(suggestions)}`;
+}
+function previewingSourceFallback(browser, distDir) {
+    return `${getLoggingPrefix('warn')} No production build found at ${distDir}, previewing the source manifest directory instead.\nRun \`extension build --browser ${String(browser)}\` first to preview the built output.`;
+}
+function previewing(browser, noBrowser) {
+    const suffix = noBrowser ? ' (no-browser mode)' : '';
+    return `${getLoggingPrefix('info')} Previewing on ${capitalizedBrowserName(browser)}${suffix}.`;
+}
+function starting(browser, noBrowser) {
+    const suffix = noBrowser ? ' (no-browser mode)' : '';
+    return `${getLoggingPrefix('info')} Starting on ${capitalizedBrowserName(browser)}${suffix}.`;
+}
+function extensionLoadRecovered() {
+    return `${getLoggingPrefix('success')} The browser accepted the extension.\nIt's running now.`;
+}
+function extensionLoadStillRefused(reason) {
+    return `${getLoggingPrefix('error')} The browser still refuses to load this extension.\n${pintor.gray('REASON')} ${pintor.red(reason)}`;
+}
+function browserLaunchFailed(browser, reason) {
+    return `${getLoggingPrefix('error')} ${capitalizedBrowserName(browser)} couldn't start, so the extension isn't running.\n${reason}\nThe dev server keeps watching, but nothing will load until this is fixed.`;
+}
+function authorInstallNotice(target) {
+    return `${messaging_prefix('debug')} install  target=${target}`;
+}
+function projectInstallFallbackToNpm(pmName) {
+    return `${getLoggingPrefix('warn')} Dependency install with ${pmName} failed.\nExtension.js retries once with npm so the build can continue.`;
+}
+function projectInstallScriptsDisabled(pmName) {
+    return `${getLoggingPrefix('info')} Installing the project dependencies with ${pmName}…\nLifecycle scripts are disabled for safety.\nSet ${pintor.blue('EXTENSION_ALLOW_INSTALL_SCRIPTS=true')} to run them.`;
+}
+function anotherDevSessionActive(browser, pid, runId) {
+    const run = runId ? `, run ${runId}` : '';
+    return `${getLoggingPrefix('warn')} Another dev session is already writing dist/${browser} (PID ${pid}${run}).\nBoth sessions rebuild the same output, so the last compile wins.\nStop the other session, or pass ${fmt.code('--instance-id')} to run them side by side.`;
+}
+function buildAssetsTree(stats) {
+    const statsJson = stats?.toJson?.({
+        all: false,
+        assets: true
+    });
+    const assets = statsJson?.assets || [];
+    return getAssetsTree(assets);
+}
+function buildComplete(browser, distDisplayPath, totalBytes) {
+    const noun = artifactNoun(String(browser));
+    const size = 'number' == typeof totalBytes && totalBytes > 0 ? ` (${getHumanSize(totalBytes)})` : '';
+    return `${getLoggingPrefix('success')} ${noun} built for production in ${pintor.underline(distDisplayPath)}${size}.`;
+}
+function platformDocsUrl() {
+    return String(process.env.EXTENSION_DEV_DOCS_URL || '').trim().replace(/\/+$/, '');
+}
+function buildShareHint() {
+    const docs = platformDocsUrl();
+    if (!docs) return '';
+    return `${getLoggingPrefix('info')} Send this build to someone for review: ` + pintor.underline(`${docs}/share/unpublished-build-for-review?utm_source=cli-build`);
+}
+function buildFailed(errorCount) {
+    const count = Math.max(1, Math.floor(errorCount || 1));
+    const noun = 1 === count ? 'error' : 'errors';
+    return `${getLoggingPrefix('error')} Build failed with ${count} ${noun}.`;
+}
+function stripModuleWarningWrapper(message) {
+    return message.replace(/^Module (?:Warning|Error) \(from [^)]*\):\s*/, '');
+}
+function getWarningMessage(warning) {
+    if (!warning) return '';
+    if ('string' == typeof warning) return stripModuleWarningWrapper(warning.trim());
+    const candidates = [
+        warning.message,
+        warning.details,
+        warning.reason,
+        warning.description
+    ];
+    for (const candidate of candidates)if ('string' == typeof candidate && candidate.trim()) return stripModuleWarningWrapper(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 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) : 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('NOT FOUND')} ${pintor.underline(candidates.join(', '))}`;
+}
+function packagingSourceFiles(zipPath) {
+    return `${messaging_prefix('debug')} zip      pack=source gitignore=excluded path=${zipPath}`;
+}
+function zipArtifactReady(zipPath, sizeInBytes) {
+    return `${getLoggingPrefix('success')} Packaged ${pintor.underline(zipPath)} (${getHumanSize(sizeInBytes)}).`;
+}
+function packagingDistributionFiles(zipPath) {
+    return `${messaging_prefix('debug')} zip      pack=dist path=${zipPath}`;
+}
+function treeWithSourceAndDistFiles(browser, name, sourceZip, destZip) {
+    return `${messaging_prefix('debug')} zip      name=${name} browser=${String(browser)} source=${sourceZip} dist=${destZip}`;
+}
+function treeWithDistFilesBrowser(name, ext, browser, zipPath) {
+    return `${messaging_prefix('debug')} zip      name=${name}.${ext} browser=${String(browser)} dist=${zipPath}`;
+}
+function treeWithSourceFiles(name, ext, browser, zipPath) {
+    return `${messaging_prefix('debug')} zip      name=${name}-source.${ext} browser=${String(browser)} source=${zipPath}`;
+}
+function writingTypeDefinitions(manifest) {
+    return `${getLoggingPrefix('info')} Writing the type definitions for ${manifest.name || 'the extension'}…`;
+}
+function writingTypeDefinitionsError(error) {
+    return `${getLoggingPrefix('error')} Couldn't write the extension type definitions.\n${pintor.gray('REASON')} ${pintor.red(String(error))}\nCheck the file permissions, then try again.`;
+}
+function downloadingText(url) {
+    return fmt.block('Downloading extension', [
+        [
+            'URL',
+            fmt.val(url)
+        ]
+    ]);
+}
+function unpackagingExtension(zipFilePath) {
+    return `${getLoggingPrefix('info')} Unpackaging the browser extension…\n${pintor.gray('PATH')} ${pintor.underline(zipFilePath)}`;
+}
+function unpackagedSuccessfully() {
+    return `${getLoggingPrefix('success')} Extension unpackaged.`;
+}
+function failedToDownloadOrExtractZIPFileError(error) {
+    return `${getLoggingPrefix('error')} Couldn't download or extract the ZIP file.\n${pintor.gray('REASON')} ${pintor.red(String(error))}\nCheck the URL and your network, then try again.`;
+}
+function invalidRemoteZip(url, contentType) {
+    return `${getLoggingPrefix('error')} The remote URL doesn't point to a ZIP archive.\n${pintor.gray('URL')} ${pintor.underline(url)}\n${pintor.gray('GOT')} ${pintor.underline(contentType || 'unknown')}\nUse a direct-download URL, or download the file and pass the local path.`;
+}
+function notAZipArchive(source, contentType) {
+    return `${getLoggingPrefix('error')} The downloaded content isn't a ZIP archive.\n${pintor.gray('SOURCE')} ${pintor.underline(source)}\n` + (contentType ? `${pintor.gray('GOT')} ${pintor.underline(contentType)}\n` : '') + `The URL likely requires authentication and returned an HTML login page instead of the file.\n` + `This happens with Slack, Google Drive, and Dropbox file pages.\n` + "Download the ZIP in the browser and pass the local path, or use a direct-download URL.";
+}
+function localZipNotFound(zipFilePath) {
+    return `${getLoggingPrefix('error')} ZIP file not found.\n${pintor.gray('NOT FOUND')} ${pintor.underline(zipFilePath)}\nCheck the path, then try again.`;
+}
+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 getHumanSize(sizeInBytes) {
+    const bytes = Math.max(0, sizeInBytes || 0);
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+function printTree(node, prefix = '') {
+    let output = '';
+    Object.keys(node).forEach((key, index, array)=>{
+        const isLast = index === array.length - 1;
+        const connector = isLast ? '└─' : '├─';
+        const child = node[key];
+        const childNode = child && 'object' == typeof child ? child : void 0;
+        const isLeaf = 'number' == typeof childNode?.size;
+        const sizeInKB = isLeaf ? ` (${getFileSize(childNode?.size ?? 0)})` : '';
+        output += `${pintor.gray(prefix)}${pintor.gray(connector)} ${key}${pintor.gray(sizeInKB)}\n`;
+        if (childNode && !isLeaf) output += printTree(childNode, `${prefix}${isLast ? '   ' : pintor.gray('│  ')}`);
+    });
+    return output;
+}
+function getAssetsTree(assets) {
+    const assetTree = {};
+    assets?.forEach((asset)=>{
+        if ('string' != typeof asset?.name) return;
+        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];
+        });
+    });
+    if (0 === Object.keys(assetTree).length) return '';
+    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 `${messaging_prefix('debug')} config   using=${String(integration)}`;
+}
+function debugDirs(manifestDir, packageJsonDir) {
+    return `${messaging_prefix('debug')} dirs     manifest=${manifestDir} pkg=${packageJsonDir}`;
+}
+function debugBrowser(browser, chromiumBinary, geckoBinary) {
+    return `${messaging_prefix('debug')} browser  target=${String(browser)} chromiumBinary=${String(chromiumBinary || 'auto')} geckoBinary=${String(geckoBinary || 'auto')}`;
+}
+function debugOutputPath(pathValue) {
+    return `${messaging_prefix('debug')} output   path=${pathValue}`;
+}
+function previewingCustomOutput(browser, outputPath, distPath) {
+    return `${getLoggingPrefix('info')} Previewing ${String(browser)} from ${outputPath}.\nThis is not the build folder ${distPath}. The run record describes the folder loaded.`;
+}
+function debugPreviewOutput(outputPath, distPath) {
+    return `${messaging_prefix('debug')} preview  output=${outputPath} dist=${distPath}`;
+}
+function debugContextPath(packageJsonDir) {
+    return `${messaging_prefix('debug')} context  path=${packageJsonDir}`;
+}
+function debugExtensionsToLoad(extensions) {
+    return `${messaging_prefix('debug')} extensions count=${extensions.length} paths=${extensions.join(',')}`;
+}
+function noCompanionExtensionsResolved() {
+    return `${getLoggingPrefix('warn')} No companion extensions resolved from the ${pintor.blue('extensions')} config.\nPoint each entry at an unpacked extension directory that contains a manifest.json, for example ./extensions/<name>/manifest.json.`;
+}
+function configLoadingError(configPath, error) {
+    return `${getLoggingPrefix('error')} Couldn't load ${pintor.blue('extension.config.js')}.\n${fmt.label('PATH')} ${fmt.val(configPath)}\n${pintor.red(fmt.truncate(error, 1200))}\nFix the config file, then run the command again.`;
+}
+function buildCommandFailed(error) {
+    const message = (()=>{
+        if (error instanceof Error && error.message) return error.message;
+        return String(error || 'Unknown error');
+    })();
+    if (message.includes(getLoggingPrefix('error'))) return message;
+    return `${getLoggingPrefix('error')} ${pintor.red(fmt.truncate(message, 1200))}`;
+}
+function devCommandFailed(error) {
+    const message = (()=>{
+        if (error instanceof Error && error.message) return error.message;
+        return String(error || 'Unknown error');
+    })();
+    return `${getLoggingPrefix('error')} Dev mode 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 Extension.js already manages, so the build was aborted.\n${pintor.red('Duplicate declarations can cause version conflicts and break the build.')}\n\n${pintor.gray('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.`;
+}
+function isUrlShaped(target) {
+    return /^(?:\.[\\/])?[a-z][a-z0-9+.-]+:[\\/]+/i.test(target);
+}
+function findUpLocalSync(filename, options) {
+    if (isUrlShaped(options.cwd)) return;
+    const root = __rspack_external_node_path_c5b9b54f.parse(__rspack_external_node_path_c5b9b54f.resolve(options.cwd)).root;
+    let currentDir = __rspack_external_node_path_c5b9b54f.resolve(options.cwd);
+    while(true){
+        const candidate = __rspack_external_node_path_c5b9b54f.join(currentDir, filename);
+        try {
+            const stat = __rspack_external_node_fs_5ea92f0c.statSync(candidate);
+            if (stat.isFile()) return candidate;
+        } catch  {}
+        const parentDir = __rspack_external_node_path_c5b9b54f.dirname(currentDir);
+        if (currentDir === root || parentDir === currentDir) return;
+        currentDir = parentDir;
+    }
+}
+function findNearestPackageJsonSync(manifestPath) {
+    try {
+        const manifestDir = __rspack_external_node_path_c5b9b54f.dirname(manifestPath);
+        const packageJsonPath = findUpLocalSync('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_node_fs_5ea92f0c.existsSync(packageJsonPath)) return false;
+        const content = __rspack_external_node_fs_5ea92f0c.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;
+    }
+};
+const REMOTE_FETCH_TIMEOUT_MS = (()=>{
+    const raw = parseInt(String(process.env.EXTENSION_FETCH_TIMEOUT_MS || ''), 10);
+    return Number.isFinite(raw) && raw > 0 ? raw : 60000;
+})();
+function withTimeout(task, ms, label) {
+    let timer;
+    const timeout = new Promise((_, reject)=>{
+        timer = setTimeout(()=>reject(new Error(remoteFetchTimedOut(label, ms))), ms);
+    });
+    return Promise.race([
+        task,
+        timeout
+    ]).finally(()=>{
+        if (timer) clearTimeout(timer);
+    });
+}
+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_node_path_c5b9b54f.resolve(cwd, expectedName);
+    if (__rspack_external_node_fs_5ea92f0c.existsSync(expectedPath)) try {
+        const entries = __rspack_external_node_fs_5ea92f0c.readdirSync(expectedPath);
+        if (0 === entries.length) __rspack_external_node_fs_5ea92f0c.rmSync(expectedPath, {
+            recursive: true,
+            force: true
+        });
+        else {
+            const hasManifest = (dir)=>{
+                const stack = [
+                    dir
+                ];
+                while(stack.length){
+                    const current = stack.pop();
+                    const items = __rspack_external_node_fs_5ea92f0c.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_node_path_c5b9b54f.join(current, it.name));
+                    }
+                }
+                return false;
+            };
+            if (hasManifest(expectedPath)) return expectedPath;
+            __rspack_external_node_fs_5ea92f0c.rmSync(expectedPath, {
+                recursive: true,
+                force: true
+            });
+        }
+    } catch  {}
+    async function tryGitClone() {
+        const { default: goGitIt } = await import("go-git-it");
+        await withTimeout(goGitIt(pathOrRemoteUrl, cwd, text), REMOTE_FETCH_TIMEOUT_MS, pathOrRemoteUrl);
+    }
+    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_node_fs_5ea92f0c.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_node_path_c5b9b54f.join(extractedPath, repoRootDir) : extractedPath;
+        return subdir ? __rspack_external_node_path_c5b9b54f.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_node_path_c5b9b54f.resolve(cwd, name);
+        if (__rspack_external_node_fs_5ea92f0c.existsSync(p)) return p;
+    }
+    const dirs = __rspack_external_node_fs_5ea92f0c.readdirSync(cwd, {
+        withFileTypes: true
+    }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+    for (const dir of dirs){
+        const manifestPath = __rspack_external_node_path_c5b9b54f.join(cwd, dir, 'manifest.json');
+        if (__rspack_external_node_fs_5ea92f0c.existsSync(manifestPath)) return __rspack_external_node_path_c5b9b54f.join(cwd, dir);
+    }
+    try {
+        const dirs = __rspack_external_node_fs_5ea92f0c.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_node_path_c5b9b54f.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 withTimeout(downloadAndExtractZip(pathOrRemoteUrl, cwd), REMOTE_FETCH_TIMEOUT_MS, pathOrRemoteUrl);
+    return extractedPath;
+}
+async function importLocalSourceFromZip(zipFilePath) {
+    const cwd = process.cwd();
+    const { extractLocalZip } = await import("./0~zip.mjs");
+    return await extractLocalZip(zipFilePath, cwd);
+}
+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_node_path_c5b9b54f.basename(url.pathname);
+            const urlSource = await importUrlSourceFromGithub(pathOrRemoteUrl, downloadingProjectPath(projectName));
+            console.log(creatingProjectPath(url.pathname));
+            return urlSource;
+        }
+    }
+    const resolvedPath = __rspack_external_node_path_c5b9b54f.resolve(process.cwd(), pathOrRemoteUrl);
+    if ('.zip' === __rspack_external_node_path_c5b9b54f.extname(resolvedPath).toLowerCase() && __rspack_external_node_fs_5ea92f0c.existsSync(resolvedPath) && __rspack_external_node_fs_5ea92f0c.statSync(resolvedPath).isFile()) return await importLocalSourceFromZip(resolvedPath);
+    return resolvedPath;
+}
+function collectManifestCandidates(rootDir, maxDepth) {
+    const SKIP_DIRS = new Set([
+        'node_modules',
+        'dist',
+        'build',
+        'out',
+        '.git',
+        '.turbo',
+        '.next',
+        'coverage',
+        '.cache',
+        '.vercel'
+    ]);
+    const results = [];
+    const walk = (dir, depth)=>{
+        if (depth > maxDepth || results.length >= 10) return;
+        let entries;
+        try {
+            entries = __rspack_external_node_fs_5ea92f0c.readdirSync(dir, {
+                withFileTypes: true
+            });
+        } catch  {
+            return;
+        }
+        for (const entry of entries){
+            if (entry.isFile() && 'manifest.json' === entry.name) {
+                results.push(__rspack_external_node_path_c5b9b54f.join(dir, entry.name));
+                continue;
+            }
+            if (entry.isDirectory() && !entry.name.startsWith('.') && !SKIP_DIRS.has(entry.name)) walk(__rspack_external_node_path_c5b9b54f.join(dir, entry.name), depth + 1);
+        }
+    };
+    walk(rootDir, 0);
+    return results;
+}
+async function getProjectStructure(pathOrRemoteUrl) {
+    const projectPath = await getProjectPath(pathOrRemoteUrl);
+    return resolveProjectStructureSync(projectPath);
+}
+function resolveProjectStructureSync(projectPath, options = {}) {
+    const log = (line)=>{
+        if (!options.quiet) console.log(line);
+    };
+    const isUnderDir = (baseDir, candidatePath)=>{
+        const rel = __rspack_external_node_path_c5b9b54f.relative(baseDir, candidatePath);
+        return Boolean(rel && !rel.startsWith('..') && !__rspack_external_node_path_c5b9b54f.isAbsolute(rel));
+    };
+    const packageJsonPathFromProject = findNearestPackageJsonSync(__rspack_external_node_path_c5b9b54f.join(projectPath, 'manifest.json'));
+    const denoJsonPathFromProject = findNearestDenoConfigSync(__rspack_external_node_path_c5b9b54f.join(projectPath, 'manifest.json'));
+    const packageJsonDirFromProject = packageJsonPathFromProject ? __rspack_external_node_path_c5b9b54f.dirname(packageJsonPathFromProject) : denoJsonPathFromProject ? __rspack_external_node_path_c5b9b54f.dirname(denoJsonPathFromProject) : void 0;
+    const rootManifestPath = __rspack_external_node_path_c5b9b54f.join(projectPath, 'manifest.json');
+    const srcManifestPath = __rspack_external_node_path_c5b9b54f.join(projectPath, 'src', 'manifest.json');
+    let manifestPath = __rspack_external_node_fs_5ea92f0c.existsSync(srcManifestPath) ? srcManifestPath : rootManifestPath;
+    if (!__rspack_external_node_fs_5ea92f0c.existsSync(manifestPath)) if (packageJsonDirFromProject) {
+        const absoluteCandidates = collectManifestCandidates(projectPath, 3);
+        const relativeCandidates = absoluteCandidates.map((candidate)=>__rspack_external_node_path_c5b9b54f.relative(projectPath, candidate) || candidate);
+        if (1 === absoluteCandidates.length) {
+            manifestPath = absoluteCandidates[0];
+            log(resolvedWorkspaceManifest(projectPath, manifestPath));
+        } else throw new Error(manifestNotFoundError(manifestPath, relativeCandidates));
+    } else {
+        const MAX_DEPTH = 5;
+        const findManifest = (dir, depth)=>{
+            if (depth > MAX_DEPTH) return null;
+            let files;
+            try {
+                files = __rspack_external_node_fs_5ea92f0c.readdirSync(dir, {
+                    withFileTypes: true
+                });
+            } catch  {
+                return null;
+            }
+            for (const file of files){
+                if (file.isFile() && 'manifest.json' === file.name) return __rspack_external_node_path_c5b9b54f.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_node_path_c5b9b54f.join(dir, file.name), depth + 1);
+                    if (found) return found;
+                }
+            }
+            return null;
+        };
+        const foundManifest = findManifest(projectPath, 0);
+        if (foundManifest) manifestPath = foundManifest;
+        else throw new Error(manifestNotFoundError(manifestPath));
+    }
+    const readManifestObject = (candidatePath)=>{
+        try {
+            const parsed = parseJsonSafe(__rspack_external_node_fs_5ea92f0c.readFileSync(candidatePath));
+            if (null === parsed || 'object' != typeof parsed || Array.isArray(parsed)) return;
+            return parsed;
+        } catch  {
+            return;
+        }
+    };
+    const isPwaManifest = (candidatePath)=>{
+        const parsed = readManifestObject(candidatePath);
+        if (!parsed || null != parsed.manifest_version) return false;
+        return Array.isArray(parsed.icons) || 'string' == typeof parsed.start_url || 'string' == typeof parsed.display || null != parsed.related_applications || null != parsed.prefer_related_applications;
+    };
+    if (__rspack_external_node_fs_5ea92f0c.existsSync(manifestPath) && isPwaManifest(manifestPath)) {
+        const alternatives = collectManifestCandidates(projectPath, 3).filter((candidate)=>__rspack_external_node_path_c5b9b54f.resolve(candidate) !== __rspack_external_node_path_c5b9b54f.resolve(manifestPath) && readManifestObject(candidate)?.manifest_version != null);
+        if (1 === alternatives.length) {
+            manifestPath = alternatives[0];
+            log(resolvedWorkspaceManifest(projectPath, manifestPath));
+        } else throw new Error(notAnExtensionManifestError(manifestPath));
+    }
+    const packageJsonPath = findNearestPackageJsonSync(manifestPath);
+    const packageJsonDir = packageJsonPath ? __rspack_external_node_path_c5b9b54f.dirname(packageJsonPath) : void 0;
+    const nearestDenoJsonPath = findNearestDenoConfigSync(manifestPath);
+    const denoJsonPath = nearestDenoJsonPath && validateDenoConfig(nearestDenoJsonPath) ? nearestDenoJsonPath : void 0;
+    const projectRootDir = packageJsonDir ?? (denoJsonPath ? __rspack_external_node_path_c5b9b54f.dirname(denoJsonPath) : void 0);
+    if (projectRootDir) {
+        const publicRoot = __rspack_external_node_path_c5b9b54f.join(projectRootDir, 'public');
+        if (isUnderDir(publicRoot, manifestPath)) {
+            const fallbackSrc = __rspack_external_node_path_c5b9b54f.join(projectRootDir, 'src', 'manifest.json');
+            const fallbackRoot = __rspack_external_node_path_c5b9b54f.join(projectRootDir, 'manifest.json');
+            if (__rspack_external_node_fs_5ea92f0c.existsSync(fallbackSrc)) manifestPath = fallbackSrc;
+            else if (__rspack_external_node_fs_5ea92f0c.existsSync(fallbackRoot)) manifestPath = fallbackRoot;
+            else throw new Error(manifestNotFoundError(fallbackRoot));
+        }
+    }
+    if (!packageJsonPath || !validatePackageJson(packageJsonPath)) return {
+        manifestPath,
+        ...denoJsonPath ? {
+            denoJsonPath
+        } : {}
+    };
+    return {
+        manifestPath,
+        packageJsonPath,
+        ...denoJsonPath ? {
+            denoJsonPath
+        } : {}
+    };
+}
+function asAbsolute(p) {
+    return __rspack_external_node_path_c5b9b54f.isAbsolute(p) ? p : __rspack_external_node_path_c5b9b54f.resolve(p);
+}
+function toPosixPath(p) {
+    return p.split(__rspack_external_node_path_c5b9b54f.sep).join('/');
+}
+function getDirs(struct) {
+    const manifestDir = asAbsolute(__rspack_external_node_path_c5b9b54f.dirname(struct.manifestPath));
+    const projectManifestPath = struct.packageJsonPath || struct.denoJsonPath;
+    const packageJsonDir = asAbsolute(projectManifestPath ? __rspack_external_node_path_c5b9b54f.dirname(projectManifestPath) : manifestDir);
+    return {
+        manifestDir,
+        packageJsonDir
+    };
+}
+function getNodeModulesDir(packageJsonDir) {
+    return asAbsolute(__rspack_external_node_path_c5b9b54f.join(packageJsonDir, 'node_modules'));
+}
+function needsInstall(packageJsonDir) {
+    const nm = getNodeModulesDir(packageJsonDir);
+    const hasManifest = PROJECT_MANIFEST_FILENAMES.some((filename)=>__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(packageJsonDir, filename)));
+    if (!hasManifest) return false;
+    try {
+        const deps = Object.keys(readProjectDependencies(packageJsonDir));
+        if (0 === deps.length) return false;
+        if (!__rspack_external_node_fs_5ea92f0c.existsSync(nm)) return true;
+        if (__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(nm, '.pnpm'))) return false;
+        if (__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(nm, '.modules.yaml'))) return false;
+        if (__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(nm, '.deno'))) return false;
+        const hasInstalledDep = deps.some((dep)=>__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.join(nm, dep)));
+        return !hasInstalledDep;
+    } catch  {
+        return true;
+    }
+}
+const KNOWN_BROWSER_NAMES = new Set([
+    'chrome',
+    'edge',
+    'chromium',
+    'brave',
+    'opera',
+    'vivaldi',
+    'yandex',
+    'chromium-based',
+    'firefox',
+    'waterfox',
+    'librewolf',
+    'gecko-based',
+    'firefox-based',
+    'safari',
+    'webkit-based'
+]);
+function isKnownBrowserName(name) {
+    return 'string' == typeof name && KNOWN_BROWSER_NAMES.has(name);
+}
+function configBrowserOrThrow(configBrowser, command) {
+    if (null == configBrowser) return;
+    if (!isKnownBrowserName(configBrowser)) throw new Error(`Unsupported browser in extension.config commands.${command}.browser: ${String(configBrowser)}`);
+    return configBrowser;
+}
+function normalizeBrowser(browser, chromiumBinary, geckoBinary, safariBinary) {
+    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';
+    }
+    if (safariBinary) {
+        if (!requested || 'webkit-based' === requested) return 'webkit-based';
+        if ('safari' === requested) return 'safari';
+    }
+    switch(requested){
+        case 'chrome':
+            return 'chrome';
+        case 'edge':
+            return 'edge';
+        case 'chromium':
+            return 'chromium';
+        case 'brave':
+            return 'brave';
+        case 'opera':
+            return 'opera';
+        case 'vivaldi':
+            return 'vivaldi';
+        case 'yandex':
+            return 'yandex';
+        case 'chromium-based':
+            return 'chromium-based';
+        case 'firefox':
+            return 'firefox';
+        case 'waterfox':
+            return 'waterfox';
+        case 'librewolf':
+            return 'librewolf';
+        case 'gecko-based':
+        case 'firefox-based':
+            return 'gecko-based';
+        case 'safari':
+            return 'safari';
+        case 'webkit-based':
+            return 'webkit-based';
+        default:
+            return 'chrome';
+    }
+}
+function getDistPath(packageJsonDir, browser) {
+    return asAbsolute(__rspack_external_node_path_c5b9b54f.join(packageJsonDir, 'dist', browser));
+}
+function computePreviewOutputPath(struct, browser, explicitOutputPath) {
+    const { manifestDir, packageJsonDir } = getDirs(struct);
+    if (explicitOutputPath) return asAbsolute(explicitOutputPath);
+    if (struct.packageJsonPath || struct.denoJsonPath) {
+        const distDir = getDistPath(packageJsonDir, browser);
+        try {
+            if (__rspack_external_node_fs_5ea92f0c.existsSync(__rspack_external_node_path_c5b9b54f.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':
+        case 'brave':
+        case 'opera':
+        case 'vivaldi':
+        case 'yandex':
+            return 'chromium';
+        case 'firefox':
+        case 'gecko-based':
+        case 'waterfox':
+        case 'librewolf':
+            return 'firefox';
+        case 'safari':
+        case 'webkit-based':
+            return 'safari';
+        default:
+            return 'chrome';
+    }
+}
+function sessionStateDir(projectPath) {
+    return __rspack_external_node_path_c5b9b54f.resolve(projectPath, '.extension-js');
+}
+function controlPortFilePath(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(sessionStateDir(projectPath), `control-port-${browser}`);
+}
+function legacyControlPortFilePath(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(browserArtifactsDir(projectPath, browser), 'control-port');
+}
+function controlTokenPath(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(sessionStateDir(projectPath), `control-token-${browser}`);
+}
+function legacyControlTokenPath(projectPath) {
+    return __rspack_external_node_path_c5b9b54f.join(sessionStateDir(projectPath), 'control.token');
+}
+function sessionArtifactsRootDir(projectPath) {
+    return __rspack_external_node_path_c5b9b54f.resolve(projectPath, 'dist', 'extension-js');
+}
+const SESSION_ARTIFACTS_IGNORE_CONTENT = "# Extension.js session state: managed browser profiles (cookies, history,\n# logins), session logs and machine contracts. Personal data lives here:\n# this directory must never be committed or shipped.\n*\n";
+function sessionArtifactsIgnoreFilePath(projectPath) {
+    return __rspack_external_node_path_c5b9b54f.join(sessionArtifactsRootDir(projectPath), '.gitignore');
+}
+function ensureSessionArtifactsIgnoreFile(projectPath) {
+    try {
+        const ignoreFile = sessionArtifactsIgnoreFilePath(projectPath);
+        if (__rspack_external_node_fs_5ea92f0c.existsSync(ignoreFile)) return;
+        __rspack_external_node_fs_5ea92f0c.mkdirSync(__rspack_external_node_path_c5b9b54f.dirname(ignoreFile), {
+            recursive: true
+        });
+        __rspack_external_node_fs_5ea92f0c.writeFileSync(ignoreFile, SESSION_ARTIFACTS_IGNORE_CONTENT);
+    } catch  {}
+}
+function isAlreadyIgnoredByGit(projectPath) {
+    try {
+        const result = spawnSync('git', [
+            'check-ignore',
+            '-q',
+            '--',
+            '.extension-js/'
+        ], {
+            cwd: projectPath,
+            stdio: 'ignore'
+        });
+        return 0 === result.status;
+    } catch  {
+        return false;
+    }
+}
+function ensureSessionStateInProjectGitignore(projectPath) {
+    try {
+        const gitignorePath = __rspack_external_node_path_c5b9b54f.resolve(projectPath, '.gitignore');
+        if (!__rspack_external_node_fs_5ea92f0c.existsSync(gitignorePath)) return;
+        const content = __rspack_external_node_fs_5ea92f0c.readFileSync(gitignorePath, 'utf8');
+        const lines = content.split(/\r?\n/).map((line)=>line.trim());
+        if (lines.includes('.extension-js') || lines.includes('.extension-js/')) return;
+        if (isAlreadyIgnoredByGit(projectPath)) return;
+        const prefix = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+        __rspack_external_node_fs_5ea92f0c.appendFileSync(gitignorePath, `${prefix}\n# Extension.js local session state\n.extension-js\n`);
+    } catch  {}
+}
+function browserArtifactsDir(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(sessionArtifactsRootDir(projectPath), browser);
+}
+function browserProfileRootDir(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(sessionArtifactsRootDir(projectPath), 'profiles', `${browser}-profile`);
+}
+function browserDistDir(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.resolve(projectPath, 'dist', browser);
+}
+function readyContractPath(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(browserArtifactsDir(projectPath, browser), 'ready.json');
+}
+function eventsPath(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(browserArtifactsDir(projectPath, browser), 'events.ndjson');
+}
+function logsPath(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(browserArtifactsDir(projectPath, browser), 'logs.ndjson');
+}
+function actionsPath(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(browserArtifactsDir(projectPath, browser), 'actions.ndjson');
+}
+function buildSummaryPath(projectPath, browser) {
+    return __rspack_external_node_path_c5b9b54f.join(browserArtifactsDir(projectPath, browser), 'build-summary.json');
+}
+export { actionsPath, anotherDevSessionActive, asAbsolute, authorInstallNotice, browserArtifactsDir, browserDistDir, browserLaunchFailed, browserProfileRootDir, buildAssetsTree, buildCommandFailed, buildComplete, buildFailed, buildShareHint, buildSummaryPath, buildWarningsDetails, computePreviewOutputPath, configBrowserOrThrow, configLoadingError, controlPortFilePath, controlTokenPath, debugBrowser, debugContextPath, debugDirs, debugExtensionsToLoad, debugOutputPath, debugPreviewOutput, devCommandFailed, devtoolsEngineFor, downloadingText, ensureSessionArtifactsIgnoreFile, ensureSessionStateInProjectGitignore, eventsPath, extensionLoadRecovered, extensionLoadStillRefused, failedToDownloadOrExtractZIPFileError, getDirs, getDistPath, getProjectStructure, invalidRemoteZip, isUsingExperimentalConfig, legacyControlPortFilePath, legacyControlTokenPath, localZipNotFound, logsPath, managedDependencyConflict, manifestInvalidJson, needsInstall, noCompanionExtensionsResolved, normalizeBrowser, notAZipArchive, packagingDistributionFiles, packagingSourceFiles, previewing, previewingCustomOutput, previewingSourceFallback, projectInstallFallbackToNpm, projectInstallScriptsDisabled, readyContractPath, resolveProjectStructureSync, sessionArtifactsRootDir, sessionStateDir, starting, toPosixPath, treeWithDistFilesBrowser, treeWithSourceAndDistFiles, treeWithSourceFiles, unpackagedSuccessfully, unpackagingExtension, writingTypeDefinitions, writingTypeDefinitionsError, zipArtifactReady };