extension-develop 4.1.17 → 4.1.18-canary.1789403792.e514b06c

package/dist/840~0.mjs

@@ -7,7 +7,8 @@ import { EventEmitter } from "node:events";
 import { browserRowValue, ENVELOPE, CODES, 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 { buildWarningsDetails, buildFailed, getDirs, zipArtifactReady, projectInstallFallbackToNpm, debugDirs, browserLaunchFailed, buildSummaryPath, extensionLoadRecovered, extensionLoadStillRefused, writingTypeDefinitionsError, buildAssetsTree, authorInstallNotice, projectInstallScriptsDisabled, configBrowserOrThrow, needsInstall, buildCommandFailed, writingTypeDefinitions, buildComplete, ensureSessionStateInProjectGitignore, ensureSessionArtifactsIgnoreFile, normalizeBrowser, debugBrowser, debugOutputPath, devCommandFailed, getProjectStructure, getDistPath, buildShareHint, debugSplitChunksNarrowed } from "./950~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, buildCommandFailed, addonLintNotInstalled, writingTypeDefinitions, buildComplete, ensureSessionStateInProjectGitignore, ensureSessionArtifactsIgnoreFile, debugBrowser, normalizeBrowser, debugOutputPath, devCommandFailed, getDistPath, buildShareHint, 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";
@@ -257,87 +258,6 @@ function attachLifecycleStream(compiler, stream) {
         } catch  {}
     });
 }
-const DIST_STAGING_PREFIX = '.extension-build-';
-function stagingDistPathFor(distPath) {
-    const unique = `${process.pid.toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    return __rspack_external_node_path_806ed179.join(__rspack_external_node_path_806ed179.dirname(distPath), `${DIST_STAGING_PREFIX}${__rspack_external_node_path_806ed179.basename(distPath)}-${unique}`);
-}
-function removeStaleStagingDirs(distPath) {
-    const parent = __rspack_external_node_path_806ed179.dirname(distPath);
-    const prefix = `${DIST_STAGING_PREFIX}${__rspack_external_node_path_806ed179.basename(distPath)}-`;
-    let entries;
-    try {
-        entries = __rspack_external_node_fs_1b05aee1.readdirSync(parent, {
-            withFileTypes: true
-        });
-    } catch  {
-        return;
-    }
-    for (const entry of entries)try {
-        if (!entry.isDirectory() || !entry.name.startsWith(prefix)) continue;
-        __rspack_external_node_fs_1b05aee1.rmSync(__rspack_external_node_path_806ed179.join(parent, entry.name), {
-            recursive: true,
-            force: true
-        });
-    } catch  {}
-}
-function removeStagingDir(stagingPath) {
-    try {
-        __rspack_external_node_fs_1b05aee1.rmSync(stagingPath, {
-            recursive: true,
-            force: true
-        });
-    } catch  {}
-}
-function promoteStagingDist(stagingPath, distPath) {
-    const parent = __rspack_external_node_path_806ed179.dirname(distPath);
-    __rspack_external_node_fs_1b05aee1.mkdirSync(parent, {
-        recursive: true
-    });
-    const retiredPath = `${stagingPath}-retired`;
-    let retired = false;
-    if (__rspack_external_node_fs_1b05aee1.existsSync(distPath)) {
-        __rspack_external_node_fs_1b05aee1.renameSync(distPath, retiredPath);
-        retired = true;
-    }
-    try {
-        __rspack_external_node_fs_1b05aee1.renameSync(stagingPath, distPath);
-    } catch (error) {
-        if (retired) try {
-            __rspack_external_node_fs_1b05aee1.renameSync(retiredPath, distPath);
-        } catch  {}
-        throw error;
-    }
-    if (retired) try {
-        __rspack_external_node_fs_1b05aee1.rmSync(retiredPath, {
-            recursive: true,
-            force: true
-        });
-    } catch  {}
-}
-const MAX_SUMMARY_WARNINGS = 20;
-const build_summary_ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
-function getBuildSummary(browser, info, outputPath) {
-    const assets = info?.assets || [];
-    const warnings = (info?.warnings || []).slice(0, MAX_SUMMARY_WARNINGS).map((warning)=>{
-        const message = warning && 'object' == typeof warning ? String(warning.message ?? '') : String(warning ?? '');
-        return message.replace(build_summary_ANSI_PATTERN, '').trim();
-    }).filter(Boolean);
-    return {
-        browser,
-        ...outputPath ? {
-            output_path: outputPath
-        } : {},
-        total_assets: assets.length,
-        total_bytes: assets.reduce((n, a)=>n + (a.size || 0), 0),
-        largest_asset_bytes: assets.reduce((m, a)=>Math.max(m, a.size || 0), 0),
-        warnings_count: (info?.warnings || []).length,
-        errors_count: (info?.errors || []).length,
-        ...warnings.length ? {
-            warnings
-        } : {}
-    };
-}
 const cjsRequire = createRequire(import.meta.url);
 if (!process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION) process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION = package_namespaceObject.rE;
 function resolveDevelopRootFromDir(dir) {
@@ -410,6 +330,155 @@ function resolveDevelopDistFile(stem) {
     if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${base} (fallback, installRoot=${installRoot || '<none>'})`);
     return base;
 }
