extension-develop 3.15.1 → 3.16.0

package/dist/962.mjs

@@ -0,0 +1,1389 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import { createRequire } from "module";
+import { execFileSync, spawn, spawnSync as external_child_process_spawnSync } from "child_process";
+import { EventEmitter } from "node:events";
+import pintor from "pintor";
+import { package_namespaceObject, buildSuccessWithWarnings, buildWarningsDetails, loadCommandConfig, needsInstall, getDirs, buildCommandFailed, sanitize, writingTypeDefinitions, buildWebpack, assertNoManagedDependencyConflicts, debugDirs, debugBrowser, normalizeBrowser, debugOutputPath, loadCustomConfig, buildSuccess, writingTypeDefinitionsError, getDistPath, getProjectStructure, loadBrowserConfig, authorInstallNotice, resolveCompanionExtensionsConfig, getSpecialFoldersDataForProjectRoot } from "./946.mjs";
+import { getCanonicalContentScriptEntryName } from "./526.mjs";
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+import { dirname as __rspack_dirname } from "node:path";
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_path from "path";
+import * as __rspack_external_fs_promises_400951f8 from "fs/promises";
+function getBuildSummary(browser, info) {
+    const assets = info?.assets || [];
+    return {
+        browser,
+        total_assets: assets.length,
+        total_bytes: assets.reduce((n, a)=>n + (a.size || 0), 0),
+        largest_asset_bytes: assets.reduce((m, a)=>Math.max(m, a.size || 0), 0),
+        warnings_count: (info?.warnings || []).length,
+        errors_count: (info?.errors || []).length
+    };
+}
+function parseJsonSafe(text) {
+    const raw = 'string' == typeof text ? text : String(text || '');
+    const s = raw && 0xfeff === raw.charCodeAt(0) ? raw.slice(1) : raw;
+    return JSON.parse(s || '{}');
+}
+var develop_context_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const cjsRequire = createRequire(import.meta.url);
+if (!process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION) process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION = package_namespaceObject.rE;
+function resolveDevelopRootFromDir(dir) {
+    try {
+        const packageJsonPath = __rspack_external_path.join(dir, 'package.json');
+        if (!__rspack_external_fs.existsSync(packageJsonPath)) return;
+        const pkg = parseJsonSafe(__rspack_external_fs.readFileSync(packageJsonPath, 'utf8'));
+        if (pkg?.name === 'extension-develop') return dir;
+    } catch  {}
+}
+function findDevelopRootFrom(startDir) {
+    let currentDir = startDir;
+    const maxDepth = 6;
+    for(let i = 0; i < maxDepth; i++){
+        const root = resolveDevelopRootFromDir(currentDir);
+        if (root) return root;
+        const parent = __rspack_external_path.dirname(currentDir);
+        if (parent === currentDir) break;
+        currentDir = parent;
+    }
+}
+function findExtensionDevelopRoot() {
+    const libDir = develop_context_dirname;
+    const buildDir = __rspack_external_path.resolve(libDir, '..');
+    const packageRoot = __rspack_external_path.resolve(buildDir, '..');
+    const packageJsonPath = __rspack_external_path.join(packageRoot, 'package.json');
+    if (__rspack_external_fs.existsSync(packageJsonPath)) try {
+        const pkg = JSON.parse(__rspack_external_fs.readFileSync(packageJsonPath, 'utf-8'));
+        if ('extension-develop' === pkg.name) return packageRoot;
+    } catch  {}
+    return null;
+}
+function resolveDevelopInstallRoot() {
+    const envRoot = process.env.EXTENSION_DEVELOP_ROOT;
+    if (envRoot) {
+        const resolvedEnvRoot = resolveDevelopRootFromDir(__rspack_external_path.resolve(envRoot));
+        if (resolvedEnvRoot) return resolvedEnvRoot;
+    }
+    const directRoot = findExtensionDevelopRoot();
+    if (directRoot) return directRoot;
+    try {
+        const candidateRoot = findDevelopRootFrom(develop_context_dirname);
+        if (candidateRoot) return candidateRoot;
+    } catch  {}
+    try {
+        const pkgPath = cjsRequire.resolve('extension-develop/package.json', {
+            paths: [
+                develop_context_dirname
+            ]
+        });
+        return resolveDevelopRootFromDir(__rspack_external_path.dirname(pkgPath));
+    } catch  {
+        return;
+    }
+}
+function resolveDevelopDistFile(stem) {
+    const installRoot = resolveDevelopInstallRoot();
+    const distRoot = installRoot ? __rspack_external_path.join(installRoot, 'dist') : __rspack_external_path.resolve(develop_context_dirname, '..');
+    const base = __rspack_external_path.join(distRoot, stem);
+    const candidates = [
+        `${base}.js`,
+        `${base}.cjs`,
+        `${base}.mjs`,
+        base
+    ];
+    for (const candidate of candidates)if (__rspack_external_fs.existsSync(candidate)) {
+        if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${candidate} (installRoot=${installRoot || '<none>'})`);
+        return candidate;
+    }
+    if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${base} (fallback, installRoot=${installRoot || '<none>'})`);
+    return base;
+}
+var package_manager_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+const package_manager_require = createRequire(import.meta.url);
+function normalizePackageManager(value) {
+    if (!value) return;
+    const lower = value.toLowerCase().trim();
+    if ('pnpm' === lower) return 'pnpm';
+    if ('yarn' === lower) return 'yarn';
+    if ('bun' === lower) return 'bun';
+    if ('npm' === lower) return 'npm';
+}
+function inferPackageManagerFromPath(value) {
+    if (!value) return;
+    const lower = value.toLowerCase();
+    if (lower.includes('pnpm')) return 'pnpm';
+    if (lower.includes('yarn')) return 'yarn';
+    if (lower.includes('bun')) return 'bun';
+    if (lower.includes('npm')) return 'npm';
+}
+function getPackageManagerOverride() {
+    const name = normalizePackageManager(process.env.EXTENSION_JS_PACKAGE_MANAGER);
+    const execPath = process.env.EXTENSION_JS_PM_EXEC_PATH || process.env.npm_execpath || process.env.NPM_EXEC_PATH;
+    if (!name && !execPath) return;
+    const inferredName = name || inferPackageManagerFromPath(execPath) || 'npm';
+    return {
+        name: inferredName,
+        execPath
+    };
+}
+function detectPackageManagerFromEnv() {
+    const userAgent = process.env.npm_config_user_agent || '';
+    const execPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
+    if (userAgent.includes('pnpm')) return {
+        name: 'pnpm',
+        execPath: execPath || void 0
+    };
+    if (userAgent.includes('yarn')) return {
+        name: 'yarn',
+        execPath: execPath || void 0
+    };
+    if (userAgent.includes('bun')) return {
+        name: 'bun',
+        execPath: execPath || void 0
+    };
+    if (userAgent.includes('npm')) return {
+        name: 'npm',
+        execPath: execPath || void 0
+    };
+    if (execPath) {
+        const inferred = inferPackageManagerFromPath(execPath) || 'npm';
+        return {
+            name: inferred,
+            execPath
+        };
+    }
+}
+function resolveNpmCliFromNode(execPath) {
+    const execDir = __rspack_external_path.dirname(execPath);
+    const candidates = [
+        __rspack_external_path.join(execDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+        __rspack_external_path.join(execDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+        __rspack_external_path.join(execDir, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js')
+    ];
+    for (const candidate of candidates)if (__rspack_external_fs.existsSync(candidate)) return candidate;
+}
+function resolveBundledNpmCliPath() {
+    if (process.env.EXTENSION_JS_PM_EXEC_PATH) {
+        const overridePath = process.env.EXTENSION_JS_PM_EXEC_PATH;
+        if (overridePath && __rspack_external_fs.existsSync(overridePath)) return overridePath;
+    }
+    try {
+        const resolved = package_manager_require.resolve('npm/bin/npm-cli.js', {
+            paths: [
+                process.cwd(),
+                package_manager_dirname
+            ]
+        });
+        if (resolved && __rspack_external_fs.existsSync(resolved)) return resolved;
+    } catch  {}
+    return resolveNpmCliFromNode(process.execPath);
+}
+function isWindowsExecutablePath(value) {
+    if (!value || 'win32' !== process.platform) return false;
+    return /\.(cmd|bat|exe)$/i.test(value);
+}
+function isNodeScriptPath(value) {
+    if (!value) return false;
+    return /\.(mjs|cjs|js)$/i.test(value);
+}
+function resolveWindowsCommandPath(command) {
+    if ('win32' !== process.platform) return;
+    try {
+        const systemRoot = process.env.SystemRoot || 'C:\\Windows';
+        const whereExe = __rspack_external_path.join(systemRoot, 'System32', 'where.exe');
+        const whereCommand = __rspack_external_fs.existsSync(whereExe) ? whereExe : 'where';
+        const output = execFileSync(whereCommand, [
+            command
+        ], {
+            encoding: 'utf8',
+            stdio: [
+                'ignore',
+                'pipe',
+                'ignore'
+            ],
+            windowsHide: true
+        });
+        const candidates = String(output).split(/\r?\n/).map((line)=>line.trim()).filter(Boolean);
+        const cmdMatch = candidates.find((line)=>/\.cmd$/i.test(line));
+        return cmdMatch || candidates[0];
+    } catch  {
+        return;
+    }
+}
+function resolveUnixCommandPath(command) {
+    if ('win32' === process.platform) return;
+    try {
+        const output = execFileSync('which', [
+            command
+        ], {
+            encoding: 'utf8',
+            stdio: [
+                'ignore',
+                'pipe',
+                'ignore'
+            ]
+        });
+        const candidate = String(output).trim();
+        return candidate || void 0;
+    } catch  {
+        return;
+    }
+}
+function resolveCommandOnPath(command) {
+    return resolveWindowsCommandPath(command) || resolveUnixCommandPath(command) || void 0;
+}
+function canRunCorepack() {
+    try {
+        const spawnSync = external_child_process_spawnSync;
+        const result = spawnSync('corepack', [
+            '--version'
+        ], {
+            stdio: 'ignore',
+            windowsHide: true
+        });
+        return result?.status === 0;
+    } catch  {
+        return false;
+    }
+}
+function detectByLockfile(cwd) {
+    if (!cwd) return;
+    const hasPnpmLock = __rspack_external_fs.existsSync(__rspack_external_path.join(cwd, 'pnpm-lock.yaml'));
+    const hasYarnLock = __rspack_external_fs.existsSync(__rspack_external_path.join(cwd, 'yarn.lock'));
+    const hasNpmLock = __rspack_external_fs.existsSync(__rspack_external_path.join(cwd, 'package-lock.json'));
+    if (hasPnpmLock) return 'pnpm';
+    if (hasYarnLock) return 'yarn';
+    if (hasNpmLock) return 'npm';
+}
+function hydrateResolvedPackageManager(name) {
+    const resolvedCommand = resolveCommandOnPath(name);
+    if (resolvedCommand) return {
+        name,
+        execPath: resolvedCommand
+    };
+    if ('npm' === name) {
+        const bundledNpmCli = resolveBundledNpmCliPath();
+        if (bundledNpmCli) return {
+            name: 'npm',
+            execPath: bundledNpmCli,
+            runnerCommand: process.execPath,
+            runnerArgs: [
+                bundledNpmCli
+            ]
+        };
+    }
+}
+function resolvePackageManager(opts) {
+    const lockPm = detectByLockfile(opts?.cwd);
+    if (lockPm) {
+        const hydrated = hydrateResolvedPackageManager(lockPm);
+        if (hydrated) return hydrated;
+        return {
+            name: lockPm
+        };
+    }
+    const override = getPackageManagerOverride();
+    if (override) return override;
+    const envPm = detectPackageManagerFromEnv();
+    if (envPm) return envPm;
+    const candidates = [
+        'pnpm',
+        'yarn',
+        'bun'
+    ];
+    for (const candidate of candidates){
+        const resolved = resolveCommandOnPath(candidate);
+        if (resolved) return {
+            name: candidate,
+            execPath: resolved
+        };
+    }
+    const corepackPath = resolveCommandOnPath('corepack');
+    if (corepackPath || canRunCorepack()) return {
+        name: 'pnpm',
+        runnerCommand: corepackPath || 'corepack',
+        runnerArgs: [
+            'pnpm'
+        ]
+    };
+    const bundledNpmCli = resolveBundledNpmCliPath();
+    if (bundledNpmCli) return {
+        name: 'npm',
+        execPath: bundledNpmCli,
+        runnerCommand: process.execPath,
+        runnerArgs: [
+            bundledNpmCli
+        ]
+    };
+    return {
+        name: 'npm'
+    };
+}
+function buildExecEnv() {
+    if ('win32' !== process.platform) return;
+    const nodeDir = __rspack_external_path.dirname(process.execPath);
+    const pathSep = __rspack_external_path.delimiter;
+    const existing = process.env.PATH || process.env.Path || '';
+    if (existing.includes(nodeDir)) return;
+    return {
+        ...process.env,
+        PATH: `${nodeDir}${pathSep}${existing}`.trim(),
+        Path: `${nodeDir}${pathSep}${existing}`.trim()
+    };
+}
+function buildInstallCommand(pm, args) {
+    if (pm.runnerCommand) return {
+        command: pm.runnerCommand,
+        args: [
+            ...pm.runnerArgs || [],
+            ...args
+        ]
+    };
+    if (pm.execPath) {
+        if (isWindowsExecutablePath(pm.execPath)) return {
+            command: pm.execPath,
+            args
+        };
+        if (isNodeScriptPath(pm.execPath)) return {
+            command: process.execPath,
+            args: [
+                pm.execPath,
+                ...args
+            ]
+        };
+        return {
+            command: pm.execPath,
+            args
+        };
+    }
+    return {
+        command: pm.name,
+        args
+    };
+}
+function buildSpawnInvocation(command, args) {
+    return {
+        command,
+        args
+    };
+}
+function execInstallCommand(command, args, options) {
+    const invocation = buildSpawnInvocation(command, args);
+    const env = buildExecEnv();
+    const stdio = options?.stdio ?? 'ignore';
+    const useShell = 'win32' === process.platform && /\.(cmd|bat)$/i.test(invocation.command);
+    return new Promise((resolve, reject)=>{
+        const child = spawn(invocation.command, invocation.args, {
+            cwd: options?.cwd,
+            stdio,
+            env: env || process.env,
+            ...useShell ? {
+                shell: true
+            } : {}
+        });
+        child.on('close', (code)=>{
+            if (0 !== code) reject(new Error(`Install failed with exit code ${code}`));
+            else resolve();
+        });
+        child.on('error', (error)=>reject(error));
+    });
+}
+async function ensureUserProjectDependencies(packageJsonDir) {
+    if (!needsInstall(packageJsonDir)) return;
+    const pm = resolvePackageManager({
+        cwd: packageJsonDir
+    });
+    const cmd = buildInstallCommand(pm, [
+        'install'
+    ]);
+    await execInstallCommand(cmd.command, cmd.args, {
+        cwd: packageJsonDir,
+        stdio: 'inherit'
+    });
+}
+async function ensureDevelopArtifacts() {
+    const developRoot = findExtensionDevelopRoot();
+    if (!developRoot) return;
+    const requiredFiles = [
+        __rspack_external_path.join(developRoot, 'dist', "ensure-hmr-for-scripts.js"),
+        __rspack_external_path.join(developRoot, 'dist', "minimum-script-file.js")
+    ];
+    const missing = requiredFiles.filter((file)=>!__rspack_external_fs.existsSync(file));
+    if (0 === missing.length) return;
+    const pm = resolvePackageManager({
+        cwd: developRoot
+    });
+    const command = buildInstallCommand(pm, [
+        'run',
+        'compile'
+    ]);
+    const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+    const stdio = isAuthor ? 'inherit' : 'ignore';
+    if (isAuthor) console.warn(authorInstallNotice('extension-develop build artifacts (dist missing)'));
+    await execInstallCommand(command.command, command.args, {
+        cwd: developRoot,
+        stdio
+    });
+}
+async function extensionBuild(pathOrRemoteUrl, buildOptions) {
+    const projectStructure = await getProjectStructure(pathOrRemoteUrl);
+    const isVitest = 'true' === process.env.VITEST;
+    const shouldExitOnError = (buildOptions?.exitOnError ?? true) && !isVitest;
+    const browser = normalizeBrowser(buildOptions?.browser || 'chrome', buildOptions?.chromiumBinary, buildOptions?.geckoBinary || buildOptions?.firefoxBinary);
+    const { manifestDir, packageJsonDir } = getDirs(projectStructure);
+    const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+    try {
+        await ensureDevelopArtifacts();
+        if (buildOptions?.install !== false) await ensureUserProjectDependencies(packageJsonDir);
+        const [{ rspack }, { merge }, { handleStatsErrors }, { default: webpackConfig }] = await Promise.all([
+            import("@rspack/core"),
+            import("webpack-merge"),
+            import("./0~stats-handler.mjs"),
+            import("./0~rspack-config.mjs").then((m)=>m.rspack_config_namespaceObject)
+        ]);
+        const debug = isAuthor;
+        if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, manifestDir);
+        const commandConfig = await loadCommandConfig(packageJsonDir, 'build');
+        const specialFoldersData = getSpecialFoldersDataForProjectRoot(packageJsonDir);
+        const distPath = getDistPath(packageJsonDir, browser);
+        try {
+            __rspack_external_fs.rmSync(distPath, {
+                recursive: true,
+                force: true
+            });
+        } catch  {}
+        if (debug) {
+            console.log(debugDirs(manifestDir, packageJsonDir));
+            console.log(debugBrowser(browser, buildOptions?.chromiumBinary, buildOptions?.geckoBinary || buildOptions?.firefoxBinary));
+            console.log(debugOutputPath(distPath));
+        }
+        const mergedExtensionsConfig = buildOptions?.extensions ?? commandConfig.extensions ?? specialFoldersData.extensions;
+        const resolvedExtensionsConfig = await resolveCompanionExtensionsConfig({
+            projectRoot: packageJsonDir,
+            browser,
+            config: mergedExtensionsConfig
+        });
+        const resolvedMode = buildOptions?.mode === 'development' || buildOptions?.mode === 'none' || buildOptions?.mode === 'production' ? buildOptions.mode : 'production';
+        if ('development' === resolvedMode || 'production' === resolvedMode) process.env.NODE_ENV = resolvedMode;
+        const baseConfig = webpackConfig(projectStructure, {
+            ...commandConfig,
+            ...buildOptions,
+            extensions: resolvedExtensionsConfig,
+            browser,
+            mode: resolvedMode,
+            output: {
+                clean: true,
+                path: distPath
+            }
+        });
+        const allPluginsButBrowserRunners = baseConfig.plugins?.filter((plugin)=>plugin?.constructor.name !== 'plugin-browsers');
+        const userExtensionConfig = await loadCustomConfig(packageJsonDir);
+        const userConfig = userExtensionConfig({
+            ...baseConfig,
+            plugins: allPluginsButBrowserRunners
+        });
+        const compilerConfig = merge(userConfig);
+        compilerConfig.stats = false;
+        const compiler = rspack(compilerConfig);
+        let summary = {
+            browser,
+            total_assets: 0,
+            total_bytes: 0,
+            largest_asset_bytes: 0,
+            warnings_count: 0,
+            errors_count: 0
+        };
+        await new Promise((resolve, reject)=>{
+            compiler.run(async (err, stats)=>{
+                if (err) {
+                    console.error(err.stack || err);
+                    return reject(err);
+                }
+                if (!stats || 'function' != typeof stats.hasErrors) return reject(new Error('Build failed: bundler returned invalid stats output (no reliable compilation result).'));
+                if (!buildOptions?.silent && stats) console.log(buildWebpack(manifestDir, stats, browser));
+                if (stats.hasErrors()) {
+                    handleStatsErrors(stats);
+                    if (!shouldExitOnError) return reject(new Error('Build failed with errors'));
+                    process.exit(1);
+                } else {
+                    const info = stats?.toJson({
+                        all: false,
+                        assets: true,
+                        warnings: true,
+                        errors: true
+                    });
+                    summary = getBuildSummary(browser, info);
+                    if (summary.warnings_count > 0) {
+                        console.log(buildSuccessWithWarnings(summary.warnings_count));
+                        const warningDetails = buildWarningsDetails(info?.warnings || []);
+                        if (warningDetails) console.log(`\n${warningDetails}`);
+                    } else console.log(buildSuccess());
+                    resolve();
+                }
+            });
+        });
+        return summary;
+    } catch (error) {
+        const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+        if (isAuthor) console.error(error);
+        else console.error(buildCommandFailed(error));
+        if (!shouldExitOnError) throw error;
+        process.exit(1);
+    }
+}
+async function generateExtensionTypes(manifestDir, packageJsonDir) {
+    const extensionEnvFile = __rspack_external_path.join(packageJsonDir, 'extension-env.d.ts');
+    const typePath = 'extension';
+    const fileContent = `\
+// Required Extension.js types for TypeScript projects.
+// This file is auto-generated and should not be excluded.
+// If you need additional types, consider creating a new *.d.ts file and
+// referencing it in the "include" array of your tsconfig.json file.
+// See https://www.typescriptlang.org/tsconfig#include for more information.
+/// <reference types="${typePath}/types" />
+
+// Polyfill types for browser.* APIs
+/// <reference types="${typePath}/types/polyfill" />
+`;
+    try {
+        await __rspack_external_fs_promises_400951f8.access(extensionEnvFile);
+        const existingContent = await __rspack_external_fs_promises_400951f8.readFile(extensionEnvFile, 'utf8');
+        if (existingContent.includes('develop/dist/types')) await __rspack_external_fs_promises_400951f8.writeFile(extensionEnvFile, fileContent);
+        await __rspack_external_fs_promises_400951f8.writeFile(extensionEnvFile, fileContent);
+    } catch (err) {
+        const manifestText = await __rspack_external_fs_promises_400951f8.readFile(__rspack_external_path.join(manifestDir, 'manifest.json'), 'utf8');
+        const manifest = parseJsonSafe(manifestText);
+        console.log(writingTypeDefinitions(manifest));
+        try {
+            await __rspack_external_fs_promises_400951f8.writeFile(extensionEnvFile, fileContent);
+        } catch (writeErr) {
+            console.log(writingTypeDefinitionsError(writeErr));
+        }
+    }
+}
+class BuildEmitter extends EventEmitter {
+    constructor(){
+        super();
+        this.on('error', ()=>{});
+    }
+}
+class BrowsersPlugin {
+    options;
+    static name = 'plugin-browsers';
+    emitter = new BuildEmitter();
+    extensionsToLoad = [];
+    isFirstCompile = true;
+    controller;
+    constructor(options){
+        this.options = options;
+    }
+    apply(compiler) {
+        let pendingReloadReason;
+        let pendingChangedSources = [];
+        compiler.hooks.watchRun.tap(BrowsersPlugin.name, ()=>{
+            pendingReloadReason = void 0;
+            pendingChangedSources = [];
+            const modifiedFiles = compiler.modifiedFiles;
+            if (!modifiedFiles || 0 === modifiedFiles.size) return;
+            const contextDir = compiler.options.context || '';
+            for (const file of modifiedFiles){
+                const normalized = __rspack_external_path.relative(contextDir, file).replace(/\\/g, '/');
+                pendingChangedSources.push(normalized);
+                if (normalized.includes('manifest.json')) pendingReloadReason = 'full';
+                else if (normalized.includes('_locales/')) pendingReloadReason = 'full';
+            }
+        });
+        compiler.hooks.done.tapPromise(BrowsersPlugin.name, async (stats)=>{
+            const compilation = stats.compilation;
+            const hasErrors = compilation.errors && compilation.errors.length > 0;
+            if (hasErrors) return void this.emitter.emit('error', {
+                errors: compilation.errors.map((e)=>'string' == typeof e ? e : e.message || String(e))
+            });
+            const outputPath = String(compilation.options?.output?.path || '');
+            const contextDir = String(compilation.options?.context || '');
+            let reloadInstruction;
+            if (!this.isFirstCompile && pendingReloadReason) reloadInstruction = {
+                type: pendingReloadReason,
+                changedAssets: pendingChangedSources
+            };
+            else if (!this.isFirstCompile && pendingChangedSources.length > 0) {
+                const isServiceWorkerSource = (rel)=>/(^|\/)background(\.|\/)/i.test(rel) || /service[-_.]?worker/i.test(rel);
+                const hasServiceWorkerChange = pendingChangedSources.some(isServiceWorkerSource);
+                if (hasServiceWorkerChange) reloadInstruction = {
+                    type: 'service-worker',
+                    changedAssets: pendingChangedSources
+                };
+                else {
+                    const contentScriptCount = readContentScriptCount(compilation, outputPath);
+                    if (contentScriptCount > 0) {
+                        const entries = [];
+                        for(let i = 0; i < contentScriptCount; i++)entries.push(getCanonicalContentScriptEntryName(i));
+                        reloadInstruction = {
+                            type: "content-scripts",
+                            changedContentScriptEntries: entries,
+                            changedAssets: pendingChangedSources
+                        };
+                    } else reloadInstruction = void 0;
+                }
+            }
+            const wasFirstCompile = this.isFirstCompile;
+            this.isFirstCompile = false;
+            if (wasFirstCompile) try {
+                this.controller = await this.options.launcher({
+                    ...this.options.browserOptions,
+                    outputPath,
+                    contextDir,
+                    extensionsToLoad: this.extensionsToLoad
+                });
+                const logLevel = this.options.browserOptions.logLevel || 'off';
+                if ('off' !== logLevel && this.controller) await this.controller.enableUnifiedLogging({
+                    level: logLevel,
+                    contexts: this.options.browserOptions.logContexts,
+                    format: this.options.browserOptions.logFormat,
+                    timestamps: this.options.browserOptions.logTimestamps,
+                    color: this.options.browserOptions.logColor,
+                    urlFilter: this.options.browserOptions.logUrl,
+                    tabFilter: this.options.browserOptions.logTab
+                });
+            } catch (error) {
+                this.emitter.emit('error', {
+                    errors: [
+                        error instanceof Error ? error.message : String(error)
+                    ]
+                });
+            }
+            else if (this.controller && reloadInstruction) {
+                if ('true' !== process.env.EXTENSION_NO_RELOAD) try {
+                    await this.controller.reload(reloadInstruction);
+                } catch  {}
+            }
+            this.emitter.emit('compiled', {
+                outputPath,
+                contextDir,
+                isFirstCompile: wasFirstCompile,
+                reloadInstruction,
+                extensionsToLoad: wasFirstCompile ? this.extensionsToLoad : void 0
+            });
+        });
+    }
+}
+function readContentScriptCount(compilation, outputPath) {
+    try {
+        const asset = compilation.getAsset?.('manifest.json');
+        if (asset?.source) {
+            const manifest = JSON.parse(String(asset.source.source()));
+            const list = manifest?.content_scripts;
+            if (Array.isArray(list)) return list.length;
+        }
+    } catch  {}
+    try {
+        const manifestPath = __rspack_external_path.join(outputPath, 'manifest.json');
+        if (__rspack_external_fs.existsSync(manifestPath)) {
+            const manifest = JSON.parse(__rspack_external_fs.readFileSync(manifestPath, 'utf8'));
+            const list = manifest?.content_scripts;
+            if (Array.isArray(list)) return list.length;
+        }
+    } catch  {}
+    return 0;
+}
+function isUsingIntegration(name) {
+    return `${pintor.gray('⏵⏵⏵')} Using ${pintor.brightBlue(name)}...`;
+}
+function creatingTSConfig() {
+    return `${pintor.gray('⏵⏵⏵')} Creating default tsconfig.json...`;
+}
+function isUsingCustomLoader(loaderPath) {
+    return `${pintor.gray('⏵⏵⏵')} Using custom loader: ${pintor.yellow(loaderPath)}.`;
+}
+function jsFrameworksIntegrationsEnabled(integrations) {
+    const list = integrations.length > 0 ? integrations.map((n)=>pintor.yellow(n)).join(', ') : pintor.gray('none');
+    return `${pintor.gray('⏵⏵⏵')} JS: Integrations enabled (${pintor.gray(String(integrations.length))}) ${list}`;
+}
+function jsFrameworksConfigsDetected(tsConfigPath, tsRoot, targets) {
+    const fmt = (v)=>v ? pintor.underline(v) : pintor.gray('none');
+    const tgt = targets && targets.length ? targets.map((t)=>pintor.gray(t)).join(', ') : pintor.gray('default');
+    return `${pintor.gray('⏵⏵⏵')} JS: Configs\n${pintor.gray('TSCONFIG')} ${fmt(tsConfigPath)}\n${pintor.gray('TSROOT')} ${fmt(tsRoot)}\n${pintor.gray('SWC_TARGETS')} ${tgt}`;
+}
+function jsFrameworksHmrSummary(enabled, frameworks) {
+    const list = frameworks.length > 0 ? frameworks.map((n)=>pintor.yellow(n)).join(', ') : pintor.gray('none');
+    return `${pintor.gray('⏵⏵⏵')} JS: HMR ${enabled ? pintor.green('enabled') : pintor.gray('disabled')} for ${list}`;
+}
+function hasDependency(projectPath, packageName) {
+    const manifestPath = __rspack_external_path.join(projectPath, 'package.json');
+    if (!__rspack_external_fs.existsSync(manifestPath)) return false;
+    try {
+        const raw = __rspack_external_fs.readFileSync(manifestPath, 'utf8');
+        const pkg = JSON.parse(raw || '{}');
+        const sections = [
+            pkg.dependencies,
+            pkg.devDependencies,
+            pkg.optionalDependencies,
+            pkg.peerDependencies
+        ];
+        return sections.some((s)=>s && 'object' == typeof s && packageName in s);
+    } catch  {
+        return false;
+    }
+}
+function isUsingJSFramework(projectPath) {
+    const frameworks = [
+        'react',
+        'vue',
+        '@angular/core',
+        'svelte',
+        'solid-js',
+        'preact'
+    ];
+    return frameworks.some((fw)=>hasDependency(projectPath, fw));
+}
+function installRootRules(packageIds) {
+    return packageIds.map((packageId)=>({
+            type: 'install-root',
+            packageId
+        }));
+}
+function defineContract(contract) {
+    return contract;
+}
+const OPTIONAL_DEPENDENCY_CONTRACTS = {
+    typescript: defineContract({
+        id: "typescript",
+        integration: 'TypeScript',
+        installPackages: [
+            "typescript@5.9.3"
+        ],
+        verificationRules: installRootRules([
+            "typescript"
+        ])
+    }),
+    'react-refresh': defineContract({
+        id: 'react-refresh',
+        integration: 'React',
+        installPackages: [
+            'react-refresh@0.18.0',
+            '@rspack/plugin-react-refresh@1.6.0'
+        ],
+        verificationRules: [
+            ...installRootRules([
+                'react-refresh',
+                '@rspack/plugin-react-refresh'
+            ]),
+            {
+                type: 'module-context-resolve',
+                fromPackage: '@rspack/plugin-react-refresh',
+                packageId: 'react-refresh'
+            }
+        ]
+    }),
+    'preact-refresh': defineContract({
+        id: 'preact-refresh',
+        integration: 'Preact',
+        installPackages: [
+            '@prefresh/core@1.5.9',
+            '@prefresh/utils@1.2.1',
+            '@rspack/plugin-preact-refresh@1.1.5',
+            'preact@10.27.2'
+        ],
+        verificationRules: [
+            ...installRootRules([
+                '@prefresh/core',
+                '@prefresh/utils',
+                '@rspack/plugin-preact-refresh',
+                'preact'
+            ]),
+            {
+                type: 'module-context-resolve',
+                fromPackage: '@rspack/plugin-preact-refresh',
+                packageId: '@prefresh/core'
+            },
+            {
+                type: 'module-context-resolve',
+                fromPackage: '@rspack/plugin-preact-refresh',
+                packageId: '@prefresh/utils'
+            },
+            {
+                type: 'module-context-resolve',
+                fromPackage: '@rspack/plugin-preact-refresh',
+                packageId: 'preact'
+            }
+        ]
+    }),
+    vue: defineContract({
+        id: 'vue',
+        integration: 'Vue',
+        installPackages: [
+            'vue-loader@17.4.2',
+            '@vue/compiler-sfc@3.5.26',
+            'vue@3.5.26'
+        ],
+        verificationRules: [
+            ...installRootRules([
+                'vue-loader',
+                '@vue/compiler-sfc',
+                'vue'
+            ]),
+            {
+                type: 'module-context-load',
+                fromPackage: 'vue-loader',
+                packageId: '@vue/compiler-sfc'
+            }
+        ]
+    }),
+    svelte: defineContract({
+        id: 'svelte',
+        integration: 'Svelte',
+        installPackages: [
+            "typescript@5.9.3",
+            'svelte-loader@3.2.4'
+        ],
+        verificationRules: installRootRules([
+            "typescript",
+            'svelte-loader'
+        ])
+    }),
+    less: defineContract({
+        id: 'less',
+        integration: 'LESS',
+        installPackages: [
+            'less@4.5.1',
+            'less-loader@12.3.0'
+        ],
+        verificationRules: installRootRules([
+            'less',
+            'less-loader'
+        ])
+    }),
+    postcss: defineContract({
+        id: 'postcss',
+        integration: 'PostCSS',
+        installPackages: [
+            'postcss@8.5.6',
+            'postcss-loader@8.2.0'
+        ],
+        verificationRules: installRootRules([
+            'postcss',
+            'postcss-loader'
+        ])
+    }),
+    sass: defineContract({
+        id: 'sass',
+        integration: 'SASS',
+        installPackages: [
+            'postcss-loader@8.2.0',
+            'postcss-scss@4.0.9',
+            'postcss-preset-env@11.1.1',
+            'sass-loader@16.0.6'
+        ],
+        verificationRules: installRootRules([
+            'postcss-loader',
+            'postcss-scss',
+            'postcss-preset-env',
+            'sass-loader'
+        ])
+    })
+};
+function getOptionalDependencyContract(contractId) {
+    const contract = OPTIONAL_DEPENDENCY_CONTRACTS[contractId];
+    if (!contract) throw new Error(`Unknown optional dependency contract: ${contractId}`);
+    return contract;
+}
+function toInstallRootContract(integration, contractId, installDependencies, verifyPackageIds) {
+    return {
+        id: contractId,
+        integration,
+        installPackages: installDependencies,
+        verificationRules: verifyPackageIds.map((packageId)=>({
+                type: 'install-root',
+                packageId
+            }))
+    };
+}
+function getVerificationContract(input) {
+    if (input.contract) return input.contract;
+    const installDependencies = input.installDependencies || [
+        input.dependencyId
+    ];
+    const verifyPackageIds = input.verifyPackageIds || installDependencies;
+    return toInstallRootContract(input.integration, input.integration, installDependencies, verifyPackageIds);
+}
+function getResolutionBases(projectPath) {
+    const extensionRoot = resolveDevelopInstallRoot();
+    const bases = [
+        projectPath,
+        extensionRoot || void 0,
+        process.cwd()
+    ].filter(Boolean);
+    if (extensionRoot && extensionRoot.includes('.pnpm')) bases.push(__rspack_external_path.join(extensionRoot, '..', '..'));
+    return Array.from(new Set(bases));
+}
+function optional_deps_resolver_packageJsonPath(basePath) {
+    return __rspack_external_path.join(basePath, 'package.json');
+}
+function tryResolveWithBase(dependencyId, basePath) {
+    try {
+        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
+        return req.resolve(dependencyId);
+    } catch  {
+        return;
+    }
+}
+function resolveDependency(dependencyId, projectPath) {
+    const bases = getResolutionBases(projectPath);
+    for (const basePath of bases){
+        const resolvedPath = tryResolveWithBase(dependencyId, basePath);
+        if (resolvedPath) return {
+            resolvedPath,
+            basePath
+        };
+    }
+    try {
+        const resolvedPath = require.resolve(dependencyId, {
+            paths: bases
+        });
+        return {
+            resolvedPath,
+            basePath: projectPath
+        };
+    } catch  {
+        return;
+    }
+}
+function resolveFromKnownLocations(dependencyId, projectPath) {
+    const direct = resolveDependency(dependencyId, projectPath)?.resolvedPath;
+    if (direct) return direct;
+    if (declaresDependency(projectPath, dependencyId)) return projectPath;
+}
+function declaresDependency(projectPath, dependencyId) {
+    try {
+        const packageJsonPath = __rspack_external_path.join(projectPath, 'package.json');
+        if (!__rspack_external_fs.existsSync(packageJsonPath)) return false;
+        const pkg = JSON.parse(__rspack_external_fs.readFileSync(packageJsonPath, 'utf8'));
+        const sections = [
+            pkg.dependencies,
+            pkg.devDependencies,
+            pkg.optionalDependencies,
+            pkg.peerDependencies
+        ];
+        return sections.some((section)=>section && 'object' == typeof section && dependencyId in section);
+    } catch  {
+        return false;
+    }
+}
+function dedupeFailures(packageIds) {
+    return Array.from(new Set(packageIds));
+}
+function resolveRealPathSafe(targetPath) {
+    try {
+        return __rspack_external_fs.realpathSync(targetPath);
+    } catch  {
+        return __rspack_external_path.resolve(targetPath);
+    }
+}
+function findOwningPackageDir(resolvedPath) {
+    let currentPath = __rspack_external_path.dirname(resolvedPath);
+    for(let depth = 0; depth < 8; depth++){
+        const packageJson = __rspack_external_path.join(currentPath, 'package.json');
+        if (__rspack_external_fs.existsSync(packageJson)) return currentPath;
+        const parent = __rspack_external_path.dirname(currentPath);
+        if (parent === currentPath) break;
+        currentPath = parent;
+    }
+}
+function isSameInstalledPackage(resolvedPath, expectedInstalledPath) {
+    const resolvedPackageDir = findOwningPackageDir(resolvedPath);
+    const expectedPackageDir = findOwningPackageDir(expectedInstalledPath);
+    if (resolvedPackageDir && expectedPackageDir) return resolveRealPathSafe(resolvedPackageDir) === resolveRealPathSafe(expectedPackageDir);
+    return resolveRealPathSafe(resolvedPath) === resolveRealPathSafe(expectedInstalledPath);
+}
+function evaluateModuleContextRule(rule, fromPackagePath, options) {
+    try {
+        const req = createRequire(fromPackagePath);
+        const resolvedPeer = req.resolve(rule.packageId);
+        if (options?.expectedInstalledPath && !isSameInstalledPackage(resolvedPeer, options.expectedInstalledPath)) return rule.packageId;
+        if ('module-context-load' === rule.type) req(rule.packageId);
+        return;
+    } catch  {
+        return rule.packageId;
+    }
+}
+function getContractVerificationFailuresFromKnownLocations(contract, projectPath) {
+    const resolvedByPackage = new Map();
+    const resolvePackage = (packageId)=>{
+        if (!resolvedByPackage.has(packageId)) resolvedByPackage.set(packageId, resolveFromKnownLocations(packageId, projectPath));
+        return resolvedByPackage.get(packageId);
+    };
+    const failures = [];
+    for (const rule of contract.verificationRules){
+        if ('install-root' === rule.type) {
+            if (!resolvePackage(rule.packageId)) failures.push(rule.packageId);
+            continue;
+        }
+        const fromPackagePath = resolvePackage(rule.fromPackage);
+        if (!fromPackagePath) {
+            failures.push(rule.fromPackage);
+            continue;
+        }
+        const failure = evaluateModuleContextRule(rule, fromPackagePath);
+        if (!(failure && declaresDependency(projectPath, failure))) {
+            if (failure) failures.push(failure);
+        }
+    }
+    return dedupeFailures(failures);
+}
+function buildDiagnostics(input) {
+    const bases = getResolutionBases(input.projectPath);
+    return {
+        contractId: input.contract?.id || null,
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        projectPath: input.projectPath,
+        installDependencies: input.installDependencies,
+        verifyPackageIds: input.verifyPackageIds,
+        resolutionBases: bases
+    };
+}
+function resolveOptionalDependencySync(dependencyId, projectPath) {
+    const resolved = resolveFromKnownLocations(dependencyId, projectPath);
+    if (resolved) return resolved;
+    const bases = getResolutionBases(projectPath);
+    throw new Error(`[CSS] ${dependencyId} could not be resolved. Searched: ${bases.join(', ')}`);
+}
+async function ensureOptionalPackageResolved(input) {
+    const contract = getVerificationContract(input);
+    const missing = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath);
+    const resolved = resolveFromKnownLocations(input.dependencyId, input.projectPath);
+    if (resolved && 0 === missing.length) return resolved;
+    const diagnostics = buildDiagnostics({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        projectPath: input.projectPath,
+        contract,
+        installDependencies: contract.installPackages,
+        verifyPackageIds: contract.installPackages
+    });
+    throw new Error(`[${input.integration}] ${input.dependencyId} could not be resolved.` + (missing.length > 0 ? ` Missing or invalid packages: ${missing.join(', ')}.` : '') + '\n' + JSON.stringify({
+        ...diagnostics,
+        missing
+    }, null, 2));
+}
+function resolveOptionalPackageWithoutInstall(input) {
+    const contract = getVerificationContract(input);
+    const resolved = resolveFromKnownLocations(input.dependencyId, input.projectPath);
+    const missingPeerDeps = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath);
+    if (resolved && 0 === missingPeerDeps.length) return resolved;
+    const diagnostics = buildDiagnostics({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        projectPath: input.projectPath,
+        contract,
+        installDependencies: contract.installPackages,
+        verifyPackageIds: contract.installPackages
+    });
+    throw new Error(`[${input.integration}] ${input.dependencyId} could not be resolved from the project or extension-develop.\n` + JSON.stringify({
+        ...diagnostics,
+        missingPeerDeps,
+        expectation: 'Run optional dependency preflight or reinstall extension-develop.'
+    }, null, 2));
+}
+async function ensureOptionalModuleLoaded(input) {
+    const resolvedPath = await ensureOptionalPackageResolved(input);
+    const candidateBases = getResolutionBases(input.projectPath);
+    let loaded;
+    let didLoad = false;
+    let lastLoadError;
+    for (const basePath of candidateBases){
+        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
+        const candidateModuleIds = [
+            input.dependencyId,
+            resolvedPath
+        ];
+        for (const candidateModuleId of candidateModuleIds)try {
+            loaded = req(candidateModuleId);
+            didLoad = true;
+            break;
+        } catch (error) {
+            lastLoadError = error;
+        }
+        if (didLoad) break;
+    }
+    if (!didLoad) try {
+        loaded = require(resolvedPath);
+        didLoad = true;
+    } catch (directRequireError) {
+        lastLoadError = directRequireError;
+    }
+    if (!didLoad) {
+        const diagnostics = {
+            ...buildDiagnostics({
+                integration: input.integration,
+                dependencyId: input.dependencyId,
+                projectPath: input.projectPath,
+                installDependencies: input.installDependencies || [
+                    input.dependencyId
+                ],
+                verifyPackageIds: input.verifyPackageIds || input.installDependencies || [
+                    input.dependencyId
+                ]
+            }),
+            resolvedPath,
+            loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
+        };
+        throw new Error(`[${input.integration}] ${input.dependencyId} could not be loaded after it resolved.\n` + JSON.stringify(diagnostics, null, 2));
+    }
+    return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
+}
+function loadOptionalModuleWithoutInstall(input) {
+    const resolvedPath = resolveOptionalPackageWithoutInstall(input);
+    const candidateBases = getResolutionBases(input.projectPath);
+    let loaded;
+    let didLoad = false;
+    let lastLoadError;
+    for (const basePath of candidateBases){
+        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
+        const candidateModuleIds = [
+            input.dependencyId,
+            resolvedPath
+        ];
+        for (const candidateModuleId of candidateModuleIds)try {
+            loaded = req(candidateModuleId);
+            didLoad = true;
+            break;
+        } catch (error) {
+            lastLoadError = error;
+        }
+        if (didLoad) break;
+    }
+    if (!didLoad) try {
+        loaded = require(resolvedPath);
+        didLoad = true;
+    } catch (directRequireError) {
+        lastLoadError = directRequireError;
+    }
+    if (!didLoad) throw new Error(`[${input.integration}] ${input.dependencyId} could not be loaded after resolving.\n` + JSON.stringify({
+        resolvedPath,
+        loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
+    }, null, 2));
+    return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
+}
+async function optional_deps_resolver_ensureOptionalContractPackageResolved(input) {
+    const contract = getOptionalDependencyContract(input.contractId);
+    return ensureOptionalPackageResolved({
+        integration: contract.integration,
+        projectPath: input.projectPath,
+        dependencyId: input.dependencyId,
+        contract
+    });
+}
+async function ensureOptionalContractModuleLoaded(input) {
+    const contract = getOptionalDependencyContract(input.contractId);
+    return ensureOptionalModuleLoaded({
+        integration: contract.integration,
+        projectPath: input.projectPath,
+        dependencyId: input.dependencyId,
+        contract,
+        moduleAdapter: input.moduleAdapter
+    });
+}
+function resolveOptionalContractPackageWithoutInstall(input) {
+    const contract = getOptionalDependencyContract(input.contractId);
+    return resolveOptionalPackageWithoutInstall({
+        integration: contract.integration,
+        projectPath: input.projectPath,
+        dependencyId: input.dependencyId,
+        contract
+    });
+}
+function loadOptionalContractModuleWithoutInstall(input) {
+    const contract = getOptionalDependencyContract(input.contractId);
+    return loadOptionalModuleWithoutInstall({
+        integration: contract.integration,
+        projectPath: input.projectPath,
+        dependencyId: input.dependencyId,
+        contract,
+        moduleAdapter: input.moduleAdapter
+    });
+}
+let hasShownUserMessage = false;
+function findNearestPackageJsonDirectory(startPath) {
+    let currentDirectory = startPath;
+    const maxDepth = 6;
+    for(let i = 0; i < maxDepth; i++){
+        const candidate = __rspack_external_path.join(currentDirectory, 'package.json');
+        if (__rspack_external_fs.existsSync(candidate)) return currentDirectory;
+        const parentDirectory = __rspack_external_path.dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) break;
+        currentDirectory = parentDirectory;
+    }
+}
+function hasTypeScriptSourceFiles(projectPath) {
+    try {
+        const entries = __rspack_external_fs.readdirSync(projectPath, {
+            withFileTypes: true
+        });
+        return entries.some((entry)=>{
+            if (entry.isFile()) {
+                const name = entry.name;
+                if (!/\.(ts|tsx|mts|mtsx)$/i.test(name)) return false;
+                if (/\.(d\.ts|d\.mts|d\.mtsx)$/i.test(name)) return false;
+                if (/\.(spec|test)\.(ts|tsx|mts|mtsx)$/i.test(name)) return false;
+                return true;
+            }
+            if (entry.isDirectory()) {
+                if (![
+                    'src',
+                    'content',
+                    'sidebar',
+                    'background'
+                ].includes(entry.name)) return false;
+                const sub = __rspack_external_path.join(projectPath, entry.name);
+                return hasTypeScriptSourceFiles(sub);
+            }
+            return false;
+        });
+    } catch  {
+        return false;
+    }
+}
+function isUsingTypeScript(projectPath) {
+    const packageJsonDirectory = findNearestPackageJsonDirectory(projectPath);
+    const tsConfigFilePath = getUserTypeScriptConfigFile(projectPath);
+    const packageJson = packageJsonDirectory ? parseJsonSafe(__rspack_external_fs.readFileSync(__rspack_external_path.join(packageJsonDirectory, 'package.json'), 'utf8')) : void 0;
+    const TypeScriptAsDevDep = packageJson?.devDependencies?.typescript;
+    const TypeScriptAsDep = packageJson?.dependencies?.typescript;
+    const hasTsFiles = hasTypeScriptSourceFiles(projectPath);
+    if (!hasShownUserMessage) {
+        if (TypeScriptAsDevDep || TypeScriptAsDep || hasTsFiles) if (tsConfigFilePath) {
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`${pintor.brightMagenta('⏵⏵⏵ Author says')} ${isUsingIntegration('TypeScript')}`);
+        } else if (hasTsFiles) {
+            const errorMessage = '[Extension.js] Missing tsconfig.json next to package.json. Create one to use TypeScript.';
+            throw new Error(errorMessage);
+        } else {
+            console.log(creatingTSConfig());
+            writeTsConfig(projectPath);
+        }
+        hasShownUserMessage = true;
+    }
+    return !!tsConfigFilePath && !!(TypeScriptAsDevDep || TypeScriptAsDep || hasTsFiles);
+}
+function defaultTypeScriptConfig(projectPath, _opts) {
+    return {
+        compilerOptions: {
+            allowJs: true,
+            allowSyntheticDefaultImports: true,
+            esModuleInterop: true,
+            forceConsistentCasingInFileNames: true,
+            jsx: isUsingJSFramework(projectPath) ? 'react-jsx' : 'preserve',
+            lib: [
+                'dom',
+                'dom.iterable',
+                'esnext'
+            ],
+            moduleResolution: 'node',
+            module: 'esnext',
+            resolveJsonModule: true,
+            strict: true,
+            target: 'esnext',
+            isolatedModules: false,
+            skipLibCheck: true
+        },
+        exclude: [
+            'node_modules',
+            'dist'
+        ]
+    };
+}
+function getUserTypeScriptConfigFile(projectPath) {
+    const pkgDir = findNearestPackageJsonDirectory(projectPath);
+    if (pkgDir) {
+        const tsconfigPath = __rspack_external_path.join(pkgDir, 'tsconfig.json');
+        if (__rspack_external_fs.existsSync(tsconfigPath)) return tsconfigPath;
+    }
+}
+function writeTsConfig(projectPath) {
+    __rspack_external_fs.writeFileSync(__rspack_external_path.join(projectPath, 'tsconfig.json'), JSON.stringify(defaultTypeScriptConfig(projectPath, {
+        mode: 'development'
+    }), null, 2));
+}
+async function extensionDev(pathOrRemoteUrl, devOptions) {
+    let browsersPlugin;
+    let emitter = new BuildEmitter();
+    const projectStructure = await getProjectStructure(pathOrRemoteUrl);
+    try {
+        const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+        const debug = isAuthor;
+        const { manifestDir, packageJsonDir } = getDirs(projectStructure);
+        await ensureDevelopArtifacts();
+        if (false !== devOptions.install) await ensureUserProjectDependencies(packageJsonDir);
+        if (isUsingTypeScript(manifestDir)) await generateExtensionTypes(manifestDir, packageJsonDir);
+        if (projectStructure.packageJsonPath) assertNoManagedDependencyConflicts(projectStructure.packageJsonPath, manifestDir);
+        const browser = normalizeBrowser(devOptions.browser || 'chrome', devOptions.chromiumBinary, devOptions.geckoBinary || devOptions.firefoxBinary);
+        const geckoBinary = devOptions.geckoBinary || devOptions.firefoxBinary;
+        if (debug) {
+            console.log(debugDirs(manifestDir, packageJsonDir));
+            console.log(debugBrowser(browser, devOptions.chromiumBinary, geckoBinary));
+        }
+        const browserConfig = await loadBrowserConfig(packageJsonDir, browser);
+        const commandConfig = await loadCommandConfig(packageJsonDir, 'dev');
+        const merged = {
+            ...sanitize(browserConfig),
+            ...sanitize(commandConfig),
+            ...sanitize(devOptions)
+        };
+        if (devOptions.launcher && !devOptions.noBrowser) {
+            browsersPlugin = new BrowsersPlugin({
+                launcher: devOptions.launcher,
+                browserOptions: {
+                    browser,
+                    mode: 'development',
+                    enableDevtools: true,
+                    noOpen: merged.noOpen,
+                    profile: merged.profile,
+                    persistProfile: merged.persistProfile,
+                    preferences: merged.preferences,
+                    browserFlags: merged.browserFlags,
+                    excludeBrowserFlags: merged.excludeBrowserFlags,
+                    startingUrl: merged.startingUrl,
+                    chromiumBinary: merged.chromiumBinary,
+                    geckoBinary: merged.geckoBinary || merged.firefoxBinary,
+                    port: merged.port,
+                    source: merged.source,
+                    watchSource: merged.watchSource,
+                    sourceFormat: merged.sourceFormat,
+                    sourceSummary: merged.sourceSummary,
+                    sourceMeta: merged.sourceMeta,
+                    sourceProbe: merged.sourceProbe,
+                    sourceTree: merged.sourceTree,
+                    sourceConsole: merged.sourceConsole,
+                    sourceDom: merged.sourceDom,
+                    sourceMaxBytes: merged.sourceMaxBytes,
+                    sourceRedact: merged.sourceRedact,
+                    sourceIncludeShadow: merged.sourceIncludeShadow,
+                    sourceDiff: merged.sourceDiff,
+                    logLevel: merged.logLevel,
+                    logContexts: merged.logContexts,
+                    logFormat: merged.logFormat,
+                    logTimestamps: merged.logTimestamps,
+                    logColor: merged.logColor,
+                    logUrl: merged.logUrl,
+                    logTab: merged.logTab
+                }
+            });
+            emitter = browsersPlugin.emitter;
+        }
+        if ('true' === process.env.EXTENSION_DEV_DRY_RUN) return emitter;
+        const { devServer } = await import("./0~dev-server.mjs");
+        await devServer(projectStructure, {
+            ...devOptions,
+            mode: 'development',
+            browser,
+            geckoBinary,
+            browsersPlugin
+        });
+        return emitter;
+    } catch (error) {
+        console.error(error);
+        process.exit(1);
+    }
+}
+export { BuildEmitter, ensureOptionalContractModuleLoaded, extensionBuild, extensionDev, getUserTypeScriptConfigFile, hasDependency, isUsingCustomLoader, isUsingIntegration, isUsingTypeScript, jsFrameworksConfigsDetected, jsFrameworksHmrSummary, jsFrameworksIntegrationsEnabled, loadOptionalContractModuleWithoutInstall, optional_deps_resolver_ensureOptionalContractPackageResolved, parseJsonSafe, resolveDevelopDistFile, resolveDevelopInstallRoot, resolveOptionalContractPackageWithoutInstall, resolveOptionalDependencySync };