extension-develop 4.1.19 → 4.1.21

package/dist/840~0.mjs

@@ -3,13 +3,15 @@ import { createRequire } from "node:module";
 import { execFileSync } from "node:child_process";
 import { spawn, sync } from "cross-spawn";
 import { buildExecEnv, detectPackageManagerFromLockfile } from "prefers-yarn";
-import "pintor";
+import pintor from "pintor";
+import { DefinePlugin } from "@rspack/core";
+import { pathToFileURL } from "node:url";
 import { EventEmitter } from "node:events";
-import { browserRowValue, ENVELOPE, CODES, prefix as messaging_prefix, card, isDebug, claimCardKey, isMachineOutput } from "./852~0.mjs";
+import { humanWarn, browserRowValue, CODES, ENVELOPE, prefix as messaging_prefix, card, isDebug, claimCardKey, isMachineOutput } from "./852~0.mjs";
 import { package_namespaceObject, loadCommandConfig, DEV_COMMAND_DEFAULTS, stampReadyDistExtensionId, loadProjectConfigDefaults, mergeOptionLayers, stampReadyKnownExtensionId, assertNoManagedDependencyConflicts, loadCustomConfig, START_BUILD_DEFAULTS, loadBrowserConfig, resolveCompanionExtensionsConfig, BUILD_COMMAND_DEFAULTS, getSpecialFoldersDataForProjectRoot, withDarkMode } from "./832~0.mjs";
 import { stripBom, hasProjectDependency, parseJsonSafe, findNearestProjectManifestDirSync } from "./731~0.mjs";
 import { isGeckoBasedBrowser } from "./331~0.mjs";
-import { buildWarningsDetails, buildFailed, getDirs, zipArtifactReady, projectInstallFallbackToNpm, debugDirs, browserLaunchFailed, buildSummaryPath, addonLintMore, extensionLoadRecovered, writingTypeDefinitionsError, extensionLoadStillRefused, projectInstallScriptsDisabled, authorInstallNotice, addonLintFailed, buildAssetsTree, addonLintSummary, addonLintFinding, configBrowserOrThrow, needsInstall, projectInstallInWorkspaceRoot, buildCommandFailed, addonLintNotInstalled, writingTypeDefinitions, buildComplete, ensureSessionStateInProjectGitignore, ensureSessionArtifactsIgnoreFile, debugBrowser, normalizeBrowser, debugOutputPath, devCommandFailed, getDistPath, buildShareHint, getProjectStructure, debugSplitChunksNarrowed } from "./950~0.mjs";
+import { buildWarningsDetails, buildFailed, getDirs, zipArtifactReady, projectInstallFallbackToNpm, debugDirs, addonLintDependencyAttribution, browserLaunchFailed, buildSummaryPath, addonLintMore, extensionLoadRecovered, writingTypeDefinitionsError, extensionLoadStillRefused, projectInstallScriptsDisabled, authorInstallNotice, addonLintFailed, buildAssetsTree, addonLintSummary, addonLintFinding, configBrowserOrThrow, needsInstall, projectInstallInWorkspaceRoot, buildCommandFailed, addonLintNotInstalled, writingTypeDefinitions, buildComplete, ensureSessionStateInProjectGitignore, ensureSessionArtifactsIgnoreFile, debugBrowser, normalizeBrowser, debugOutputPath, devCommandFailed, buildShareHint, getDistPath, getProjectStructure, debugSplitChunksNarrowed } from "./950~0.mjs";
 import { publicRootsFor } from "./105~0.mjs";
 import { getCanonicalContentScriptEntryName } from "./640~0.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