+const BUNDLED_DEPENDENCY_VERSIONS = {
+    ...package_namespaceObject.El || {}
+};
+function optional_deps_contracts_spec(packageId) {
+    const version = BUNDLED_DEPENDENCY_VERSIONS[packageId];
+    return version ? `${packageId}@${version}` : packageId;
+}
+function specs(packageIds) {
+    return packageIds.map(optional_deps_contracts_spec);
+}
+function installRootRules(packageIds) {
+    return packageIds.map((packageId)=>({
+            type: 'install-root',
+            packageId
+        }));
+}
+function defineContract(contract) {
+    return contract;
+}
+const OPTIONAL_DEPENDENCY_CONTRACTS = {
+    'react-refresh': defineContract({
+        id: 'react-refresh',
+        integration: 'React',
+        installPackages: specs([
+            'react-refresh',
+            '@rspack/plugin-react-refresh'
+        ]),
+        verificationRules: [
+            ...installRootRules([
+                'react-refresh',
+                '@rspack/plugin-react-refresh'
+            ]),
+            {
+                type: 'module-context-resolve',
+                fromPackage: '@rspack/plugin-react-refresh',
+                packageId: 'react-refresh'
+            }
+        ]
+    }),
+    'preact-refresh': defineContract({
+        id: 'preact-refresh',
+        integration: 'Preact',
+        installPackages: specs([
+            '@prefresh/core',
+            '@prefresh/utils',
+            '@rspack/plugin-preact-refresh',
+            'preact'
+        ]),
+        verificationRules: [
+            ...installRootRules([
+                '@prefresh/core',
+                '@prefresh/utils',
+                '@rspack/plugin-preact-refresh',
+                'preact'
+            ]),
+            {
+                type: 'module-context-resolve',
+                fromPackage: '@rspack/plugin-preact-refresh',
+                packageId: '@prefresh/core'
+            },
+            {
+                type: 'module-context-resolve',
+                fromPackage: '@rspack/plugin-preact-refresh',
+                packageId: '@prefresh/utils'
+            },
+            {
+                type: 'module-context-resolve',
+                fromPackage: '@rspack/plugin-preact-refresh',
+                packageId: 'preact'
+            }
+        ]
+    }),
+    vue: defineContract({
+        id: 'vue',
+        integration: 'Vue',
+        installPackages: specs([
+            'vue-loader',
+            '@vue/compiler-sfc',
+            'vue'
+        ]),
+        verificationRules: [
+            ...installRootRules([
+                'vue-loader',
+                '@vue/compiler-sfc',
+                'vue'
+            ]),
+            {
+                type: 'module-context-load',
+                fromPackage: 'vue-loader',
+                packageId: '@vue/compiler-sfc'
+            }
+        ]
+    }),
+    svelte: defineContract({
+        id: 'svelte',
+        integration: 'Svelte',
+        installPackages: specs([
+            'svelte-loader'
+        ]),
+        verificationRules: installRootRules([
+            'svelte-loader'
+        ])
+    }),
+    less: defineContract({
+        id: 'less',
+        integration: 'LESS',
+        installPackages: specs([
+            'less',
+            'less-loader'
+        ]),
+        verificationRules: installRootRules([
+            'less',
+            'less-loader'
+        ])
+    }),
+    postcss: defineContract({
+        id: 'postcss',
+        integration: 'PostCSS',
+        installPackages: specs([
+            'postcss',
+            'postcss-loader'
+        ]),
+        verificationRules: installRootRules([
+            'postcss',
+            'postcss-loader'
+        ])
+    }),
+    sass: defineContract({
+        id: 'sass',
+        integration: 'SASS',
+        installPackages: specs([
+            'postcss-loader',
+            'postcss-scss',
+            'postcss-preset-env',
+            'sass-loader'
+        ]),
+        verificationRules: installRootRules([
+            'postcss-loader',
+            'postcss-scss',
+            'postcss-preset-env',
+            'sass-loader'
+        ])
+    })
+};
+function getOptionalDependencyContract(contractId) {
+    const contract = OPTIONAL_DEPENDENCY_CONTRACTS[contractId];
+    if (!contract) throw new Error(`Unknown optional dependency contract: ${contractId}`);
+    return contract;
+}
 const package_manager_require = createRequire(import.meta.url);
 function normalizePackageManager(value) {
     if (!value) return;
@@ -749,6 +818,600 @@ function execInstallCommand(command, args, options) {
         child.on('error', (error)=>reject(error));
     });
 }
