extension-develop 4.1.20 → 4.1.21

package/dist/672~0.mjs

@@ -104,6 +104,16 @@ function findDroppedVendorKeys(manifest, browser) {
     walk(manifest, '');
     return found;
 }
+function isValidManifestVersion(value) {
+    return 2 === value || 3 === value;
+}
+function findPrefixedManifestVersionKeys(manifest) {
+    if (!manifest || 'object' != typeof manifest) return [];
+    return Object.keys(manifest).filter((key)=>{
+        const colon = key.indexOf(':');
+        return colon > 0 && 'manifest_version' === key.substring(colon + 1);
+    });
+}
 const THEME_DISQUALIFYING_KEYS = [
     'background',
     "content_scripts",
@@ -198,6 +208,19 @@ function entrySplitAcrossInitialFiles(entryName, surface, ownFile, extraFiles) {
     lines.push(`Only a user-set optimization.splitChunks cache group does this. Use chunks: 'async' and import() the shared module: ${pintor.blue(SPLIT_ENTRY_RECIPE_URL)}`);
     return lines.join('\n');
 }
+const PAGE_CONTEXT_SURFACES = {
+    content_script: "a content script",
+    script: "an injected script"
+};
+function workerStartedFromPageContext(assetName, surface) {
+    const lines = [];
+    lines.push(`${assetName} starts a worker from an extension URL, which the browser refuses in ${PAGE_CONTEXT_SURFACES[surface]}.`);
+    lines.push(`${pintor.gray('SCRIPT')} ${pintor.underline(assetName)}`);
+    lines.push("The worker file ships, but a worker script must be same-origin with the document that starts it, and this document is the page, so the worker never runs. Chromium throws a SecurityError and Firefox fires an error event on the worker.");
+    lines.push(`- Fetch the worker file first and start the worker from a blob: ${pintor.blue("new Worker(URL.createObjectURL(new Blob([await (await fetch(chrome.runtime.getURL('worker.js'))).text()])))")}`);
+    lines.push("- Or start the worker from an extension page, where the document is the extension and this spelling works as written.");
+    return lines.join('\n');
+}
 function fetchedFileDependencyMissing(assetName, literal, expectedPath) {
     const lines = [];
     lines.push(`${assetName} loads '${literal}' at runtime (fetch/XMLHttpRequest/new URL), but the file isn't in the output.`);
@@ -243,4 +266,4 @@ function compiledSourceSpelling(assetName, api, literal, emittedPath) {
     lines.push(`Reference the emitted path: ${pintor.blue(emittedPath)}.`);
     return lines.join('\n');
 }
-export { compiledSourceSpelling, entrySplitAcrossInitialFiles, fetchedFileDependencyMissing, filterKeysForThisBrowser, findDroppedVendorKeys, getURLDependencyMissing, importScriptsDependencyMissing, injectedCompiledSourceLiteral, injectedFileDependencyMissing, isStaticTheme, isStaticThemeSource, reservedScriptsFolder, runtimeSetSurfaceDependencyMissing, staticImportDependencyMissing };
+export { compiledSourceSpelling, entrySplitAcrossInitialFiles, fetchedFileDependencyMissing, filterKeysForThisBrowser, findDroppedVendorKeys, findPrefixedManifestVersionKeys, getURLDependencyMissing, importScriptsDependencyMissing, injectedCompiledSourceLiteral, injectedFileDependencyMissing, isStaticTheme, isStaticThemeSource, isValidManifestVersion, reservedScriptsFolder, runtimeSetSurfaceDependencyMissing, staticImportDependencyMissing, workerStartedFromPageContext };

package/dist/747~0.mjs

@@ -69,10 +69,12 @@ function toRuntimeStylesheetModule(css) {
         `var __extjsCssText = ${JSON.stringify(css)};`,
         'function __extjsExtensionRoot() {',
         '  try {',
-        '    if (typeof browser === "object" && browser && browser.runtime && typeof browser.runtime.getURL === "function") return String(browser.runtime.getURL("/"));',
+        '    var b = globalThis.browser;',
+        '    if (typeof b === "object" && b && b.runtime && typeof b.runtime.getURL === "function") return String(b.runtime.getURL("/"));',
         '  } catch (error) {}',
         '  try {',
-        '    if (typeof chrome === "object" && chrome && chrome.runtime && typeof chrome.runtime.getURL === "function") return String(chrome.runtime.getURL("/"));',
+        '    var c = globalThis.chrome;',
+        '    if (typeof c === "object" && c && c.runtime && typeof c.runtime.getURL === "function") return String(c.runtime.getURL("/"));',
         '  } catch (error) {}',
         '  try {',
         '    var base = (typeof globalThis === "object" && globalThis && globalThis.__EXTJS_EXTENSION_BASE__) ? String(globalThis.__EXTJS_EXTENSION_BASE__) : "";',

package/dist/832~0.mjs

@@ -19,7 +19,7 @@ import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
 import * as __rspack_external_node_os_4f3c9d58 from "node:os";
 import * as __rspack_external_node_path_806ed179 from "node:path";
 import * as __rspack_external_node_vm_ef240610 from "node:vm";
-var package_namespaceObject = /*#__PURE__*/ JSON.parse('{"rE":"4.1.20","El":{"@prefresh/core":"1.5.9","@prefresh/utils":"1.2.1","@rspack/core":"^2.2.3","@rspack/dev-server":"2.1.0","@rspack/plugin-preact-refresh":"2.0.1","@rspack/plugin-react-refresh":"2.0.2","@vue/compiler-sfc":"3.5.26","acorn":"^8.16.0","browser-extension-manifest-fields":"^3.0.1","case-sensitive-paths-webpack-plugin":"^2.4.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","es-module-lexer":"^3.0.2","extension-from-store":"^0.2.5","fflate":"^0.8.3","go-git-it":"^5.1.5","ignore":"^7.0.5","less":"4.6.7","less-loader":"13.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","postcss":"8.5.23","postcss-loader":"8.2.1","postcss-preset-env":"11.1.1","postcss-scss":"4.0.9","preact":"10.27.3","prefers-yarn":"2.0.1","react-refresh":"0.18.0","sass-loader":"17.0.0","schema-utils":"^4.3.3","svelte-loader":"3.2.4","tiny-glob":"^0.2.9","vue":"3.5.26","vue-loader":"17.4.2","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.20.1"}}');
+var package_namespaceObject = /*#__PURE__*/ JSON.parse('{"rE":"4.1.21","El":{"@prefresh/core":"1.5.9","@prefresh/utils":"1.2.1","@rspack/core":"^2.2.3","@rspack/dev-server":"2.1.0","@rspack/plugin-preact-refresh":"2.0.1","@rspack/plugin-react-refresh":"2.0.2","@vue/compiler-sfc":"3.5.26","acorn":"^8.16.0","browser-extension-manifest-fields":"^3.0.1","case-sensitive-paths-webpack-plugin":"^2.4.0","content-security-policy-parser":"^0.6.0","cross-spawn":"^7.0.6","dotenv":"^17.2.3","es-module-lexer":"^3.0.2","extension-from-store":"^0.2.5","fflate":"^0.8.3","go-git-it":"^5.1.5","ignore":"^7.0.5","less":"4.6.7","less-loader":"13.0.0","parse5-utilities":"^1.0.0","pintor":"0.3.0","postcss":"8.5.23","postcss-loader":"8.2.1","postcss-preset-env":"11.1.1","postcss-scss":"4.0.9","preact":"10.27.3","prefers-yarn":"2.0.1","react-refresh":"0.18.0","sass-loader":"17.0.0","schema-utils":"^4.3.3","svelte-loader":"3.2.4","tiny-glob":"^0.2.9","vue":"3.5.26","vue-loader":"17.4.2","webextension-polyfill":"^0.12.0","webpack-merge":"^6.0.1","webpack-target-webextension":"^2.1.3","ws":"^8.20.1"}}');
 const preloadedEnvKeys = new Set();
 function getPreloadedEnvKeys() {
     return preloadedEnvKeys;

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);
@@ -2907,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 };