@@ -775,7 +777,7 @@ function readPnpmWorkspacePackages(workspaceRoot) {
         for(let j = i + 1; j < lines.length; j++){
             const line = lines[j];
             if (!line.trim() || line.trim().startsWith('#')) continue;
-            const item = /^\s+-\s*(.+)$/.exec(line);
+            const item = /^\s*-\s*(.+)$/.exec(line);
             if (!item) break;
             const value = cleanYamlListItem(item[1]);
             if (value) patterns.push(value);
@@ -900,19 +902,21 @@ function buildSpawnInvocation(command, args) {
         args
     };
 }
-function execInstallCommand(command, args, options) {
+function spawnInstallCommand(command, args, options) {
     const invocation = buildSpawnInvocation(command, args);
     const env = buildExecEnv();
-    const stdio = options?.stdio ?? 'ignore';
+    return spawn(invocation.command, invocation.args, {
+        cwd: options?.cwd,
+        stdio: options?.stdio ?? 'ignore',
+        env: {
+            ...env || process.env,
+            ...options?.env
+        }
+    });
+}
+function execInstallCommand(command, args, options) {
     return new Promise((resolve, reject)=>{
-        const child = spawn(invocation.command, invocation.args, {
-            cwd: options?.cwd,
-            stdio,
-            env: {
-                ...env || process.env,
-                ...options?.env
-            }
-        });
+        const child = spawnInstallCommand(command, args, options);
         child.on('close', (code)=>{
             if (0 !== code) reject(new Error(`Install failed with exit code ${code}`));
             else resolve();
@@ -1340,7 +1344,14 @@ function collectAddonLintLines(output) {
         ...warnings.map((finding)=>toLine('warning', finding))
     ].filter((line)=>!DUPLICATED_BY_BUILD_WARNINGS.has(line.code));
 }
-function formatAddonLintFindings(output, distDisplay, maxPrinted = ADDON_LINT_MAX_PRINTED) {
+function attributionFor(location, chunkProvenance) {
+    if (!chunkProvenance || 0 === chunkProvenance.size) return '';
+    const file = location.split(':')[0].replace(/\\/g, '/').replace(/^\.?\//, '');
+    const provenance = chunkProvenance.get(file);
+    if (!provenance) return '';
+    return addonLintDependencyAttribution(provenance.packages, provenance.onlyDependencies);
+}
+function formatAddonLintFindings(output, distDisplay, maxPrinted = ADDON_LINT_MAX_PRINTED, chunkProvenance) {
     const all = collectAddonLintLines(output);
     if (0 === all.length) return {
         findings: 0,
@@ -1351,7 +1362,7 @@ function formatAddonLintFindings(output, distDisplay, maxPrinted = ADDON_LINT_MA
     const shown = all.slice(0, Math.max(0, maxPrinted));
     const lines = [
         addonLintSummary(errorCount, warningCount, distDisplay),
-        ...shown.map((line)=>addonLintFinding(line.level, line.code, line.message, line.location))
+        ...shown.map((line)=>addonLintFinding(line.level, line.code, line.message, line.location, attributionFor(line.location, chunkProvenance)))
     ];
     if (all.length > shown.length) lines.push(addonLintMore(all.length - shown.length, distDisplay));
     return {
@@ -1424,7 +1435,7 @@ async function runAddonLint(input) {
         }), input.timeoutMs ?? ADDON_LINT_TIMEOUT_MS);
         return {
             status: 'linted',
-            ...formatAddonLintFindings(output, input.distDisplay)
+            ...formatAddonLintFindings(output, input.distDisplay, ADDON_LINT_MAX_PRINTED, input.chunkProvenance?.())
         };
     } catch (error) {
         return {
@@ -1514,6 +1525,85 @@ function getBuildSummary(browser, info, outputPath) {
         } : {}
     };
 }
+function packageNameFromPath(candidate) {
+    const normalized = candidate.replace(/\\/g, '/');
+    const marker = '/node_modules/';
+    const at = normalized.lastIndexOf(marker);
+    if (-1 === at) return null;
+    const rest = normalized.slice(at + marker.length);
+    const segments = rest.split('/').filter(Boolean);
+    if (0 === segments.length) return null;
+    if (segments[0].startsWith('@')) return segments.length > 1 ? `${segments[0]}/${segments[1]}` : null;
+    if (segments[0].includes('@') && segments.length > 1) return packageNameFromPath(`/node_modules/${segments.slice(1).join('/')}`);
+    return segments[0];
+}
+function isAbsoluteFilePath(candidate) {
+    return /^([a-zA-Z]:[\\/]|[\\/])/.test(candidate);
+}
+function pathOfModule(moduleObj) {
+    const candidate = moduleObj;
+    if ('string' == typeof candidate?.resource && candidate.resource) return candidate.resource;
+    if ('function' == typeof candidate?.identifier) {
+        const identifier = candidate.identifier();
+        if ('string' == typeof identifier && identifier) return identifier;
+    }
+    return null;
+}
+function collectChunkDependencyProvenance(compilation) {
+    const provenance = new Map();
+    const chunkGraph = compilation?.chunkGraph;
+    const chunks = compilation?.chunks;
+    if (!chunkGraph?.getChunkModulesIterable || !chunks) return provenance;
+    for (const chunk of chunks){
+        const files = chunk?.files;
+        if (!files) continue;
+        let modules = [];
+        try {
+            modules = Array.from(chunkGraph.getChunkModulesIterable(chunk));
+        } catch  {
+            continue;
+        }
+        const packages = new Set();
+        let counted = 0;
+        let fromDependencies = 0;
+        for (const moduleObj of modules){
+            const modulePath = pathOfModule(moduleObj);
+            if (!modulePath) continue;
+            if (!isAbsoluteFilePath(modulePath)) continue;
+            counted += 1;
+            const packageName = packageNameFromPath(modulePath);
+            if (packageName) {
+                fromDependencies += 1;
+                packages.add(packageName);
+            }
+        }
+        if (0 === packages.size) continue;
+        const entry = {
+            packages: [
+                ...packages
+            ].sort(),
+            onlyDependencies: counted > 0 && fromDependencies === counted
+        };
+        for (const file of files){
+            if ('string' != typeof file || !file.endsWith('.js')) continue;
+            const existing = provenance.get(file);
+            if (!existing) {
+                provenance.set(file, entry);
+                continue;
+            }
+            provenance.set(file, {
+                packages: [
+                    ...new Set([
+                        ...existing.packages,
+                        ...entry.packages
+                    ])
+                ].sort(),
+                onlyDependencies: existing.onlyDependencies && entry.onlyDependencies
+            });
+        }
+    }
+    return provenance;
+}
 async function ensureUserProjectDependencies(packageJsonDir) {
     const member = findPnpmWorkspaceMember(packageJsonDir);
     if (!needsInstall(packageJsonDir, member?.root)) return;
@@ -1805,6 +1895,9 @@ function isUsingJSFramework(projectPath) {
 function isUsingIntegration(name) {
     return `integration use=${name}`;
 }
+function solidIsNotSupported() {
+    return `${messaging_prefix('warn')} Solid is not a supported framework, so this project compiles through the JSX runtime only.\nA signal read in a child position, like ${pintor.yellow('{count()}')}, renders once and does not update.\nOnly Solid's own compiler makes that expression reactive, and the JSX runtime cannot recover it.`;
+}
 function creatingTSConfig() {
     return `${messaging_prefix('info')} Creating a default tsconfig.json…`;
 }
@@ -1824,6 +1917,319 @@ function jsFrameworksHmrSummary(enabled, frameworks) {
     const names = frameworks.length > 0 ? frameworks.join(',') : 'none';
     return `${messaging_prefix('debug')} js       hmr=${enabled ? 'enabled' : 'disabled'} frameworks=${names}`;
 }
+let userMessageDelivered = false;
+function isUsingPreact(projectPath) {
+    if (hasDependency(projectPath, 'preact')) {
+        if (!userMessageDelivered) {
+            if (isDebug()) console.log(`${messaging_prefix('debug')} ${isUsingIntegration('Preact')}`);
+            userMessageDelivered = true;
+        }
+        return true;
+    }
+    return false;
+}
+async function maybeUsePreact(projectPath) {
+    if (!isUsingPreact(projectPath)) return;
+    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
+    const resolveFromProject = (id)=>{
+        try {
+            return requireFromProject.resolve(id);
+        } catch  {
+            return;
+        }
+    };
+    const preactPkgJson = resolveFromProject('preact/package.json');
+    const preactDir = preactPkgJson ? __rspack_external_node_path_806ed179.dirname(preactPkgJson) : void 0;
+    const preactCompat = resolveFromProject('preact/compat');
+    const preactTestUtils = resolveFromProject('preact/test-utils');
+    const preactJsxRuntime = resolveFromProject('preact/jsx-runtime');
+    const preactJsxDevRuntime = resolveFromProject('preact/jsx-dev-runtime');
+    const alias = {};
+    if (preactJsxRuntime) alias['preact/jsx-runtime'] = preactJsxRuntime;
+    if (preactJsxDevRuntime) alias['preact/jsx-dev-runtime'] = preactJsxDevRuntime;
+    if (preactDir) alias.preact = preactDir;
+    if (preactCompat) {
+        alias.react = preactCompat;
+        alias['react-dom'] = preactCompat;
+    }
+    if (preactTestUtils) alias['react-dom/test-utils'] = preactTestUtils;
+    if (preactJsxRuntime) alias['react/jsx-runtime'] = preactJsxRuntime;
+    if (preactJsxDevRuntime) alias['react/jsx-dev-runtime'] = preactJsxDevRuntime;
+    return {
+        plugins: [],
+        loaders: void 0,
+        alias
+    };
+}
+let react_userMessageDelivered = false;
+function isUsingReact(projectPath) {
+    if (hasDependency(projectPath, 'react')) {
+        if (!react_userMessageDelivered) {
+            if (isDebug()) console.log(`${messaging_prefix('debug')} ${isUsingIntegration('React')}`);
+            react_userMessageDelivered = true;
+        }
+        return true;
+    }
+    return false;
+}
+async function maybeUseReact(projectPath, options = {}) {
+    if (!isUsingReact(projectPath)) return;
+    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
+    let reactPath;
+    let reactDomPath;
+    let reactDomClientPath;
+    let jsxRuntimePath;
+    let jsxDevRuntimePath;
+    try {
+        reactPath = requireFromProject.resolve('react');
+    } catch  {}
+    try {
+        reactDomPath = requireFromProject.resolve('react-dom');
+    } catch  {}
+    try {
+        reactDomClientPath = requireFromProject.resolve('react-dom/client');
+    } catch  {}
+    try {
+        jsxRuntimePath = requireFromProject.resolve('react/jsx-runtime');
+    } catch  {}
+    try {
+        jsxDevRuntimePath = requireFromProject.resolve('react/jsx-dev-runtime');
+    } catch  {}
+    const alias = {};
+    if (reactPath) alias.react$ = reactPath;
+    if (reactDomPath) alias['react-dom$'] = reactDomPath;
+    if (reactDomClientPath) alias['react-dom/client'] = reactDomClientPath;
+    if (jsxRuntimePath) alias['react/jsx-runtime'] = jsxRuntimePath;
+    if (jsxDevRuntimePath) alias['react/jsx-dev-runtime'] = jsxDevRuntimePath;
+    if (true === options.disableRefresh) return {
+        plugins: [],
+        loaders: void 0,
+        alias
+    };
+    resolveOptionalContractPackageWithoutInstall({
+        contractId: 'react-refresh',
+        projectPath,
+        dependencyId: 'react-refresh'
+    });
+    const ReactRefreshPlugin = loadOptionalContractModuleWithoutInstall({
+        contractId: 'react-refresh',
+        projectPath,
+        dependencyId: '@rspack/plugin-react-refresh',
+        moduleAdapter: (mod)=>mod && (mod.default || mod.ReactRefreshRspackPlugin) || mod
+    });
+    const reactPlugins = [
+        new ReactRefreshPlugin({
+            overlay: false,
+            ...void 0 === options.refreshExclude ? {} : {
+                exclude: options.refreshExclude
+            }
+        })
+    ];
+    return {
+        plugins: reactPlugins,
+        loaders: void 0,
+        alias
+    };
+}
+let solid_userMessageDelivered = false;
+function isUsingSolid(projectPath) {
+    if (hasDependency(projectPath, 'solid-js')) {
+        if (!solid_userMessageDelivered) {
+            if (isDebug()) console.log(`${messaging_prefix('debug')} ${isUsingIntegration('Solid')}`);
+            humanWarn(solidIsNotSupported());
+            solid_userMessageDelivered = true;
+        }
+        return true;
+    }
+    return false;
+}
+function pickEsmCondition(entry) {
+    if ('string' == typeof entry) return entry;
+    if (!entry || 'object' != typeof entry) return;
+    const conditions = entry;
+    for (const name of [
+        'browser',
+        'import',
+        'module',
+        'default'
+    ]){
+        const picked = pickEsmCondition(conditions[name]);
+        if (picked) return picked;
+    }
+}
+function resolveSolidHyperscript(resolveFromProject) {
+    const packageJsonPath = resolveFromProject('solid-js/package.json');
+    if (packageJsonPath) try {
+        const packageJson = JSON.parse(__rspack_external_node_fs_1b05aee1.readFileSync(packageJsonPath, 'utf-8'));
+        const subpath = pickEsmCondition(packageJson?.exports?.['./h']);
+        if (subpath) {
+            const esmPath = __rspack_external_node_path_806ed179.resolve(__rspack_external_node_path_806ed179.dirname(packageJsonPath), subpath);
+            if (__rspack_external_node_fs_1b05aee1.existsSync(esmPath)) return esmPath;
+        }
+    } catch  {}
+    return resolveFromProject('solid-js/h/dist/h.js') || resolveFromProject('solid-js/h');
+}
+async function maybeUseSolid(projectPath) {
+    if (!isUsingSolid(projectPath)) return;
+    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
+    const resolveFromProject = (id)=>{
+        try {
+            return requireFromProject.resolve(id);
+        } catch  {
+            return;
+        }
+    };
+    const adapter = resolveDevelopDistFile('solid-jsx-runtime');
+    const hyperscript = resolveSolidHyperscript(resolveFromProject);
+    const alias = {
+        'solid-js/jsx-runtime$': adapter,
+        'solid-js/jsx-dev-runtime$': adapter
+    };
+    if (hyperscript) alias['solid-js/h$'] = hyperscript;
+    return {
+        plugins: [],
+        loaders: void 0,
+        alias
+    };
+}
+let load_loader_options_userMessageDelivered = false;
+function resolveLoaderConfigPath(projectPath, framework) {
+    const candidates = [
+        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.ts`),
+        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.mts`),
+        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.js`),
+        __rspack_external_node_path_806ed179.join(projectPath, `${framework}.loader.mjs`)
+    ];
+    return candidates.find((p)=>__rspack_external_node_fs_1b05aee1.existsSync(p)) || null;
+}
+async function loadLoaderOptions(projectPath, framework) {
+    const configPath = resolveLoaderConfigPath(projectPath, framework);
+    if (configPath) {
+        if (!load_loader_options_userMessageDelivered && isDebug()) {
+            const display = __rspack_external_node_path_806ed179.basename(configPath);
+            console.log(isUsingCustomLoader(display));
+            load_loader_options_userMessageDelivered = true;
+        }
+        try {
+            const module = await import(pathToFileURL(configPath).href);
+            return module.default || module;
+        } catch (err) {
+            const error = err;
+            console.error(`Error loading ${framework} loader options: ${error.message}`);
+            throw err;
+        }
+    }
+    return null;
+}
+let vue_userMessageDelivered = false;
+function isUsingVue(projectPath) {
+    const using = hasDependency(projectPath, 'vue');
+    if (using && !vue_userMessageDelivered) {
+        if (isDebug()) console.log(`${messaging_prefix('debug')} ${isUsingIntegration('Vue')}`);
+        vue_userMessageDelivered = true;
+    }
+    return using;
+}
+function resolveVueBundlerEntry(requireFromProject, id) {
+    try {
+        const manifestPath = requireFromProject.resolve(`${id}/package.json`);
+        const manifest = JSON.parse(__rspack_external_node_fs_1b05aee1.readFileSync(manifestPath, 'utf8'));
+        if ('string' == typeof manifest.module && manifest.module) {
+            const entry = __rspack_external_node_path_806ed179.join(__rspack_external_node_path_806ed179.dirname(manifestPath), manifest.module);
+            if (__rspack_external_node_fs_1b05aee1.existsSync(entry)) return entry;
+        }
+    } catch  {}
+    try {
+        return requireFromProject.resolve(id);
+    } catch  {
+        return;
+    }
+}
+async function maybeUseVue(projectPath, mode = 'development') {
+    if (!isUsingVue(projectPath)) return;
+    const vueLoaderPath = await ensureOptionalContractPackageResolved({
+        contractId: 'vue',
+        projectPath,
+        dependencyId: 'vue-loader'
+    });
+    const VueLoaderPlugin = await ensureOptionalContractModuleLoaded({
+        contractId: 'vue',
+        projectPath,
+        dependencyId: 'vue-loader',
+        moduleAdapter: (mod)=>mod?.VueLoaderPlugin || mod?.default?.VueLoaderPlugin
+    });
+    const customOptions = await loadLoaderOptions(projectPath, 'vue');
+    const defaultLoaders = [
+        {
+            test: /\.vue$/,
+            loader: vueLoaderPath,
+            options: {
+                experimentalInlineMatchResource: true,
+                ...customOptions || {}
+            },
+            include: projectPath,
+            exclude: /node_modules/
+        }
+    ];
+    const isProd = 'production' === mode;
+    const defaultPlugins = [
+        new VueLoaderPlugin(),
+        new DefinePlugin({
+            __VUE_OPTIONS_API__: JSON.stringify(true),
+            __VUE_PROD_DEVTOOLS__: JSON.stringify(!isProd),
+            __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: JSON.stringify(!isProd)
+        })
+    ];
+    const requireFromProject = createRequire(__rspack_external_node_path_806ed179.join(projectPath, 'package.json'));
+    const resolveFromProject = (id)=>resolveVueBundlerEntry(requireFromProject, id);
+    const alias = {};
+    const vuePath = resolveFromProject('vue');
+    const vueRuntimeDom = resolveFromProject('@vue/runtime-dom');
+    const vueRuntimeCore = resolveFromProject('@vue/runtime-core');
+    const vueShared = resolveFromProject('@vue/shared');
+    if (vuePath) alias.vue$ = vuePath;
+    if (vueRuntimeDom) alias['@vue/runtime-dom'] = vueRuntimeDom;
+    if (vueRuntimeCore) alias['@vue/runtime-core'] = vueRuntimeCore;
+    if (vueShared) alias['@vue/shared'] = vueShared;
+    return {
+        plugins: defaultPlugins,
+        loaders: defaultLoaders,
+        alias
+    };
+}
+function isUsingJsxFramework(projectPath) {
+    return isUsingReact(projectPath) || isUsingPreact(projectPath) || isUsingSolid(projectPath) || isUsingVue(projectPath);
+}
+function getJsxImportSource(projectPath) {
+    if (isUsingSolid(projectPath)) return 'solid-js';
+    if (isUsingPreact(projectPath) && !isUsingReact(projectPath)) return 'preact';
+    if (isUsingVue(projectPath) && !isUsingReact(projectPath) && !isUsingPreact(projectPath)) return 'vue';
+    return 'react';
+}
+function swcParserForFile(resourcePath, jsxInPlainJs) {
+    const clean = String(resourcePath || '').split('?')[0];
+    const ext = __rspack_external_node_path_806ed179.extname(clean).toLowerCase();
+    if ('.tsx' === ext || '.mtsx' === ext) return {
+        syntax: "typescript",
+        tsx: true,
+        dynamicImport: true
+    };
+    if ('.ts' === ext || '.mts' === ext || '.cts' === ext) return {
+        syntax: "typescript",
+        tsx: false,
+        dynamicImport: true
+    };
+    if ('.jsx' === ext || '.mjsx' === ext) return {
+        syntax: "ecmascript",
+        jsx: true,
+        dynamicImport: true
+    };
+    return {
+        syntax: "ecmascript",
+        jsx: jsxInPlainJs,
+        dynamicImport: true
+    };
+}
 let hasShownUserMessage = false;
 function findNearestPackageJsonDirectory(startPath) {
     return findNearestProjectManifestDirSync(startPath, 6);
@@ -1884,13 +2290,18 @@ function ensureTypeScriptConfig(projectPath) {
     }
 }
 function defaultTypeScriptConfig(projectPath, _opts) {
+    const usesJsFramework = isUsingJSFramework(projectPath);
+    const jsxImportSource = usesJsFramework ? {
+        jsxImportSource: getJsxImportSource(projectPath)
+    } : {};
     return {
         compilerOptions: {
             allowJs: true,
             allowSyntheticDefaultImports: true,
             esModuleInterop: true,
             forceConsistentCasingInFileNames: true,
-            jsx: isUsingJSFramework(projectPath) ? 'react-jsx' : 'preserve',
+            jsx: usesJsFramework ? 'react-jsx' : 'preserve',
+            ...jsxImportSource,
             lib: [
                 'dom',
                 'dom.iterable',
@@ -2122,7 +2533,8 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                             distDisplay,
                             browser,
                             mode: resolvedMode,
-                            enabled: mergedBuildOptions.addonLint
+                            enabled: mergedBuildOptions.addonLint,
+                            chunkProvenance: ()=>collectChunkDependencyProvenance(stats.compilation)
                         });
                         if ('missing' === lint.status && lint.hint) lintLines.push(lint.hint);
                         else if ('failed' === lint.status && isDebug()) lintLines.push(lint.debugLine);
@@ -2152,7 +2564,7 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                         if (warningDetails) humanLine(warningDetails);
                     }
                     for (const line of lintLines)humanLine(line);
-                    humanLine(buildComplete(browser, distDisplay, summary.total_bytes));
+                    humanLine(buildComplete(browser, distDisplay, summary.total_bytes, resolvedMode));
                     for (const artifact of getZipArtifacts(stats.compilation)){
                         const artifactPath = useStagingSwap && artifact.path.startsWith(stagingDistPath) ? distPath + artifact.path.slice(stagingDistPath.length) : artifact.path;
                         const zipDisplay = relativeToCwd(artifactPath) || artifactPath;
@@ -2212,6 +2624,9 @@ function viaBroker(broker, instruction) {
 function formatReloadingLine(label) {
     return `${messaging_prefix('info')} Reloading ${label}…`;
 }
+function formatQueuedReloadLine(label) {
+    return `${messaging_prefix('info')} Queued ${label} for the extension to apply when it reconnects.`;
+}
 async function dispatchReload(instruction, executor) {
     if (!instruction) return;
     if ('true' === process.env.EXTENSION_NO_RELOAD) return;
@@ -2221,8 +2636,11 @@ async function dispatchReload(instruction, executor) {
             if (instruction.label) console.log(formatReloadingLine(instruction.label));
             return;
         }
-        const warning = executor.broker.undeliveredReloadWarning?.();
-        if (warning) console.warn(warning);
+        const warning = executor.broker.undeliveredReloadWarning?.(executor.producerRestartExpected ? {
+            producerRestartExpected: true
+        } : void 0);
+        if (warning) return void console.warn(warning);
+        if (executor.producerRestartExpected && instruction.label) console.log(formatQueuedReloadLine(instruction.label));
     }
 }
 function isForcedFullPath(normalized) {
@@ -2674,6 +3092,43 @@ class BrowsersPlugin {
         });
     }
 }
+function union(previous, next) {
+    return [
+        ...new Set([
+            ...previous || [],
+            ...next || []
+        ])
+    ].sort();
+}
+function reloadSurvivingPackage(instruction) {
+    if (!instruction) return;
+    if ("content-scripts" === instruction.type || 'page' === instruction.type) return instruction;
+    const entries = instruction.changedContentScriptEntries || [];
+    if (0 === entries.length) return;
+    return {
+        ...instruction,
+        type: "content-scripts",
+        label: formatReloadContextLabel("content_script", instruction.changedAssets || [])
+    };
+}
+function mergeInstructions(previous, next) {
+    if (!previous) return next;
+    if (!next) return previous;
+    const entries = union(previous.changedContentScriptEntries, next.changedContentScriptEntries);
+    const scriptFiles = union(previous.changedScriptFiles, next.changedScriptFiles);
+    if (0 === entries.length) return scriptFiles.length > 0 ? {
+        ...next,
+        changedScriptFiles: scriptFiles
+    } : next;
+    const base = "content-scripts" === next.type ? next : previous;
+    return {
+        ...base,
+        changedContentScriptEntries: entries,
+        ...scriptFiles.length > 0 ? {
+            changedScriptFiles: scriptFiles
+        } : {}
+    };
+}
 class SafariDevPlugin {
     packager;
     static name = 'safari-dev';
@@ -2683,23 +3138,45 @@ class SafariDevPlugin {
     active = false;
     pending = null;
     idleWaiters = [];
+    reloadBroker;
     constructor(packager){
         this.packager = packager;
     }
+    setReloadBroker(broker) {
+        this.reloadBroker = broker;
+    }
     apply(compiler) {
+        const changedSources = compiler.hooks?.watchRun ? createChangedSourcesTracker(compiler) : void 0;
         compiler.hooks.done.tapPromise(SafariDevPlugin.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 instruction;
+            if (!this.firstRun && changedSources) {
+                const { forcedFull, changedSources: sources } = changedSources.snapshot();
+                instruction = reloadSurvivingPackage(classifyReloadFromSources({
+                    changedSources: sources,
+                    forcedFull,
+                    getContentScriptCount: ()=>readContentScriptCount(compilation, outputPath),
+                    getSourceFeatureIndex: ()=>buildSourceFeatureIndex(compilation, contextDir),
+                    outputPath
+                }));
+            }
             const target = {
-                outputPath: String(compilation.options?.output?.path || ''),
-                contextDir: String(compilation.options?.context || '')
+                outputPath,
+                contextDir,
+                instruction
             };
             if (this.firstRun) return void await this.runOne(target, 'full');
             if (this.active) {
-                this.pending = target;
+                this.pending = {
+                    ...target,
+                    instruction: mergeInstructions(this.pending?.instruction, target.instruction)
+                };
                 return;
             }
             this.active = true;
@@ -2736,6 +3213,10 @@ class SafariDevPlugin {
             return;
         }
         if (wasFirstRun) this.firstRun = false;
+        if (!wasFirstRun && target.instruction && this.reloadBroker) await dispatchReload(target.instruction, {
+            broker: this.reloadBroker,
+            producerRestartExpected: true
+        });
         this.emitter.emit('compiled', {
             outputPath: target.outputPath,
             contextDir: target.contextDir,
@@ -2838,4 +3319,4 @@ async function extensionDev(pathOrRemoteUrl, devOptions) {
         process.exit(1);
     }
 }
-export { BuildEmitter, applySplitChunksGuard, attachLifecycleStream, buildSourceFeatureIndex, classifyEntrySurface, classifyReloadFromSources, createChangedSourcesTracker, createLifecycleStream, defaultSplitChunks, dispatchReload, ensureOptionalContractModuleLoaded, ensureOptionalContractPackageResolved, ensureTypeScriptConfig, extensionBuild, extensionDev, getUserTypeScriptConfigFile, hasDependency, humanLine, isUsingCustomLoader, isUsingIntegration, isUsingTypeScript, jsFrameworksConfigsDetected, jsFrameworksHmrSummary, jsFrameworksIntegrationsEnabled, loadOptionalContractModuleWithoutInstall, readContentScriptCount, recordZipArtifact, resolveDevelopDistFile, resolveDevelopInstallRoot, resolveOptionalContractPackageWithoutInstall };
+export { BuildEmitter, applySplitChunksGuard, attachLifecycleStream, buildSourceFeatureIndex, classifyEntrySurface, classifyReloadFromSources, createChangedSourcesTracker, createLifecycleStream, defaultSplitChunks, dispatchReload, ensureOptionalContractPackageResolved, ensureTypeScriptConfig, extensionBuild, extensionDev, getJsxImportSource, getUserTypeScriptConfigFile, hasDependency, humanLine, isUsingIntegration, isUsingJsxFramework, isUsingReact, isUsingTypeScript, isUsingVue, jsFrameworksConfigsDetected, jsFrameworksHmrSummary, jsFrameworksIntegrationsEnabled, loadLoaderOptions, maybeUsePreact, maybeUseReact, maybeUseSolid, maybeUseVue, readContentScriptCount, recordZipArtifact, resolveDevelopDistFile, resolveDevelopInstallRoot, swcParserForFile };