+function debugSwallowed(step, error) {
+    if (!isVerboseMode()) return;
+    console.log(`${messaging_prefix('debug')} optional-deps ${step}: ${String(error?.message || error)}`);
+}
+function isVerboseMode() {
+    return '1' === String(process.env.EXTENSION_VERBOSE || '').trim();
+}
+function installVerbForPackageManager(name) {
+    if ('npm' === name) return 'install -D';
+    if ('deno' === name) return 'add --dev';
+    return 'add -D';
+}
+function formatInstallHint(projectPath, packageSpecs) {
+    const { name } = resolvePackageManager({
+        cwd: projectPath
+    });
+    const verb = installVerbForPackageManager(name);
+    return `${name} ${verb} ${packageSpecs.join(' ')}`;
+}
+function formatResolverError(args) {
+    const hint = formatInstallHint(args.projectPath, args.installSpecs);
+    const readableLine = `[${args.integration}] ${args.headline} Install it with: ${hint}`;
+    if (!isVerboseMode()) return readableLine;
+    return `${readableLine}\n${JSON.stringify(args.diagnostics, null, 2)}`;
+}
+function toInstallRootContract(integration, contractId, installDependencies, verifyPackageIds) {
+    return {
+        id: contractId,
+        integration,
+        installPackages: installDependencies,
+        verificationRules: verifyPackageIds.map((packageId)=>({
+                type: 'install-root',
+                packageId
+            }))
+    };
+}
+function getVerificationContract(input) {
+    if (input.contract) return input.contract;
+    const installDependencies = input.installDependencies || [
+        input.dependencyId
+    ];
+    const verifyPackageIds = input.verifyPackageIds || installDependencies;
+    return toInstallRootContract(input.integration, input.integration, installDependencies, verifyPackageIds);
+}
+function getResolutionBases(projectPath) {
+    const extensionRoot = resolveDevelopInstallRoot();
+    const bases = [
+        projectPath,
+        extensionRoot || void 0,
+        process.cwd()
+    ].filter(Boolean);
+    if (extensionRoot?.includes('.pnpm')) bases.push(__rspack_external_node_path_806ed179.join(extensionRoot, '..', '..'));
+    return Array.from(new Set(bases));
+}
+function optional_deps_resolver_packageJsonPath(basePath) {
+    return __rspack_external_node_path_806ed179.join(basePath, 'package.json');
+}
+function tryResolveWithBase(dependencyId, basePath) {
+    try {
+        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
+        return req.resolve(dependencyId);
+    } catch (error) {
+        debugSwallowed(`resolve ${dependencyId} from ${basePath}`, error);
+        return;
+    }
+}
+function resolveDependency(dependencyId, projectPath) {
+    const bases = getResolutionBases(projectPath);
+    for (const basePath of bases){
+        const resolvedPath = tryResolveWithBase(dependencyId, basePath);
+        if (resolvedPath) return {
+            resolvedPath,
+            basePath
+        };
+    }
+    try {
+        const resolvedPath = require.resolve(dependencyId, {
+            paths: bases
+        });
+        return {
+            resolvedPath,
+            basePath: projectPath
+        };
+    } catch (error) {
+        debugSwallowed(`resolve ${dependencyId} from the project bases`, error);
+        return;
+    }
+}
+function resolveFromKnownLocations(dependencyId, projectPath) {
+    const direct = resolveDependency(dependencyId, projectPath)?.resolvedPath;
+    if (direct) return direct;
+    if (declaresDependency(projectPath, dependencyId)) return projectPath;
+}
+function declaresDependency(projectPath, dependencyId) {
+    try {
+        return hasProjectDependency(projectPath, dependencyId);
+    } catch (error) {
+        debugSwallowed(`read the project manifest for ${dependencyId}`, error);
+        return false;
+    }
+}
+function dedupeFailures(packageIds) {
+    return Array.from(new Set(packageIds));
+}
+function resolveRealPathSafe(targetPath) {
+    try {
+        return __rspack_external_node_fs_1b05aee1.realpathSync(targetPath);
+    } catch (error) {
+        debugSwallowed(`realpath ${targetPath}`, error);
+        return __rspack_external_node_path_806ed179.resolve(targetPath);
+    }
+}
+function findOwningPackageDir(resolvedPath) {
+    let currentPath = __rspack_external_node_path_806ed179.dirname(resolvedPath);
+    for(let depth = 0; depth < 8; depth++){
+        const packageJson = __rspack_external_node_path_806ed179.join(currentPath, 'package.json');
+        if (__rspack_external_node_fs_1b05aee1.existsSync(packageJson)) return currentPath;
+        const parent = __rspack_external_node_path_806ed179.dirname(currentPath);
+        if (parent === currentPath) break;
+        currentPath = parent;
+    }
+}
+function isSameInstalledPackage(resolvedPath, expectedInstalledPath) {
+    const resolvedPackageDir = findOwningPackageDir(resolvedPath);
+    const expectedPackageDir = findOwningPackageDir(expectedInstalledPath);
+    if (resolvedPackageDir && expectedPackageDir) return resolveRealPathSafe(resolvedPackageDir) === resolveRealPathSafe(expectedPackageDir);
+    return resolveRealPathSafe(resolvedPath) === resolveRealPathSafe(expectedInstalledPath);
+}
+function evaluateModuleContextRule(rule, fromPackagePath, options) {
+    try {
+        const req = createRequire(fromPackagePath);
+        const resolvedPeer = req.resolve(rule.packageId);
+        if (options?.expectedInstalledPath && !isSameInstalledPackage(resolvedPeer, options.expectedInstalledPath)) return rule.packageId;
+        if ('module-context-load' === rule.type) req(rule.packageId);
+        return;
+    } catch (error) {
+        debugSwallowed(`verify ${rule.packageId}`, error);
+        return rule.packageId;
+    }
+}
+function getContractVerificationFailuresFromKnownLocations(contract, projectPath) {
+    const resolvedByPackage = new Map();
+    const resolvePackage = (packageId)=>{
+        if (!resolvedByPackage.has(packageId)) resolvedByPackage.set(packageId, resolveFromKnownLocations(packageId, projectPath));
+        return resolvedByPackage.get(packageId);
+    };
+    const failures = [];
+    for (const rule of contract.verificationRules){
+        if ('install-root' === rule.type) {
+            if (!resolvePackage(rule.packageId)) failures.push(rule.packageId);
+            continue;
+        }
+        const fromPackagePath = resolvePackage(rule.fromPackage);
+        if (!fromPackagePath) {
+            failures.push(rule.fromPackage);
+            continue;
+        }
+        const failure = evaluateModuleContextRule(rule, fromPackagePath);
+        if (!(failure && declaresDependency(projectPath, failure))) {
+            if (failure) failures.push(failure);
+        }
+    }
+    return dedupeFailures(failures);
+}
+function buildDiagnostics(input) {
+    const bases = getResolutionBases(input.projectPath);
+    return {
+        contractId: input.contract?.id || null,
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        projectPath: input.projectPath,
+        installDependencies: input.installDependencies,
+        verifyPackageIds: input.verifyPackageIds,
+        resolutionBases: bases
+    };
+}
+async function ensureOptionalPackageResolved(input) {
+    const contract = getVerificationContract(input);
+    const missing = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath);
+    const resolved = resolveFromKnownLocations(input.dependencyId, input.projectPath);
+    if (resolved && 0 === missing.length) return resolved;
+    const diagnostics = buildDiagnostics({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        projectPath: input.projectPath,
+        contract,
+        installDependencies: contract.installPackages,
+        verifyPackageIds: contract.installPackages
+    });
+    const headline = `${input.dependencyId} could not be resolved.` + (missing.length > 0 ? ` Missing or invalid packages: ${missing.join(', ')}.` : '');
+    throw new Error(formatResolverError({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        headline,
+        installSpecs: missing.length > 0 ? missing : contract.installPackages,
+        projectPath: input.projectPath,
+        diagnostics: {
+            ...diagnostics,
+            missing
+        }
+    }));
+}
+function resolveOptionalPackageWithoutInstall(input) {
+    const contract = getVerificationContract(input);
+    const resolved = resolveFromKnownLocations(input.dependencyId, input.projectPath);
+    const missingPeerDeps = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath);
+    if (resolved && 0 === missingPeerDeps.length) return resolved;
+    const diagnostics = buildDiagnostics({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        projectPath: input.projectPath,
+        contract,
+        installDependencies: contract.installPackages,
+        verifyPackageIds: contract.installPackages
+    });
+    throw new Error(formatResolverError({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        headline: `${input.dependencyId} could not be resolved from the project or extension-develop.`,
+        installSpecs: missingPeerDeps.length > 0 ? missingPeerDeps : contract.installPackages,
+        projectPath: input.projectPath,
+        diagnostics: {
+            ...diagnostics,
+            missingPeerDeps,
+            expectation: 'Run optional dependency preflight or reinstall extension-develop.'
+        }
+    }));
+}
+async function ensureOptionalModuleLoaded(input) {
+    const resolvedPath = await ensureOptionalPackageResolved(input);
+    const candidateBases = getResolutionBases(input.projectPath);
+    let loaded;
+    let didLoad = false;
+    let lastLoadError;
+    for (const basePath of candidateBases){
+        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
+        const candidateModuleIds = [
+            input.dependencyId,
+            resolvedPath
+        ];
+        for (const candidateModuleId of candidateModuleIds)try {
+            loaded = req(candidateModuleId);
+            didLoad = true;
+            break;
+        } catch (error) {
+            lastLoadError = error;
+        }
+        if (didLoad) break;
+    }
+    if (!didLoad) try {
+        loaded = require(resolvedPath);
+        didLoad = true;
+    } catch (directRequireError) {
+        lastLoadError = directRequireError;
+    }
+    if (!didLoad) {
+        const diagnostics = {
+            ...buildDiagnostics({
+                integration: input.integration,
+                dependencyId: input.dependencyId,
+                projectPath: input.projectPath,
+                installDependencies: input.installDependencies || [
+                    input.dependencyId
+                ],
+                verifyPackageIds: input.verifyPackageIds || input.installDependencies || [
+                    input.dependencyId
+                ]
+            }),
+            resolvedPath,
+            loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
+        };
+        throw new Error(formatResolverError({
+            integration: input.integration,
+            dependencyId: input.dependencyId,
+            headline: `${input.dependencyId} could not be loaded after it resolved.`,
+            installSpecs: input.installDependencies || [
+                input.dependencyId
+            ],
+            projectPath: input.projectPath,
+            diagnostics
+        }));
+    }
+    return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
+}
+function loadOptionalModuleWithoutInstall(input) {
+    const resolvedPath = resolveOptionalPackageWithoutInstall(input);
+    const candidateBases = getResolutionBases(input.projectPath);
+    let loaded;
+    let didLoad = false;
+    let lastLoadError;
+    for (const basePath of candidateBases){
+        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
+        const candidateModuleIds = [
+            input.dependencyId,
+            resolvedPath
+        ];
+        for (const candidateModuleId of candidateModuleIds)try {
+            loaded = req(candidateModuleId);
+            didLoad = true;
+            break;
+        } catch (error) {
+            lastLoadError = error;
+        }
+        if (didLoad) break;
+    }
+    if (!didLoad) try {
+        loaded = require(resolvedPath);
+        didLoad = true;
+    } catch (directRequireError) {
+        lastLoadError = directRequireError;
+    }
+    if (!didLoad) throw new Error(formatResolverError({
+        integration: input.integration,
+        dependencyId: input.dependencyId,
+        headline: `${input.dependencyId} could not be loaded after resolving.`,
+        installSpecs: input.installDependencies || [
+            input.dependencyId
+        ],
+        projectPath: input.projectPath,
+        diagnostics: {
+            resolvedPath,
+            loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
+        }
+    }));
+    return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
+}
+async function ensureOptionalContractPackageResolved(input) {
+    const contract = getOptionalDependencyContract(input.contractId);
+    return ensureOptionalPackageResolved({
+        integration: contract.integration,
+        projectPath: input.projectPath,
+        dependencyId: input.dependencyId,
+        contract
+    });
+}
+async function ensureOptionalContractModuleLoaded(input) {
+    const contract = getOptionalDependencyContract(input.contractId);
+    return ensureOptionalModuleLoaded({
+        integration: contract.integration,
+        projectPath: input.projectPath,
+        dependencyId: input.dependencyId,
+        contract,
+        moduleAdapter: input.moduleAdapter
+    });
+}
+function resolveOptionalContractPackageWithoutInstall(input) {
+    const contract = getOptionalDependencyContract(input.contractId);
+    return resolveOptionalPackageWithoutInstall({
+        integration: contract.integration,
+        projectPath: input.projectPath,
+        dependencyId: input.dependencyId,
+        contract
+    });
+}
+function loadOptionalContractModuleWithoutInstall(input) {
+    const contract = getOptionalDependencyContract(input.contractId);
+    return loadOptionalModuleWithoutInstall({
+        integration: contract.integration,
+        projectPath: input.projectPath,
+        dependencyId: input.dependencyId,
+        contract,
+        moduleAdapter: input.moduleAdapter
+    });
+}
+const ADDON_LINT_DEFAULT = true;
+const ADDON_LINT_TIMEOUT_MS = 10000;
+const ADDON_LINT_MAX_PRINTED = 20;
+const ADDON_LINT_PACKAGE = 'addons-linter';
+const DUPLICATED_BY_BUILD_WARNINGS = new Set([
+    'MISSING_DATA_COLLECTION_PERMISSIONS'
+]);
+const hintedProjects = new Set();
+function toModule(loaded) {
+    const candidate = loaded?.createInstance ? loaded : loaded?.default;
+    if ('function' != typeof candidate?.createInstance) throw new Error(`${ADDON_LINT_PACKAGE} exports no createInstance`);
+    return candidate;
+}
+const defaultLoadLinter = (projectPath)=>ensureOptionalModuleLoaded({
+        integration: 'AMO',
+        projectPath,
+        dependencyId: ADDON_LINT_PACKAGE,
+        moduleAdapter: toModule
+    });
+function shouldRunAddonLint(input) {
+    if ((input.enabled ?? ADDON_LINT_DEFAULT) === false) return {
+        status: 'skipped',
+        reason: 'disabled'
+    };
+    if ('production' !== input.mode) return {
+        status: 'skipped',
+        reason: 'mode'
+    };
+    if (!isGeckoBasedBrowser(String(input.browser))) return {
+        status: 'skipped',
+        reason: 'browser'
+    };
+    return null;
+}
+function locationOf(finding) {
+    const file = String(finding.file || '').trim();
+    if (!file) return '';
+    const line = 'number' == typeof finding.line ? `:${finding.line}` : '';
+    return `${file}${line}`;
+}
+function toLine(level, finding) {
+    return {
+        level,
+        code: String(finding.code || 'UNKNOWN').trim(),
+        message: String(finding.message || finding.description || '').replace(/\s+/g, ' ').trim(),
+        location: locationOf(finding)
+    };
+}
+function collectAddonLintLines(output) {
+    const errors = Array.isArray(output?.errors) ? output.errors : [];
+    const warnings = Array.isArray(output?.warnings) ? output.warnings : [];
+    return [
+        ...errors.map((finding)=>toLine('error', finding)),
+        ...warnings.map((finding)=>toLine('warning', finding))
+    ].filter((line)=>!DUPLICATED_BY_BUILD_WARNINGS.has(line.code));
+}
+function formatAddonLintFindings(output, distDisplay, maxPrinted = ADDON_LINT_MAX_PRINTED) {
+    const all = collectAddonLintLines(output);
+    if (0 === all.length) return {
+        findings: 0,
+        lines: []
+    };
+    const errorCount = all.filter((line)=>'error' === line.level).length;
+    const warningCount = all.length - errorCount;
+    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))
+    ];
+    if (all.length > shown.length) lines.push(addonLintMore(all.length - shown.length, distDisplay));
+    return {
+        findings: all.length,
+        lines
+    };
+}
+function withTimeout(promise, ms) {
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            reject(new Error(`timed out after ${Math.round(ms / 1000)} s`));
+        }, ms);
+        timer.unref?.();
+        promise.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function silentConsole() {
+    return {
+        log () {},
+        error () {},
+        warn () {},
+        info () {}
+    };
+}
+async function runAddonLint(input) {
+    const skipped = shouldRunAddonLint(input);
+    if (skipped) return skipped;
+    let linter;
+    try {
+        linter = await (input.loadLinter || defaultLoadLinter)(input.projectPath);
+    } catch  {
+        if (hintedProjects.has(input.projectPath)) return {
+            status: 'missing',
+            hint: null
+        };
+        hintedProjects.add(input.projectPath);
+        return {
+            status: 'missing',
+            hint: addonLintNotInstalled(formatInstallHint(input.projectPath, [
+                ADDON_LINT_PACKAGE
+            ]))
+        };
+    }
+    try {
+        const instance = linter.createInstance({
+            config: {
+                _: [
+                    input.distPath
+                ],
+                logLevel: 'fatal',
+                stack: false,
+                pretty: false,
+                boring: true,
+                warningsAsErrors: false,
+                metadata: false,
+                output: 'none',
+                selfHosted: false,
+                shouldScanFile: (fileName)=>!/\.map$/i.test(fileName)
+            },
+            runAsBinary: false
+        });
+        const output = await withTimeout(instance.run({
+            _console: silentConsole()
+        }), input.timeoutMs ?? ADDON_LINT_TIMEOUT_MS);
+        return {
+            status: 'linted',
+            ...formatAddonLintFindings(output, input.distDisplay)
+        };
+    } catch (error) {
+        return {
+            status: 'failed',
+            debugLine: addonLintFailed(String(error?.message || error))
+        };
+    }
+}
+const DIST_STAGING_PREFIX = '.extension-build-';
+function stagingDistPathFor(distPath) {
+    const unique = `${process.pid.toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    return __rspack_external_node_path_806ed179.join(__rspack_external_node_path_806ed179.dirname(distPath), `${DIST_STAGING_PREFIX}${__rspack_external_node_path_806ed179.basename(distPath)}-${unique}`);
+}
+function removeStaleStagingDirs(distPath) {
+    const parent = __rspack_external_node_path_806ed179.dirname(distPath);
+    const prefix = `${DIST_STAGING_PREFIX}${__rspack_external_node_path_806ed179.basename(distPath)}-`;
+    let entries;
+    try {
+        entries = __rspack_external_node_fs_1b05aee1.readdirSync(parent, {
+            withFileTypes: true
+        });
+    } catch  {
+        return;
+    }
+    for (const entry of entries)try {
+        if (!entry.isDirectory() || !entry.name.startsWith(prefix)) continue;
+        __rspack_external_node_fs_1b05aee1.rmSync(__rspack_external_node_path_806ed179.join(parent, entry.name), {
+            recursive: true,
+            force: true
+        });
+    } catch  {}
+}
+function removeStagingDir(stagingPath) {
+    try {
+        __rspack_external_node_fs_1b05aee1.rmSync(stagingPath, {
+            recursive: true,
+            force: true
+        });
+    } catch  {}
+}
+function promoteStagingDist(stagingPath, distPath) {
+    const parent = __rspack_external_node_path_806ed179.dirname(distPath);
+    __rspack_external_node_fs_1b05aee1.mkdirSync(parent, {
+        recursive: true
+    });
+    const retiredPath = `${stagingPath}-retired`;
+    let retired = false;
+    if (__rspack_external_node_fs_1b05aee1.existsSync(distPath)) {
+        __rspack_external_node_fs_1b05aee1.renameSync(distPath, retiredPath);
+        retired = true;
+    }
+    try {
+        __rspack_external_node_fs_1b05aee1.renameSync(stagingPath, distPath);
+    } catch (error) {
+        if (retired) try {
+            __rspack_external_node_fs_1b05aee1.renameSync(retiredPath, distPath);
+        } catch  {}
+        throw error;
+    }
+    if (retired) try {
+        __rspack_external_node_fs_1b05aee1.rmSync(retiredPath, {
+            recursive: true,
+            force: true
+        });
+    } catch  {}
+}
+const MAX_SUMMARY_WARNINGS = 20;
+const build_summary_ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function getBuildSummary(browser, info, outputPath) {
+    const assets = info?.assets || [];
+    const warnings = (info?.warnings || []).slice(0, MAX_SUMMARY_WARNINGS).map((warning)=>{
+        const message = warning && 'object' == typeof warning ? String(warning.message ?? '') : String(warning ?? '');
+        return message.replace(build_summary_ANSI_PATTERN, '').trim();
+    }).filter(Boolean);
+    return {
+        browser,
+        ...outputPath ? {
+            output_path: outputPath
+        } : {},
+        total_assets: assets.length,
+        total_bytes: assets.reduce((n, a)=>n + (a.size || 0), 0),
+        largest_asset_bytes: assets.reduce((m, a)=>Math.max(m, a.size || 0), 0),
+        warnings_count: (info?.warnings || []).length,
+        errors_count: (info?.errors || []).length,
+        ...warnings.length ? {
+            warnings
+        } : {}
+    };
+}
 async function ensureUserProjectDependencies(packageJsonDir) {
     if (!needsInstall(packageJsonDir)) return;
     const pm = resolvePackageManager({
@@ -1345,6 +2008,31 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                         errors: true
                     });
                     summary = getBuildSummary(browser, info, displayDistPath);
+                    const distDisplay = relativeToCwd(displayDistPath) || collapseHomeDir(displayDistPath);
+                    const lintLines = [];
+                    try {
+                        const lint = await runAddonLint({
+                            projectPath: packageJsonDir,
+                            distPath: displayDistPath,
+                            distDisplay,
+                            browser,
+                            mode: resolvedMode,
+                            enabled: mergedBuildOptions.addonLint
+                        });
+                        if ('missing' === lint.status && lint.hint) lintLines.push(lint.hint);
+                        else if ('failed' === lint.status && isDebug()) lintLines.push(lint.debugLine);
+                        else if ('linted' === lint.status && lint.findings > 0) {
+                            lintLines.push(...lint.lines);
+                            summary = {
+                                ...summary,
+                                warnings_count: summary.warnings_count + lint.findings,
+                                warnings: [
+                                    ...summary.warnings || [],
+                                    ...lint.lines.map((line)=>stripAnsi(line))
+                                ]
+                            };
+                        }
+                    } catch  {}
                     try {
                         const summaryFile = buildSummaryPath(packageJsonDir, browser);
                         __rspack_external_node_fs_1b05aee1.mkdirSync(__rspack_external_node_path_806ed179.dirname(summaryFile), {
@@ -1354,11 +2042,11 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                         ensureSessionStateInProjectGitignore(packageJsonDir);
                         __rspack_external_node_fs_1b05aee1.writeFileSync(summaryFile, JSON.stringify(summary));
                     } catch  {}
-                    if (summary.warnings_count > 0) {
+                    if ((info?.warnings || []).length > 0) {
                         const warningDetails = buildWarningsDetails((info?.warnings || []).filter((warning)=>!isEmitTimeWarning(warning)));
                         if (warningDetails) humanLine(warningDetails);
                     }
-                    const distDisplay = relativeToCwd(displayDistPath) || collapseHomeDir(displayDistPath);
+                    for (const line of lintLines)humanLine(line);
                     humanLine(buildComplete(browser, distDisplay, summary.total_bytes));
                     for (const artifact of getZipArtifacts(stats.compilation)){
                         const artifactPath = useStagingSwap && artifact.path.startsWith(stagingDistPath) ? distPath + artifact.path.slice(stagingDistPath.length) : artifact.path;
@@ -2045,4 +2733,4 @@ async function extensionDev(pathOrRemoteUrl, devOptions) {
         process.exit(1);
     }
 }
-export { BuildEmitter, applySplitChunksGuard, attachLifecycleStream, buildSourceFeatureIndex, classifyEntrySurface, classifyReloadFromSources, createChangedSourcesTracker, createLifecycleStream, defaultSplitChunks, dispatchReload, ensureTypeScriptConfig, extensionBuild, extensionDev, getUserTypeScriptConfigFile, hasDependency, humanLine, isUsingCustomLoader, isUsingIntegration, isUsingTypeScript, jsFrameworksConfigsDetected, jsFrameworksHmrSummary, jsFrameworksIntegrationsEnabled, readContentScriptCount, recordZipArtifact, resolveDevelopDistFile, resolveDevelopInstallRoot, resolvePackageManager };
+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 };