extension-develop 4.1.20 → 4.1.22

package/dist/840~0.mjs

@@ -3,20 +3,21 @@ 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, collapseHomeDir, addonLintMore, extensionLoadRecovered, writingTypeDefinitionsError, extensionLoadStillRefused, relativeToDir, projectInstallScriptsDisabled, authorInstallNotice, addonLintFailed, buildAssetsTree, addonLintSummary, addonLintFinding, configBrowserOrThrow, buildSummaryPath, needsInstall, projectInstallInWorkspaceRoot, buildCommandFailed, addonLintNotInstalled, writingTypeDefinitions, buildComplete, ensureSessionStateInProjectGitignore, displayPath, 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";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 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_fs_promises_3b710708 from "node:fs/promises";
 const MAX_OUTPUT_CHARS = 2000;
@@ -775,7 +776,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 +901,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 +1343,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 +1361,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 +1434,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 +1524,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 +1894,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 +1916,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 +2289,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',
@@ -1927,19 +2337,6 @@ function writeTsConfig(projectPath) {
         mode: 'development'
     }), null, 2));
 }
-function collapseHomeDir(value) {
-    const home = __rspack_external_node_os_4f3c9d58.homedir();
-    if (!home || !value.startsWith(home)) return value;
-    const rest = value.slice(home.length);
-    if ('' === rest) return '~';
-    if (rest.startsWith(__rspack_external_node_path_806ed179.sep) || rest.startsWith('/')) return `~${rest}`;
-    return value;
-}
-function relativeToCwd(target) {
-    const relative = __rspack_external_node_path_806ed179.relative(process.cwd(), target);
-    if (relative && !relative.startsWith('..') && !__rspack_external_node_path_806ed179.isAbsolute(relative)) return relative;
-    return null;
-}
 const reportedBuildFailures = new WeakSet();
 function printBuildCard(manifestPath, browser, distPath) {
     if (!claimCardKey(`${browser}::${__rspack_external_node_path_806ed179.resolve(distPath)}`)) return;
@@ -2113,7 +2510,7 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                         errors: true
                     });
                     summary = getBuildSummary(browser, info, displayDistPath);
-                    const distDisplay = relativeToCwd(displayDistPath) || collapseHomeDir(displayDistPath);
+                    const distDisplay = displayPath(displayDistPath);
                     const lintLines = [];
                     try {
                         const lint = await runAddonLint({
@@ -2122,7 +2519,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);
@@ -2155,7 +2553,7 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                     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;
+                        const zipDisplay = relativeToDir(artifactPath, process.cwd()) || artifactPath;
                         humanLine(zipArtifactReady(zipDisplay, artifact.size));
                     }
                     const shareHint = buildShareHint();
@@ -2907,4 +3305,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 };

package/dist/852~0.mjs

@@ -22,6 +22,10 @@ function prefix(type) {
     if ('debug' === type) return pintor.dim(pintor.gray(DEBUG_GLYPH));
     return pintor.gray(GLYPH);
 }
+const ANSI_PATTERN = /\[[0-9;]*m/g;
+function hasChannelPrefix(text) {
+    return String(text || '').replace(ANSI_PATTERN, '').trimStart().startsWith(GLYPH);
+}
 const MACHINE_OUTPUT_VALUES = new Set([
     'json',
     'ndjson'
@@ -272,4 +276,4 @@ const ENVELOPE = {
         }, extras);
     }
 };
-export { CODES, ENVELOPE, artifactNoun, browserRowValue, card, claimCardKey, fmt, humanLine, humanWarn, isDebug, isMachineOutput, prefix };
+export { CODES, ENVELOPE, artifactNoun, browserRowValue, card, claimCardKey, fmt, hasChannelPrefix, humanLine, humanWarn, isDebug, isMachineOutput, prefix };