extension-develop 4.1.31 → 4.1.32

package/dist/840~0.mjs

@@ -9,14 +9,16 @@ import pintor from "pintor";
 import { DefinePlugin, WebpackError } from "@rspack/core";
 import { pathToFileURL } from "node:url";
 import { EventEmitter } from "node:events";
-import { package_namespaceObject, loadCommandConfig, DEV_COMMAND_DEFAULTS, stampReadyDistExtensionId, loadProjectConfigDefaults, mergeOptionLayers, loadConfigResolvedHook, stampReadyKnownExtensionId, assertNoManagedDependencyConflicts, loadDefineTypes, loadCustomConfig, START_BUILD_DEFAULTS, loadBrowserConfig, resolveCompanionExtensionsConfig, BUILD_COMMAND_DEFAULTS, getSpecialFoldersDataForProjectRoot, withDarkMode } from "./832~0.mjs";
+import { browserRowValue, CODES, ENVELOPE, prefix as messaging_prefix, humanLine, card, debugLine, isDebug, claimCardKey, isMachineOutput } from "./852~0.mjs";
+import { package_namespaceObject, DEV_COMMAND_DEFAULTS, stampReadyDistExtensionId, takeCodedWarnings, mergeOptionLayers, shouldWarnPortConflict, stampReadyKnownExtensionId, assertNoManagedDependencyConflicts, recordCodedWarning, falseProfileSource, START_BUILD_DEFAULTS, resolveCompanionExtensionsConfig, BUILD_COMMAND_DEFAULTS, getSpecialFoldersDataForProjectRoot, withDarkMode } from "./832~0.mjs";
 import { stripBom, parseJsonSafe, isGeckoBasedBrowser } from "./937~0.mjs";
-import { browserRowValue, isDebug, prefix as messaging_prefix, claimCardKey, card } from "./852~0.mjs";
+import { buildWarningsDetails, buildFailed, getDirs, listOutputFiles, zipArtifactReady, projectInstallFallbackToNpm, debugDirs, zipArtifactNotCreated, addonLintDependencyAttribution, browserLaunchFailed, collapseHomeDir, addonLintMore, extensionLoadRecovered, writingTypeDefinitionsError, extensionLoadStillRefused, operaBuildUnminified, buildAssetsTree, addonLintFailed, addonLintFailedDebug, safariBuildOutputNotFound, projectInstallScriptsDisabled, addonLintFinding, authorInstallNotice, addonLintSummary, codedError, configResolvedChangeIgnored, projectInstallInWorkspaceRoot, addonLintNotInstalled, writingTypeDefinitions, buildComplete, buildCommandFailed, needsInstall, relativeToDir, displayPath, updatingTypeDefinitions, runtimeChunkKeptInline, debugBrowser, normalizeBrowser, configBrowserOrThrow, debugOutputPath, safariInvalidBundleId, devCommandFailed, buildShareHint, getDistPath, getProjectStructure, debugSplitChunksNarrowed } from "./469~0.mjs";
 import { hasProjectDependency, findNearestProjectManifestDirSync } from "./731~0.mjs";
-import { buildWarningsDetails, stripAnsi, buildFailed, getDirs, zipArtifactReady, projectInstallFallbackToNpm, debugDirs, zipArtifactNotCreated, addonLintDependencyAttribution, browserLaunchFailed, collapseHomeDir, addonLintMore, extensionLoadRecovered, writingTypeDefinitionsError, extensionLoadStillRefused, operaBuildUnminified, buildAssetsTree, addonLintFailed, addonLintFailedDebug, safariBuildOutputNotFound, projectInstallScriptsDisabled, addonLintFinding, authorInstallNotice, addonLintSummary, needsInstall, configResolvedChangeIgnored, projectInstallInWorkspaceRoot, addonLintNotInstalled, writingTypeDefinitions, buildComplete, buildCommandFailed, relativeToDir, displayPath, configBrowserOrThrow, runtimeChunkKeptInline, humanLine, debugBrowser, normalizeBrowser, buildSummaryPath, debugOutputPath, safariInvalidBundleId, ensureSessionArtifactsIgnoreFile, ensureSessionStateInProjectGitignore, devCommandFailed, buildShareHint, getDistPath, getProjectStructure, debugSplitChunksNarrowed } from "./896~0.mjs";
+import { loadCommandConfig, loadDefineTypes, loadBrowserConfig, loadProjectConfigDefaults, loadConfigResolvedHook, loadCustomConfig } from "./846~0.mjs";
 import { isResourceUnderDirs, canonicalizeDir } from "./712~0.mjs";
+import { buildSummaryPath, ensureSessionArtifactsIgnoreFile, ensureSessionStateInProjectGitignore } from "./771~0.mjs";
+import { getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset } from "./640~0.mjs";
 import { publicRootsFor } from "./105~0.mjs";
-import { getCanonicalContentScriptEntryName } from "./640~0.mjs";
 import { rememberSpecialFoldersConfig } from "./471~0.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -24,6 +26,533 @@ var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(imp
 import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
 import * as __rspack_external_node_path_806ed179 from "node:path";
 import * as __rspack_external_node_fs_promises_3b710708 from "node:fs/promises";
+const NAMED_CODES = {
+    WARInvalidMatchPattern: CODES.E_WAR_INVALID,
+    WARStringEntryInMv3: CODES.E_WAR_INVALID,
+    LocalesLayoutWarning: CODES.E_LOCALES_LAYOUT,
+    LocalesFolderWithoutMessages: CODES.E_LOCALES_LAYOUT,
+    PerfBudgetWarning: CODES.E_PERF_BUDGET,
+    EnvNoMatchingFile: CODES.E_ENV_NO_MATCH,
+    JSONMissingFile: CODES.E_ENTRY_NOT_FOUND,
+    LocalesPluginMissingFile: CODES.E_ENTRY_NOT_FOUND,
+    HtmlEntrypointMissing: CODES.E_ENTRY_NOT_FOUND,
+    ScriptsMissingFile: CODES.E_ENTRY_NOT_FOUND,
+    HtmlPublicAssetMissing: CODES.E_ASSET_MISSING,
+    WARRelativeAssetMissing: CODES.E_ASSET_MISSING,
+    MissingCssAssetWarning: CODES.E_ASSET_MISSING,
+    RuntimeLoadedFileCompileFailed: CODES.E_SCRIPT_DEP_MISSING,
+    UnresolvedBareRequireWarning: CODES.E_SCRIPT_DEP_MISSING,
+    RemoteResourceBlocked: CODES.E_REMOTE_RESOURCE_BLOCKED,
+    ReservedScriptsFolder: CODES.E_RESERVED_FOLDER,
+    CssPreprocessorMissing: CODES.E_CSS_PREPROCESSOR_MISSING,
+    CssDeadRef: CODES.E_CSS_DEAD_REF,
+    CssParseWarning: CODES.E_CSS_PARSE,
+    BackgroundRequired: CODES.E_BACKGROUND_REQUIRED,
+    ContentScriptSyntax: CODES.E_CONTENT_SCRIPT_SYNTAX
+};
+const WRAPPER_NAMES = new Set([
+    'Error',
+    'ModuleBuildError',
+    'ModuleError',
+    'ModuleWarning',
+    'ModuleParseError',
+    'ModuleParseWarning',
+    'ModuleNotFoundError'
+]);
+const STYLESHEET = /\.(?:css|scss|sass|less|styl|pcss)(?:\?.*)?$/i;
+function diagnostic_code_text(value) {
+    return 'string' == typeof value ? value : '';
+}
+function diagnosticName(issue) {
+    const err = issue ?? {};
+    const own = diagnostic_code_text(err.name);
+    if (own && !WRAPPER_NAMES.has(own)) return own;
+    const inner = diagnostic_code_text(err.error?.name);
+    if (inner && !WRAPPER_NAMES.has(inner)) return inner;
+    const header = /^([A-Za-z]\w*): /.exec(diagnostic_code_text(err.details))?.[1];
+    if (header && !WRAPPER_NAMES.has(header)) return header;
+}
+function isModuleNotFound(err) {
+    return 'ModuleNotFoundError' === err.name || /^\s*[×]?\s*Module not found:/.test(diagnostic_code_text(err.message));
+}
+function isSyntaxFailure(err) {
+    return 'ModuleBuildError' === err.name && /syntax/i.test(diagnostic_code_text(err.error?.name));
+}
+function diagnostic_code_resource(err) {
+    return diagnostic_code_text(err.module?.resource);
+}
+function diagnosticCode(issue, context = {}) {
+    const err = issue ?? {};
+    const declared = diagnostic_code_text(err.code);
+    if (declared && Object.prototype.hasOwnProperty.call(CODES, declared)) return declared;
+    const named = diagnosticName(issue);
+    if (named && NAMED_CODES[named]) return NAMED_CODES[named];
+    if (isModuleNotFound(err)) return CODES.E_MODULE_NOT_FOUND;
+    if (isSyntaxFailure(err) && context.contentScripts?.has(diagnostic_code_resource(err))) return CODES.E_CONTENT_SCRIPT_SYNTAX;
+    if ('ModuleParseError' === err.name && STYLESHEET.test(diagnostic_code_resource(err))) return CODES.E_CSS_PARSE;
+}
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function finite(value) {
+    return 'number' == typeof value && Number.isFinite(value) ? value : void 0;
+}
+function plainMessage(raw) {
+    return String(raw ?? '').replace(ANSI_PATTERN, '').split('\n').map((line, index)=>0 === index ? line.replace(/^\s*[×⚠]\s*/, '') : line.replace(/^\s*│ ?/, '')).join('\n').trim();
+}
+function fileOf(issue, root) {
+    if ('string' == typeof issue.file && issue.file) return issue.file;
+    const resource = issue.module?.resource;
+    if ('string' != typeof resource || !resource) return;
+    if (!root || !__rspack_external_node_path_806ed179.isAbsolute(resource)) return resource;
+    for (const base of [
+        root,
+        realpath(root)
+    ]){
+        const relative = __rspack_external_node_path_806ed179.relative(base, resource);
+        if (relative && !relative.startsWith('..') && !__rspack_external_node_path_806ed179.isAbsolute(relative)) return relative.split(__rspack_external_node_path_806ed179.sep).join('/');
+    }
+    return resource;
+}
+function realpath(dir) {
+    try {
+        return __rspack_external_node_fs_1b05aee1.realpathSync.native(dir);
+    } catch  {
+        return dir;
+    }
+}
+function toDiagnostic(issue, severity, root, context = {}) {
+    const error = issue && 'object' == typeof issue ? issue : {};
+    const message = 'string' == typeof issue ? plainMessage(issue) : plainMessage(error.message);
+    const code = diagnosticCode(issue, context);
+    const file = fileOf(error, root);
+    const line = finite(error.loc?.start?.line);
+    const column = finite(error.loc?.start?.column);
+    const name = 'string' == typeof error.name && 'Error' !== error.name ? error.name : void 0;
+    return {
+        ...code ? {
+            code
+        } : {},
+        message,
+        ...file ? {
+            file
+        } : {},
+        ...void 0 !== line ? {
+            line
+        } : {},
+        ...void 0 !== column ? {
+            column
+        } : {},
+        severity,
+        ...name ? {
+            name
+        } : {}
+    };
+}
+function contentScriptResources(compilation) {
+    const found = new Set();
+    const getChunkModules = compilation?.chunkGraph?.getChunkModules;
+    try {
+        for (const [name, entry] of compilation?.entrypoints ?? [])if (name.startsWith("content_scripts/") && getChunkModules) {
+            for (const chunk of entry.chunks ?? [])for (const module of getChunkModules.call(compilation?.chunkGraph, chunk))if ('string' == typeof module?.resource) found.add(module.resource);
+        }
+    } catch  {}
+    return found;
+}
+function compilationDiagnostics(input, root) {
+    const compilation = input;
+    const base = root ?? compilation?.compiler?.context;
+    const context = {
+        contentScripts: contentScriptResources(compilation)
+    };
+    const errors = Array.isArray(compilation?.errors) ? compilation.errors : [];
+    const warnings = Array.isArray(compilation?.warnings) ? compilation.warnings : [];
+    const all = [
+        ...errors.map((issue)=>toDiagnostic(issue, 'error', base, context)),
+        ...warnings.map((issue)=>toDiagnostic(issue, 'warning', base, context))
+    ];
+    return {
+        details: all.slice(0, 20),
+        truncated: all.length > 20
+    };
+}
+function warningCodes(input) {
+    const compilation = input;
+    const codes = new Map();
+    for (const issue of compilation?.warnings ?? []){
+        const code = diagnosticCode(issue);
+        if (!code) continue;
+        const message = issue && 'object' == typeof issue ? String(issue.message ?? '') : String(issue ?? '');
+        codes.set(message.replace(ANSI_PATTERN, '').trim(), code);
+    }
+    return codes;
+}
+const MAX_OUTPUT_CHARS = 2000;
+const lifecycle_stream_ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function isLifecycleStreamEnabled() {
+    return isMachineOutput();
+}
+function stripAnsi(input) {
+    return String(input || '').replace(lifecycle_stream_ANSI_PATTERN, '');
+}
+function readReadyContract(readyPath) {
+    if (!readyPath) return null;
+    try {
+        const parsed = JSON.parse(__rspack_external_node_fs_1b05aee1.readFileSync(readyPath, 'utf-8'));
+        return parsed && 'object' == typeof parsed ? parsed : null;
+    } catch  {
+        return null;
+    }
+}
+function isProfileLocked(ready) {
+    if (!ready) return false;
+    const code = String(ready.code ?? '').trim().toLowerCase();
+    if ('profile_locked' === code || 'profile-locked' === code) return true;
+    if (true === ready.profileLocked) return true;
+    const message = String(ready.message ?? '');
+    return /profile\s+is\s+locked|singletonlock/i.test(message);
+}
+const USAGE_LAUNCH_CODES = new Set([
+    CODES.E_BROWSER_BINARY_INVALID,
+    CODES.E_BROWSER_BINARY_REQUIRED,
+    CODES.E_FLAG_NOT_SUPPORTED_HERE
+]);
+function stampedLaunchFailureCode(ready) {
+    if ('browser_launch_failed' !== ready.code) return;
+    const code = ready.browserLaunchFailedCode;
+    return 'string' == typeof code && Object.prototype.hasOwnProperty.call(CODES, code) ? code : void 0;
+}
+function cdpFaultWarnings(ready) {
+    const code = ready?.cdpFaultCode;
+    if ('string' != typeof code || !Object.prototype.hasOwnProperty.call(CODES, code)) return [];
+    const message = 'string' == typeof ready?.cdpFaultMessage && ready.cdpFaultMessage.trim() ? ready.cdpFaultMessage.trim() : 'the CDP wire failed after launch';
+    return [
+        `${code}: ${message}`
+    ];
+}
+function toFiniteNumber(value) {
+    if ('number' == typeof value && Number.isFinite(value)) return value;
+    if ('string' == typeof value) {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+class LifecycleStream {
+    options;
+    writeLine;
+    successfulCompiles = 0;
+    compileAttempts = 0;
+    readyEmitted = false;
+    readyErrorEmitted = false;
+    browserExitEmitted = false;
+    interruptEmitted = false;
+    terminalEmitted = false;
+    startingEmitted = false;
+    boundPort = null;
+    exitWatcher;
+    launchFailureWatcher;
+    constructor(options){
+        this.options = options;
+        this.writeLine = options.write || ((line)=>process.stdout.write(line));
+    }
+    get enabled() {
+        return isLifecycleStreamEnabled();
+    }
+    emit(frame) {
+        if (!this.enabled) return null;
+        this.writeLine(`${JSON.stringify(frame)}\n`);
+        return frame;
+    }
+    sessionValue(extra = {}) {
+        const ready = readReadyContract(this.options.readyPath);
+        const port = toFiniteNumber(ready?.port) ?? this.boundPort;
+        return {
+            command: this.options.command,
+            browser: this.options.browser,
+            distPath: this.options.distPath,
+            pid: process.pid,
+            port,
+            ...this.options.readyPath ? {
+                readyPath: this.options.readyPath
+            } : {},
+            ...this.options.eventsPath ? {
+                eventsPath: this.options.eventsPath
+            } : {},
+            ...'string' == typeof ready?.runId ? {
+                runId: ready.runId
+            } : {},
+            ...'string' == typeof ready?.instanceId ? {
+                instanceId: ready.instanceId
+            } : {},
+            ...'string' == typeof ready?.toolchainVersion ? {
+                toolchainVersion: ready.toolchainVersion
+            } : {},
+            ...extra
+        };
+    }
+    starting(args) {
+        const requestedPort = toFiniteNumber(args.requestedPort);
+        const port = toFiniteNumber(args.port);
+        this.boundPort = port;
+        const reassigned = null !== port && shouldWarnPortConflict(requestedPort, port);
+        this.startingEmitted = true;
+        const warnings = reassigned ? [
+            `${CODES.E_PORT_IN_USE}: port ${requestedPort} was taken, so the dev server listens on port ${port}`
+        ] : [];
+        warnings.push(...takeCodedWarnings());
+        return this.emit(ENVELOPE.ok(this.options.command, 'starting', this.sessionValue({
+            requestedPort,
+            port
+        }), {
+            warnings
+        }));
+    }
+    compiled(args) {
+        this.compileAttempts += 1;
+        this.successfulCompiles += 1;
+        const status = 1 === this.successfulCompiles ? 'compiled' : 'recompiled';
+        const assets = toFiniteNumber(args.assets) ?? 0;
+        const warnings = 0 === assets && 0 === toFiniteNumber(args.entrypoints) ? [
+            `${CODES.E_NO_ENTRYPOINTS}: the compilation produced no entrypoints or assets`
+        ] : [];
+        return this.emit(ENVELOPE.ok(this.options.command, status, this.sessionValue({
+            assets,
+            durationMs: toFiniteNumber(args.durationMs) ?? 0
+        }), {
+            warnings
+        }));
+    }
+    compileFailed(args) {
+        this.compileAttempts += 1;
+        const isFirst = 1 === this.compileAttempts;
+        const code = isFirst ? CODES.E_FIRST_COMPILE : CODES.E_COMPILE;
+        const raw = stripAnsi(String(args.output || ''));
+        const outputTruncated = raw.length > MAX_OUTPUT_CHARS;
+        const output = outputTruncated ? `${raw.slice(0, MAX_OUTPUT_CHARS)}…` : raw;
+        const message = args.message || (isFirst ? 'The first compilation failed.' : 'A recompilation failed after a change.');
+        const details = Array.isArray(args.diagnostics) && args.diagnostics.length > 0 ? args.diagnostics : void 0;
+        const launchWithheld = 0 === this.successfulCompiles && !this.options.noBrowser;
+        const frame = ENVELOPE.fail(this.options.command, 'compile-failed', {
+            code,
+            message,
+            ...details ? {
+                details
+            } : {}
+        }, {
+            truncated: outputTruncated || true === args.diagnosticsTruncated,
+            warnings: launchWithheld ? [
+                `${CODES.E_LAUNCH_SKIPPED_COMPILE_ERRORS}: the browser launch is withheld until the compile succeeds`
+            ] : []
+        });
+        frame.value = this.sessionValue({
+            output,
+            durationMs: toFiniteNumber(args.durationMs) ?? 0
+        });
+        return this.emit(frame);
+    }
+    ready(args = {}) {
+        if (this.readyEmitted) return null;
+        if (null != args.port) this.boundPort = toFiniteNumber(args.port);
+        const ready = readReadyContract(this.options.readyPath);
+        if (ready && 'error' === ready.status) {
+            if (this.readyErrorEmitted) return null;
+            this.readyErrorEmitted = true;
+            return this.contractError(ready, CODES.E_READY_ERROR_STATUS);
+        }
+        this.readyEmitted = true;
+        return this.emit(ENVELOPE.ok(this.options.command, 'ready', this.sessionValue(), {
+            warnings: cdpFaultWarnings(ready)
+        }));
+    }
+    contractError(ready, fallback) {
+        const launchCode = stampedLaunchFailureCode(ready);
+        const frame = ENVELOPE.fail(this.options.command, launchCode && USAGE_LAUNCH_CODES.has(launchCode) ? 'usage' : 'failed', {
+            code: launchCode ?? fallback,
+            message: String(ready.message || '') || 'The ready contract reports an error for this session.'
+        });
+        frame.value = this.sessionValue({
+            ...'string' == typeof ready.code ? {
+                readyCode: ready.code
+            } : {}
+        });
+        this.terminalEmitted = true;
+        return this.emit(frame);
+    }
+    exited(exitCode) {
+        if (!this.startingEmitted || this.terminalEmitted || 0 === exitCode) return null;
+        const ready = readReadyContract(this.options.readyPath);
+        if (ready && 'error' === ready.status) return this.contractError(ready, 'browser_launch_failed' === ready.code ? CODES.E_BROWSER_LAUNCH : CODES.E_READY_ERROR_STATUS);
+        const frame = ENVELOPE.fail(this.options.command, 'failed', {
+            code: CODES.E_INTERNAL,
+            message: `The dev session ended with exit code ${exitCode}.`
+        });
+        frame.value = this.sessionValue({
+            exitCode
+        });
+        this.terminalEmitted = true;
+        return this.emit(frame);
+    }
+    emitOnExit() {
+        const onExit = (code)=>{
+            try {
+                this.exited(code);
+            } catch  {}
+        };
+        process.once('exit', onExit);
+        return ()=>{
+            process.removeListener('exit', onExit);
+        };
+    }
+    browserExited(args = {}) {
+        if (this.browserExitEmitted) return null;
+        this.browserExitEmitted = true;
+        const ready = readReadyContract(this.options.readyPath);
+        const locked = isProfileLocked(ready);
+        const code = locked ? CODES.E_PROFILE_LOCKED : CODES.E_BROWSER_LAUNCH;
+        const message = args.message || String(ready?.message || '') || (locked ? 'The browser profile is locked by another session.' : 'The browser exited before the session ended.');
+        const frame = ENVELOPE.fail(this.options.command, 'browser-exited', {
+            code,
+            message
+        });
+        frame.value = this.sessionValue({
+            exitCode: toFiniteNumber(args.exitCode) ?? toFiniteNumber(ready?.browserExitCode),
+            ...'string' == typeof ready?.browserExitSignal ? {
+                exitSignal: ready.browserExitSignal
+            } : {},
+            ...'string' == typeof ready?.browserExitedAt ? {
+                browserExitedAt: ready.browserExitedAt
+            } : {}
+        });
+        this.terminalEmitted = true;
+        return this.emit(frame);
+    }
+    interrupted(signal) {
+        if (this.interruptEmitted) return null;
+        this.interruptEmitted = true;
+        this.terminalEmitted = true;
+        const frame = ENVELOPE.fail(this.options.command, 'stopped', {
+            code: CODES.E_INTERRUPTED,
+            message: `The ${this.options.command} session was interrupted by ${signal}.`
+        });
+        frame.value = this.sessionValue({
+            signal
+        });
+        return this.emit(frame);
+    }
+    failed(message) {
+        const frame = ENVELOPE.fail(this.options.command, 'failed', {
+            code: CODES.E_DEV_SERVER_START,
+            message: stripAnsi(message)
+        });
+        frame.value = this.sessionValue();
+        this.terminalEmitted = true;
+        return this.emit(frame);
+    }
+    watchBrowserExit(intervalMs = 1000, onExit) {
+        const stop = ()=>{
+            if (this.exitWatcher) clearInterval(this.exitWatcher);
+            this.exitWatcher = void 0;
+        };
+        if (!this.options.readyPath) return stop;
+        if (!this.enabled && !onExit) return stop;
+        if (this.exitWatcher) return stop;
+        this.exitWatcher = setInterval(()=>{
+            const ready = readReadyContract(this.options.readyPath);
+            if ('string' != typeof ready?.browserExitedAt) return;
+            onExit?.(ready);
+            this.browserExited();
+            stop();
+        }, intervalMs);
+        this.exitWatcher.unref?.();
+        return stop;
+    }
+    watchBrowserLaunchFailure(intervalMs = 1000, onFailure) {
+        const stop = ()=>{
+            if (this.launchFailureWatcher) clearInterval(this.launchFailureWatcher);
+            this.launchFailureWatcher = void 0;
+        };
+        if (!this.options.readyPath) return stop;
+        if (this.launchFailureWatcher) return stop;
+        this.launchFailureWatcher = setInterval(()=>{
+            const ready = readReadyContract(this.options.readyPath);
+            if ('string' != typeof ready?.browserLaunchFailedAt) return;
+            onFailure(ready);
+            stop();
+        }, intervalMs);
+        this.launchFailureWatcher.unref?.();
+        return stop;
+    }
+}
+function createLifecycleStream(options) {
+    return new LifecycleStream(options);
+}
+function assetCount(stats) {
+    const compilation = stats?.compilation;
+    try {
+        const assets = compilation?.getAssets?.();
+        if (Array.isArray(assets)) return assets.length;
+    } catch  {}
+    return Object.keys(compilation?.assets || {}).length;
+}
+function entrypointCount(stats) {
+    try {
+        const entrypoints = stats?.toJson?.({
+            all: false,
+            entrypoints: true
+        })?.entrypoints;
+        return entrypoints && 'object' == typeof entrypoints ? Object.keys(entrypoints).length : void 0;
+    } catch  {
+        return;
+    }
+}
+function compileDuration(stats) {
+    const compilation = stats?.compilation;
+    const start = Number(compilation?.startTime || 0);
+    const end = Number(compilation?.endTime || 0);
+    const duration = end - start;
+    return Number.isFinite(duration) && duration > 0 ? duration : 0;
+}
+function errorText(stats) {
+    try {
+        return String(stats?.toString?.({
+            all: false,
+            errors: true,
+            colors: false
+        }) || '');
+    } catch  {
+        return '';
+    }
+}
+function attachLifecycleStream(compiler, stream) {
+    const hooks = compiler?.hooks;
+    hooks?.done?.tap('extension.js:lifecycle-stream', (stats)=>{
+        try {
+            if (stats?.hasErrors?.()) {
+                const { details, truncated } = compilationDiagnostics(stats.compilation);
+                stream.compileFailed({
+                    output: errorText(stats),
+                    durationMs: compileDuration(stats),
+                    diagnostics: details,
+                    diagnosticsTruncated: truncated
+                });
+                return;
+            }
+            stream.compiled({
+                assets: assetCount(stats),
+                durationMs: compileDuration(stats),
+                entrypoints: entrypointCount(stats)
+            });
+            stream.ready();
+        } catch  {}
+    });
+    hooks?.failed?.tap('extension.js:lifecycle-stream', (error)=>{
+        try {
+            stream.compileFailed({
+                output: error instanceof Error ? error.stack || error.message : String(error),
+                message: error instanceof Error ? error.message : String(error)
+            });
+        } catch  {}
+    });
+}
 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) {
@@ -90,10 +619,10 @@ function resolveDevelopDistFile(stem) {
         base
     ];
     for (const candidate of candidates)if (__rspack_external_node_fs_1b05aee1.existsSync(candidate)) {
-        if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${candidate} (installRoot=${installRoot || '<none>'})`);
+        if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) debugLine(`[extjs:develop-root] ${stem} -> ${candidate} (installRoot=${installRoot || '<none>'})`);
         return candidate;
     }
-    if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) console.log(`[extjs:develop-root] ${stem} -> ${base} (fallback, installRoot=${installRoot || '<none>'})`);
+    if ('1' === process.env.EXTENSION_DEBUG_DEVELOP_ROOT) debugLine(`[extjs:develop-root] ${stem} -> ${base} (fallback, installRoot=${installRoot || '<none>'})`);
     return base;
 }
 const BUNDLED_DEPENDENCY_VERSIONS = {
@@ -258,9 +787,47 @@ const OPTIONAL_DEPENDENCY_CONTRACTS = {
 };
 function getOptionalDependencyContract(contractId) {
     const contract = OPTIONAL_DEPENDENCY_CONTRACTS[contractId];
-    if (!contract) throw new Error(`Unknown optional dependency contract: ${contractId}`);
+    if (!contract) throw codedError(CODES.E_OPTIONAL_DEP_UNKNOWN, `Unknown optional dependency contract: ${contractId}`);
     return contract;
 }
+const NPMRC_REGISTRY = /^\s*registry\s*=\s*(.*?)\s*$/;
+const PUBLIC_REGISTRY_HOSTS = [
+    'registry.npmjs.org',
+    'registry.yarnpkg.com'
+];
+function readEnv(source, name) {
+    const key = Object.keys(source).find((candidate)=>candidate.toLowerCase() === name.toLowerCase() && source[candidate]);
+    return void 0 === key ? void 0 : source[key];
+}
+function readNpmrcRegistry(projectDir) {
+    let registry;
+    try {
+        for (const line of __rspack_external_node_fs_1b05aee1.readFileSync(__rspack_external_node_path_806ed179.join(projectDir, '.npmrc'), 'utf8').split(/\r?\n/)){
+            const match = NPMRC_REGISTRY.exec(line);
+            if (match) registry = match[1].replace(/^(['"])(.*)\1$/, '$2');
+        }
+    } catch  {}
+    return registry;
+}
+function privateRegistry(value) {
+    const raw = String(value || '').trim();
+    if (!raw || raw.includes('${')) return;
+    try {
+        const url = new URL(raw);
+        if ('http:' !== url.protocol && 'https:' !== url.protocol) return;
+        if (PUBLIC_REGISTRY_HOSTS.includes(url.hostname)) return;
+        return url.href.replace(/\/+$/, '');
+    } catch  {
+        return;
+    }
+}
+function corepackRegistryEnv(source, projectDir) {
+    if (readEnv(source, 'COREPACK_NPM_REGISTRY')) return {};
+    const registry = privateRegistry(readEnv(source, 'npm_config_registry') || readNpmrcRegistry(projectDir));
+    return registry ? {
+        COREPACK_NPM_REGISTRY: registry
+    } : {};
+}
 const package_manager_require = createRequire(import.meta.url);
 function normalizePackageManager(value) {
     if (!value) return;
@@ -683,12 +1250,13 @@ function buildSpawnInvocation(command, args) {
 }
 function spawnInstallCommand(command, args, options) {
     const invocation = buildSpawnInvocation(command, args);
-    const env = buildExecEnv();
+    const env = buildExecEnv() || process.env;
     return spawn(invocation.command, invocation.args, {
         cwd: options?.cwd,
         stdio: options?.stdio ?? 'ignore',
         env: {
-            ...env || process.env,
+            ...env,
+            ...corepackRegistryEnv(env, options?.cwd ?? process.cwd()),
             ...options?.env
         }
     });
@@ -705,7 +1273,7 @@ function execInstallCommand(command, args, options) {
 }
 function debugSwallowed(step, error) {
     if (!isVerboseMode()) return;
-    console.log(`${messaging_prefix('debug')} optional-deps ${step}: ${String(error?.message || error)}`);
+    debugLine(`${messaging_prefix('debug')} optional-deps ${step}: ${String(error?.message || error)}`);
 }
 function isVerboseMode() {
     return '1' === String(process.env.EXTENSION_VERBOSE || '').trim();
@@ -893,7 +1461,7 @@ async function ensureOptionalPackageResolved(input) {
         verifyPackageIds: contract.installPackages
     });
     const headline = `${input.dependencyId} could not be resolved.` + (missing.length > 0 ? ` Missing or invalid packages: ${missing.join(', ')}.` : '');
-    throw new Error(formatResolverError({
+    throw codedError(CODES.E_OPTIONAL_DEP_UNRESOLVED, formatResolverError({
         integration: input.integration,
         dependencyId: input.dependencyId,
         headline,
@@ -918,7 +1486,7 @@ function resolveOptionalPackageWithoutInstall(input) {
         installDependencies: contract.installPackages,
         verifyPackageIds: contract.installPackages
     });
-    throw new Error(formatResolverError({
+    throw codedError(CODES.E_OPTIONAL_DEP_UNRESOLVED, formatResolverError({
         integration: input.integration,
         dependencyId: input.dependencyId,
         headline: `${input.dependencyId} could not be resolved from the project or extension-develop.`,
@@ -974,7 +1542,7 @@ async function ensureOptionalModuleLoaded(input) {
             resolvedPath,
             loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
         };
-        throw new Error(formatResolverError({
+        throw codedError(CODES.E_OPTIONAL_DEP_LOAD, formatResolverError({
             integration: input.integration,
             dependencyId: input.dependencyId,
             headline: `${input.dependencyId} could not be loaded after it resolved.`,
@@ -1014,7 +1582,7 @@ function loadOptionalModuleWithoutInstall(input) {
     } catch (directRequireError) {
         lastLoadError = directRequireError;
     }
-    if (!didLoad) throw new Error(formatResolverError({
+    if (!didLoad) throw codedError(CODES.E_OPTIONAL_DEP_LOAD, formatResolverError({
         integration: input.integration,
         dependencyId: input.dependencyId,
         headline: `${input.dependencyId} could not be loaded after resolving.`,
@@ -1074,6 +1642,10 @@ const ADDON_LINT_PACKAGE = 'addons-linter';
 const DUPLICATED_BY_BUILD_WARNINGS = new Set([
     'MISSING_DATA_COLLECTION_PERMISSIONS'
 ]);
+const NOTICES_PRINTED_AS_WARNINGS = new Set([
+    'PERMISSION_FIREFOX_UNSUPPORTED_BY_MIN_VERSION',
+    'PERMISSION_FIREFOX_ANDROID_UNSUPPORTED_BY_MIN_VERSION'
+]);
 const hintedProjects = new Set();
 function toModule(loaded) {
     const candidate = loaded?.createInstance ? loaded : loaded?.default;
@@ -1107,21 +1679,49 @@ function locationOf(finding) {
     const line = 'number' == typeof finding.line ? `:${finding.line}` : '';
     return `${file}${line}`;
 }
+function oneLine(text) {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+function quotedIn(text) {
+    return Array.from(text.matchAll(/"([^"]+)"/g), (match)=>match[1]);
+}
+function textOf(finding) {
+    const message = oneLine(finding.message);
+    const description = oneLine(finding.description);
+    if (!message || !description) return message || description;
+    if (quotedIn(message).length > 0) return message;
+    const isOneSentence = !/[.!?]\s+\S/.test(description.replace(/"[^"]*"/g, '""'));
+    const namesMore = quotedIn(description).some((subject)=>!message.includes(subject));
+    return isOneSentence && namesMore ? description : message;
+}
 function toLine(level, finding) {
     return {
         level,
         code: String(finding.code || 'UNKNOWN').trim(),
-        message: String(finding.message || finding.description || '').replace(/\s+/g, ' ').trim(),
+        message: textOf(finding),
         location: locationOf(finding)
     };
 }
 function collectAddonLintLines(output) {
     const errors = Array.isArray(output?.errors) ? output.errors : [];
     const warnings = Array.isArray(output?.warnings) ? output.warnings : [];
+    const notices = Array.isArray(output?.notices) ? output.notices : [];
+    const seen = new Set();
     return [
         ...errors.map((finding)=>toLine('error', finding)),
-        ...warnings.map((finding)=>toLine('warning', finding))
-    ].filter((line)=>!DUPLICATED_BY_BUILD_WARNINGS.has(line.code));
+        ...warnings.map((finding)=>toLine('warning', finding)),
+        ...notices.map((finding)=>toLine('warning', finding)).filter((line)=>NOTICES_PRINTED_AS_WARNINGS.has(line.code))
+    ].filter((line)=>!DUPLICATED_BY_BUILD_WARNINGS.has(line.code)).filter((line)=>{
+        const printed = [
+            line.level,
+            line.code,
+            line.message,
+            line.location
+        ].join('\0');
+        if (seen.has(printed)) return false;
+        seen.add(printed);
+        return true;
+    });
 }
 function attributionFor(location, chunkProvenance) {
     if (!chunkProvenance || 0 === chunkProvenance.size) return '';
@@ -1329,12 +1929,14 @@ function promoteStagingDist(stagingPath, distPath) {
     } catch  {}
 }
 const MAX_SUMMARY_WARNINGS = 20;
-const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
-function getBuildSummary(browser, info, outputPath) {
-    const assets = info?.assets || [];
+const build_summary_ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+function getBuildSummary(browser, info, outputPath, outputFiles, codes) {
+    const assets = outputFiles?.length ? outputFiles : 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(ANSI_PATTERN, '').trim();
+        const text = message.replace(build_summary_ANSI_PATTERN, '').trim();
+        const code = codes?.get(text);
+        return code ? `${code}: ${text.replace(/^[×⚠]\s*/, '')}` : text;
     }).filter(Boolean);
     return {
         browser,
@@ -1528,10 +2130,12 @@ function restoreFixedKeys(holder, before, { name, isFixed }) {
 }
 class ConfigResolvedPlugin {
     hook;
+    context;
     static name = 'plugin-config-resolved';
     applied = false;
-    constructor(hook){
+    constructor(hook, context){
         this.hook = hook;
+        this.context = context;
     }
     apply(compiler) {
         const options = compiler.options;
@@ -1555,7 +2159,7 @@ class ConfigResolvedPlugin {
                     before: snapshotFixedKeys(holder, fixed)
                 };
             });
-            const next = await this.hook(compiler.options);
+            const next = await this.hook(compiler.options, this.context);
             if (next && next !== compiler.options) for (const [key, value] of Object.entries(next))options[key] = value;
             const ignored = [];
             for (const { fixed, holder, before } of holders){
@@ -1576,6 +2180,13 @@ class ConfigResolvedPlugin {
         compiler.hooks.watchRun.tapPromise(ConfigResolvedPlugin.name, run);
     }
 }
+function projectInstallStdio() {
+    return isMachineOutput() ? [
+        'inherit',
+        2,
+        2
+    ] : 'inherit';
+}
 async function ensureUserProjectDependencies(packageJsonDir) {
     const member = findPnpmWorkspaceMember(packageJsonDir);
     if (!needsInstall(packageJsonDir, member?.root)) return;
@@ -1594,7 +2205,7 @@ async function ensureUserProjectDependencies(packageJsonDir) {
     try {
         await execInstallCommand(cmd.command, cmd.args, {
             cwd: target.cwd,
-            stdio: 'inherit',
+            stdio: projectInstallStdio(),
             env: suppression.env
         });
     } catch (error) {
@@ -1610,7 +2221,7 @@ async function ensureUserProjectDependencies(packageJsonDir) {
         ]);
         await execInstallCommand(npmCmd.command, npmCmd.args, {
             cwd: packageJsonDir,
-            stdio: 'inherit',
+            stdio: projectInstallStdio(),
             env: npmSuppression.env
         });
     }
@@ -1760,16 +2371,18 @@ async function generateExtensionTypes(manifestDir, packageJsonDir) {
     try {
         await __rspack_external_node_fs_promises_3b710708.access(extensionEnvFile);
         const existingContent = await __rspack_external_node_fs_promises_3b710708.readFile(extensionEnvFile, 'utf8');
-        if (existingContent.includes('develop/dist/types')) await __rspack_external_node_fs_promises_3b710708.writeFile(extensionEnvFile, fileContent);
+        if (existingContent === fileContent) return;
+        humanLine(updatingTypeDefinitions(extensionEnvFile));
         await __rspack_external_node_fs_promises_3b710708.writeFile(extensionEnvFile, fileContent);
     } catch (err) {
         const manifestText = await __rspack_external_node_fs_promises_3b710708.readFile(__rspack_external_node_path_806ed179.join(manifestDir, 'manifest.json'), 'utf8');
         const manifest = parseJsonSafe(manifestText);
-        console.log(writingTypeDefinitions(manifest));
+        humanLine(writingTypeDefinitions(manifest));
         try {
             await __rspack_external_node_fs_promises_3b710708.writeFile(extensionEnvFile, fileContent);
         } catch (writeErr) {
-            console.log(writingTypeDefinitionsError(writeErr));
+            recordCodedWarning(CODES.E_TYPES_EMIT, `Writing ${extensionEnvFile} failed: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}`);
+            humanLine(writingTypeDefinitionsError(writeErr));
         }
     }
 }
@@ -1882,7 +2495,7 @@ function normalizeSplitChunks(config) {
 }
 function applySplitChunksGuard(config) {
     const { config: next, narrowed } = normalizeSplitChunks(config);
-    if (narrowed.length > 0 && isDebug()) console.log(debugSplitChunksNarrowed(narrowed));
+    if (narrowed.length > 0 && isDebug()) debugLine(debugSplitChunksNarrowed(narrowed));
     return keepRuntimeInline(keepUserEntriesWhole(next));
 }
 function keepRuntimeInline(config) {
@@ -2027,7 +2640,7 @@ let userMessageDelivered = false;
 function isUsingReact(projectPath) {
     if (hasDependency(projectPath, 'react')) {
         if (!userMessageDelivered) {
-            if (isDebug()) console.log(`${messaging_prefix('debug')} ${isUsingIntegration('React')}`);
+            if (isDebug()) debugLine(`${messaging_prefix('debug')} ${isUsingIntegration('React')}`);
             userMessageDelivered = true;
         }
         return true;
@@ -2116,7 +2729,7 @@ let preact_userMessageDelivered = false;
 function isUsingPreact(projectPath) {
     if (hasDependency(projectPath, 'preact')) {
         if (!preact_userMessageDelivered) {
-            if (isDebug()) console.log(`${messaging_prefix('debug')} ${isUsingIntegration('Preact')}`);
+            if (isDebug()) debugLine(`${messaging_prefix('debug')} ${isUsingIntegration('Preact')}`);
             preact_userMessageDelivered = true;
         }
         return true;
@@ -2253,7 +2866,7 @@ let solid_userMessageDelivered = false;
 function isUsingSolid(projectPath) {
     const using = hasDependency(projectPath, 'solid-js');
     if (using && !solid_userMessageDelivered) {
-        if (isDebug()) console.log(`${messaging_prefix('debug')} ${isUsingIntegration('Solid')}`);
+        if (isDebug()) debugLine(`${messaging_prefix('debug')} ${isUsingIntegration('Solid')}`);
         solid_userMessageDelivered = true;
     }
     return using;
@@ -2416,7 +3029,7 @@ async function loadLoaderOptions(projectPath, framework) {
     if (configPath) {
         if (!load_loader_options_userMessageDelivered && isDebug()) {
             const display = __rspack_external_node_path_806ed179.basename(configPath);
-            console.log(isUsingCustomLoader(display));
+            debugLine(isUsingCustomLoader(display));
             load_loader_options_userMessageDelivered = true;
         }
         try {
@@ -2434,7 +3047,7 @@ 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')}`);
+        if (isDebug()) debugLine(`${messaging_prefix('debug')} ${isUsingIntegration('Vue')}`);
         vue_userMessageDelivered = true;
     }
     return using;
@@ -2643,9 +3256,9 @@ function ensureTypeScriptConfig(projectPath) {
     const hasTsFiles = hasTypeScriptSourceFiles(projectPath);
     if (hasTsFiles || hasDep && tsConfigFilePath) {
         if (tsConfigFilePath) {
-            if (!hasShownUserMessage && isDebug()) console.log(`${messaging_prefix('debug')} ${isUsingIntegration('TypeScript')}`);
+            if (!hasShownUserMessage && isDebug()) debugLine(`${messaging_prefix('debug')} ${isUsingIntegration('TypeScript')}`);
         } else {
-            if (!hasShownUserMessage) console.log(creatingTSConfig());
+            if (!hasShownUserMessage) humanLine(creatingTSConfig());
             writeTsConfig(projectPath);
         }
         hasShownUserMessage = true;
@@ -2747,6 +3360,7 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
     const stagingDistPath = stagingDistPathFor(distPath);
     const isAuthor = isDebug();
     try {
+        takeCodedWarnings();
         await ensureDevelopArtifacts();
         if (buildOptions?.install !== false) await ensureUserProjectDependencies(packageJsonDir);
         ensureTypeScriptConfig(manifestDir);
@@ -2772,9 +3386,9 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
         const safariIdentity = safariPackager ? resolveSafariIdentity(mergedBuildOptions) : void 0;
         removeStaleStagingDirs(distPath);
         if (debug) {
-            console.log(debugDirs(manifestDir, packageJsonDir));
-            console.log(debugBrowser(browser, buildOptions?.chromiumBinary, buildOptions?.geckoBinary || buildOptions?.firefoxBinary));
-            console.log(debugOutputPath(distPath));
+            debugLine(debugDirs(manifestDir, packageJsonDir));
+            debugLine(debugBrowser(browser, buildOptions?.chromiumBinary, buildOptions?.geckoBinary || buildOptions?.firefoxBinary));
+            debugLine(debugOutputPath(distPath));
         }
         const mergedExtensionsConfig = buildOptions?.extensions ?? commandConfig.extensions ?? browserConfig.extensions ?? projectConfig.extensions ?? specialFoldersData.extensions;
         const resolvedExtensionsConfig = await resolveCompanionExtensionsConfig({
@@ -2798,7 +3412,12 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
             }
         });
         const allPluginsButBrowserRunners = baseConfig.plugins?.filter((plugin)=>plugin?.constructor.name !== 'plugin-browsers');
-        const userExtensionConfig = await loadCustomConfig(packageJsonDir);
+        const hookContext = {
+            browser,
+            mode: resolvedMode,
+            command: buildOptions?.metadataCommand || 'build'
+        };
+        const userExtensionConfig = await loadCustomConfig(packageJsonDir, hookContext);
         const userConfig = userExtensionConfig({
             ...baseConfig,
             plugins: allPluginsButBrowserRunners
@@ -2808,7 +3427,7 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
         const configResolved = await loadConfigResolvedHook(packageJsonDir);
         if (configResolved) compilerConfig.plugins = [
             ...compilerConfig.plugins || [],
-            new ConfigResolvedPlugin(configResolved)
+            new ConfigResolvedPlugin(configResolved, hookContext)
         ];
         const compileContext = 'string' == typeof compilerConfig.context && compilerConfig.context ? __rspack_external_node_path_806ed179.resolve(compilerConfig.context) : packageJsonDir;
         const mergedOutputPath = 'string' == typeof compilerConfig.output?.path ? __rspack_external_node_path_806ed179.resolve(compileContext, compilerConfig.output.path) : '';
@@ -2841,10 +3460,11 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                     removeStagingDir(stagingDistPath);
                     return reject(new Error('Build failed: bundler returned invalid stats output (no reliable compilation result).'));
                 }
+                const outputFiles = listOutputFiles(useStagingSwap ? stagingDistPath : displayDistPath);
                 try {
                     printBuildCard(projectStructure.manifestPath, browser, displayDistPath);
                     if (!silent) {
-                        const assetsTree = buildAssetsTree(stats);
+                        const assetsTree = buildAssetsTree(stats, outputFiles);
                         if (assetsTree) humanLine(assetsTree);
                     }
                 } catch  {}
@@ -2861,7 +3481,12 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                     } catch  {}
                     console.error(buildFailed(errorCount));
                     if (!shouldExitOnError) {
-                        const failure = new Error('Build failed with errors');
+                        const { details, truncated } = compilationDiagnostics(stats.compilation, packageJsonDir);
+                        const failure = Object.assign(new Error('Build failed with errors'), {
+                            code: CODES.E_COMPILE,
+                            diagnostics: details,
+                            truncated
+                        });
                         reportedBuildFailures.add(failure);
                         return reject(failure);
                     }
@@ -2882,7 +3507,16 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
                         warnings: true,
                         errors: true
                     });
-                    summary = getBuildSummary(browser, info, displayDistPath);
+                    summary = getBuildSummary(browser, info, displayDistPath, outputFiles, warningCodes(stats.compilation));
+                    const codedWarnings = takeCodedWarnings();
+                    if (codedWarnings.length > 0) summary = {
+                        ...summary,
+                        warnings_count: summary.warnings_count + codedWarnings.length,
+                        warnings: [
+                            ...summary.warnings || [],
+                            ...codedWarnings
+                        ]
+                    };
                     const distDisplay = displayPath(displayDistPath);
                     const lintLines = [];
                     try {
@@ -2995,6 +3629,12 @@ async function extensionBuild(pathOrRemoteUrl, buildOptions) {
         process.exit(1);
     }
 }
+function reloadingExtensionForStaticContentScript(label) {
+    return `${messaging_prefix('info')} Reloading the extension for ${label}: a ${pintor.blue('document_start')} content script is read once when the extension loads, so the pages it matches reload too.`;
+}
+function backgroundIsRequiredMessageOnly(backgroundChunkName) {
+    return `Check the ${pintor.blue(backgroundChunkName.replace('/', '.'))} field in your ${pintor.blue('manifest.json')} file.`;
+}
 function viaBroker(broker, instruction) {
     return broker.broadcastReload({
         type: instruction.type,
@@ -3026,14 +3666,14 @@ async function dispatchReload(instruction, executor) {
                 if (instruction.label) console.warn(formatUnappliedReloadLine(instruction.label));
                 return;
             }
-            if (instruction.label) console.log(formatReloadingLine(instruction.label));
+            if (instruction.label) humanLine(instruction.staticContentScriptEntries?.length ? reloadingExtensionForStaticContentScript(instruction.label) : formatReloadingLine(instruction.label));
             return;
         }
         const warning = executor.broker.undeliveredReloadWarning?.(executor.producerRestartExpected ? {
             producerRestartExpected: true
         } : void 0);
         if (warning) return void console.warn(warning);
-        if (executor.producerRestartExpected && instruction.label) console.log(formatQueuedReloadLine(instruction.label));
+        if (executor.producerRestartExpected && instruction.label) humanLine(formatQueuedReloadLine(instruction.label));
     }
 }
 function isForcedFullPath(normalized) {
@@ -3119,6 +3759,483 @@ function createChangedSourcesTracker(compiler) {
         }
     };
 }
+const DEV_CONTENT_SCRIPT_REGISTRY_ASSET = "content_scripts/dev-registry.json";
+const DEV_CONTENT_SCRIPT_MARKER_KEY = '__extjsDevContentScripts';
+const DEV_CONTENT_SCRIPT_STUB_MESSAGE_KEY = '__extjsDevCsStub';
+const DEV_CONTENT_SCRIPT_ID_PREFIX = 'extjs-dev-cs-';
+const DEV_CONTENT_SCRIPT_STATIC_RELOAD_KEY = '__extjsDevStaticReload';
+const DEV_CONTENT_SCRIPT_STATIC_BUNDLES_KEY = '__extjsDevStaticBundles';
+function devContentScriptStubAssetName(index) {
+    return `content_scripts/dev-stub-${index}.js`;
+}
+function devContentScriptCssMarkerAssetName(index) {
+    return `content_scripts/dev-css-${index}.js`;
+}
+const DEV_CONTENT_SCRIPT_STAND_IN_ASSET = /^content_scripts\/dev-(?:stub|css)-\d+\.js$/;
+function isDevContentScriptStandInAsset(assetName) {
+    return DEV_CONTENT_SCRIPT_STAND_IN_ASSET.test(assetName);
+}
+const HASHED_CONTENT_SCRIPT_ASSET = /^content_scripts\/content-(\d+)(?:\.[a-f0-9]+)?\.js$/i;
+function contentScriptEntryForAsset(assetName) {
+    const match = HASHED_CONTENT_SCRIPT_ASSET.exec(assetName);
+    if (!match) return;
+    return getCanonicalContentScriptEntryName(Number(match[1]));
+}
+function stringList(value) {
+    return Array.isArray(value) ? value.filter((item)=>'string' == typeof item) : [];
+}
+function runAtOf(value) {
+    if ('document_start' === value || 'document_end' === value) return value;
+    return 'document_idle';
+}
+function canonicalIndexOf(entry) {
+    for (const file of [
+        ...stringList(entry.js),
+        ...stringList(entry.css)
+    ]){
+        const parsed = parseCanonicalContentScriptAsset(file);
+        if (parsed) return parsed.index;
+    }
+}
+function planDevContentScripts(manifest) {
+    if (3 !== manifest.manifest_version) return;
+    const groups = manifest.content_scripts;
+    if (!Array.isArray(groups) || 0 === groups.length) return;
+    const entries = [];
+    const stubs = {};
+    const nextGroups = groups.map((group)=>{
+        const index = canonicalIndexOf(group);
+        const matches = stringList(group.matches);
+        const js = stringList(group.js);
+        const css = stringList(group.css);
+        if (void 0 === index || 0 === matches.length) return group;
+        if (0 === js.length && 0 === css.length) return group;
+        const entryName = getCanonicalContentScriptEntryName(index);
+        const excludeMatches = stringList(group.exclude_matches);
+        if ('document_start' === group.run_at && 'MAIN' !== group.world) {
+            entries.push({
+                id: `${DEV_CONTENT_SCRIPT_ID_PREFIX}${index}`,
+                entry: entryName,
+                matches,
+                ...excludeMatches.length > 0 ? {
+                    excludeMatches
+                } : {},
+                js,
+                css,
+                runAt: 'document_start',
+                allFrames: true === group.all_frames,
+                world: 'ISOLATED',
+                stubOnly: false,
+                static: true
+            });
+            return group;
+        }
+        const stubOnly = stringList(group.include_globs).length > 0 || stringList(group.exclude_globs).length > 0;
+        const cssMarkerAsset = 0 === js.length ? devContentScriptCssMarkerAssetName(index) : void 0;
+        if (cssMarkerAsset) stubs[cssMarkerAsset] = buildDevContentScriptMarkerPrelude(entryName, cssMarkerAsset);
+        entries.push({
+            id: `${DEV_CONTENT_SCRIPT_ID_PREFIX}${index}`,
+            entry: entryName,
+            matches,
+            ...excludeMatches.length > 0 ? {
+                excludeMatches
+            } : {},
+            js: cssMarkerAsset ? [
+                cssMarkerAsset
+            ] : js,
+            css,
+            runAt: runAtOf(group.run_at),
+            allFrames: true === group.all_frames,
+            world: 'MAIN' === group.world ? 'MAIN' : 'ISOLATED',
+            ...true === group.match_origin_as_fallback ? {
+                matchOriginAsFallback: true
+            } : {},
+            stubOnly
+        });
+        const stubAsset = devContentScriptStubAssetName(index);
+        stubs[stubAsset] = buildDevContentScriptStubSource(entryName);
+        const { css: _css, world: _world, ...rest } = group;
+        return {
+            ...rest,
+            js: [
+                stubAsset
+            ]
+        };
+    });
+    if (0 === entries.length) return;
+    return {
+        manifest: {
+            ...manifest,
+            content_scripts: nextGroups
+        },
+        registry: {
+            version: 1,
+            entries
+        },
+        stubs
+    };
+}
+function buildDevContentScriptStubSource(entryName) {
+    return `;(function(){try{var c=globalThis.chrome;if(!c||!c.runtime||!c.runtime.sendMessage)return;c.runtime.sendMessage({${DEV_CONTENT_SCRIPT_STUB_MESSAGE_KEY}:{entry:${JSON.stringify(entryName)}}},function(){try{void c.runtime.lastError}catch(e){}})}catch(e){}})();\n`;
+}
+function buildDevContentScriptMarkerPrelude(entryName, assetName) {
+    return `;(function(){try{var g=globalThis,k=${JSON.stringify(DEV_CONTENT_SCRIPT_MARKER_KEY)};(g[k]=g[k]||{})[${JSON.stringify(entryName)}]=${JSON.stringify(assetName)}}catch(e){}})();\n`;
+}
+const DEV_CONTENT_SCRIPTS_RUNTIME_SOURCE = `;(function () {
+  try {
+    var g = (typeof globalThis !== "undefined" ? globalThis : self);
+    if (!g || g.__extjsDevContentScriptsInstalled) return;
+    var chrome = g.chrome;
+    if (!chrome || !chrome.runtime || !chrome.scripting || !chrome.tabs) return;
+    g.__extjsDevContentScriptsInstalled = true;
+
+    var REGISTRY = ${JSON.stringify(DEV_CONTENT_SCRIPT_REGISTRY_ASSET)};
+    var MARKER = ${JSON.stringify(DEV_CONTENT_SCRIPT_MARKER_KEY)};
+    var STUB = ${JSON.stringify(DEV_CONTENT_SCRIPT_STUB_MESSAGE_KEY)};
+    var ID_PREFIX = ${JSON.stringify(DEV_CONTENT_SCRIPT_ID_PREFIX)};
+    var STATIC_RELOAD_KEY = ${JSON.stringify(DEV_CONTENT_SCRIPT_STATIC_RELOAD_KEY)};
+    var STATIC_BUNDLES_KEY = ${JSON.stringify(DEV_CONTENT_SCRIPT_STATIC_BUNDLES_KEY)};
+    // The file a frame runs says nothing about which extension generation
+    // injected it, so every probe also stamps the booting worker's token.
+    var GENERATION_KEY = "generation";
+    var GENERATION = Math.random().toString(36).slice(2) + Date.now().toString(36);
+    var registry = null;
+    var ready = false;
+    var whenReady = [];
+
+    function noop() { try { void chrome.runtime.lastError; } catch (e) {
+      // Ignore
+    } }
+    function isString(v) { return typeof v === "string"; }
+    function injectableUrl(url) { return typeof url === "string" && /^(https?|file|ftp):/i.test(url); }
+    function call(fn) { if (fn) { try { fn(); } catch (e) {
+      // Ignore
+    } } }
+    function onReady(fn) { if (ready) call(fn); else whenReady.push(fn); }
+    function markReady() {
+      ready = true;
+      var fns = whenReady;
+      whenReady = [];
+      for (var i = 0; i < fns.length; i++) call(fns[i]);
+    }
+
+    // The registry is read FROM DISK every time: the bundles it names are
+    // content-hashed and the worker outlives many edits.
+    function load(cb) {
+      try {
+        if (typeof g.fetch !== "function") return cb(null);
+        g.fetch(chrome.runtime.getURL(REGISTRY), {cache: "no-store"})
+          .then(function (r) { return r && r.ok ? r.json() : null; })
+          .then(function (reg) { cb(reg && Array.isArray(reg.entries) ? reg : null); })
+          .catch(function () { cb(null); });
+      } catch (e) { cb(null); }
+    }
+
+    // Every field is sent: updateContentScripts keeps any key left out, so a
+    // dropped exclude_matches, css file or fallback would outlive the edit.
+    function registrationOf(e) {
+      return {
+        id: e.id,
+        matches: e.matches,
+        excludeMatches: Array.isArray(e.excludeMatches) ? e.excludeMatches.filter(isString) : [],
+        js: (e.js || []).filter(isString),
+        css: (e.css || []).filter(isString),
+        runAt: e.runAt === "document_start" || e.runAt === "document_end" ? e.runAt : "document_idle",
+        allFrames: !!e.allFrames,
+        world: e.world === "MAIN" ? "MAIN" : "ISOLATED",
+        matchOriginAsFallback: e.matchOriginAsFallback === true,
+        persistAcrossSessions: false
+      };
+    }
+
+    // Register what the registry names, update what is already registered,
+    // drop dev registrations it no longer names. Idempotent per entry id.
+    function sync(reg, done) {
+      try {
+        if (!chrome.scripting.registerContentScripts || !chrome.scripting.getRegisteredContentScripts) return call(done);
+        var wanted = [];
+        for (var i = 0; i < reg.entries.length; i++) {
+          var e = reg.entries[i] || {};
+          if (e.stubOnly || e.static || !isString(e.id) || !Array.isArray(e.matches) || !e.matches.length) continue;
+          var r = registrationOf(e);
+          if (!r.js.length && !r.css.length) continue;
+          wanted.push(r);
+        }
+        chrome.scripting.getRegisteredContentScripts(function (existing) {
+          noop();
+          var have = {};
+          if (existing) {
+            for (var k = 0; k < existing.length; k++) {
+              if (existing[k] && isString(existing[k].id)) have[existing[k].id] = true;
+            }
+          }
+          var toRegister = [], toUpdate = [], toDrop = [], keep = {};
+          for (var j = 0; j < wanted.length; j++) {
+            keep[wanted[j].id] = true;
+            (have[wanted[j].id] ? toUpdate : toRegister).push(wanted[j]);
+          }
+          for (var id in have) {
+            if (id.indexOf(ID_PREFIX) === 0 && !keep[id]) toDrop.push(id);
+          }
+          var ops = [];
+          if (toDrop.length && chrome.scripting.unregisterContentScripts) ops.push(["unregisterContentScripts", {ids: toDrop}]);
+          if (toUpdate.length && chrome.scripting.updateContentScripts) ops.push(["updateContentScripts", toUpdate]);
+          if (toRegister.length) ops.push(["registerContentScripts", toRegister]);
+          var pending = ops.length;
+          if (!pending) return call(done);
+          var step = function () { pending--; if (pending <= 0) call(done); };
+          for (var o = 0; o < ops.length; o++) {
+            try { chrome.scripting[ops[o][0]](ops[o][1], function () { noop(); step(); }); } catch (e) { step(); }
+          }
+        });
+      } catch (e) { call(done); }
+    }
+
+    // Inject one entry into the frames of a tab whose world does not already
+    // run the current file, or on a heal ran it for a previous extension
+    // generation. Chromium's own injection sets the same marker.
+    function inject(e, target, sameGeneration, done) {
+      var world = e.world === "MAIN" ? "MAIN" : "ISOLATED";
+      var js = (e.js || []).filter(isString), css = (e.css || []).filter(isString);
+      var probe = {target: target, world: world, injectImmediately: true,
+        args: [MARKER, GENERATION_KEY, e.entry, js[0] || "", GENERATION, !!sameGeneration],
+        func: function (key, genKey, entry, file, gen, needGen) {
+          try {
+            var g = globalThis, m = g[key] = g[key] || {}, gens = m[genKey] = m[genKey] || {};
+            var covered = m[entry] === file && (!needGen || gens[entry] === gen);
+            gens[entry] = gen;
+            return covered;
+          } catch (x) { return false; }
+        }};
+      try {
+        chrome.scripting.executeScript(probe, function (results) {
+          noop();
+          var frameIds = [];
+          if (results) {
+            for (var i = 0; i < results.length; i++) {
+              var r = results[i];
+              if (!r || r.result === true) continue;
+              frameIds.push(typeof r.frameId === "number" ? r.frameId : 0);
+            }
+          }
+          if (!frameIds.length) return call(done);
+          var into = {tabId: target.tabId, frameIds: frameIds};
+          if (css.length && chrome.scripting.insertCSS) {
+            try { chrome.scripting.insertCSS({target: into, files: css}, noop); } catch (x) {
+              // Ignore
+            }
+          }
+          if (!js.length) return call(done);
+          try {
+            chrome.scripting.executeScript({target: into, files: js, world: world, injectImmediately: true}, function () { noop(); call(done); });
+          } catch (x) { call(done); }
+        });
+      } catch (x) { call(done); }
+    }
+
+    // The open tabs an entry matches, exclude_matches honored, tabs still
+    // loading skipped when asked: Chromium injects those itself on landing.
+    function tabsFor(e, completeOnly, cb) {
+      var matches = Array.isArray(e.matches) ? e.matches : [];
+      if (!matches.length) return cb([]);
+      var excludes = Array.isArray(e.excludeMatches) ? e.excludeMatches : [];
+      var collect = function (excludedIds) {
+        try {
+          chrome.tabs.query({url: matches}, function (tabs) {
+            noop();
+            var out = [];
+            for (var i = 0; tabs && i < tabs.length; i++) {
+              var t = tabs[i];
+              if (!t || t.id == null || !injectableUrl(t.url) || excludedIds[t.id]) continue;
+              if (completeOnly && t.status === "loading") continue;
+              out.push(t);
+            }
+            cb(out);
+          });
+        } catch (x) { cb([]); }
+      };
+      if (!excludes.length) return collect({});
+      try {
+        chrome.tabs.query({url: excludes}, function (tabs) {
+          noop();
+          var ids = {};
+          for (var i = 0; tabs && i < tabs.length; i++) if (tabs[i] && tabs[i].id != null) ids[tabs[i].id] = true;
+          collect(ids);
+        });
+      } catch (x) { collect({}); }
+    }
+
+    function onStub(msg, sender) {
+      if (!msg || !isString(msg.entry) || !sender || !sender.tab || sender.tab.id == null) return;
+      var tabId = sender.tab.id;
+      var frameId = typeof sender.frameId === "number" ? sender.frameId : 0;
+      onReady(function () {
+        if (!registry) return;
+        for (var i = 0; i < registry.entries.length; i++) {
+          var e = registry.entries[i];
+          if (e && !e.static && e.entry === msg.entry) inject(e, {tabId: tabId, frameIds: [frameId]}, false);
+        }
+      });
+    }
+
+    // After a worker restart the open tabs still run the previous generation,
+    // and Chromium never injects into a tab that finished loading before it.
+    function heal(done) {
+      onReady(function () {
+        if (!registry) return call(done);
+        var pending = 1;
+        var step = function () { pending--; if (pending <= 0) call(done); };
+        for (var i = 0; i < registry.entries.length; i++) {
+          (function (e) {
+            if (!e || e.stubOnly || e.static) return;
+            pending++;
+            tabsFor(e, true, function (tabs) {
+              var left = tabs.length;
+              if (!left) return step();
+              for (var t = 0; t < tabs.length; t++) {
+                inject(e, {tabId: tabs[t].id, allFrames: !!e.allFrames}, true, function () { if (--left === 0) step(); });
+              }
+            });
+          })(registry.entries[i]);
+        }
+        step();
+      });
+    }
+
+    // Reload every tab the given entries match, each once.
+    function reloadTabs(entries, done) {
+      var seen = {};
+      var pending = 1;
+      var step = function () { pending--; if (pending <= 0) call(done); };
+      for (var i = 0; i < entries.length; i++) {
+        pending++;
+        tabsFor(entries[i], false, function (tabs) {
+          for (var t = 0; t < tabs.length; t++) {
+            var id = tabs[t].id;
+            if (seen[id]) continue;
+            seen[id] = true;
+            try { chrome.tabs.reload(id, {}, noop); } catch (x) {
+              // Ignore
+            }
+          }
+          step();
+        });
+      }
+      step();
+    }
+
+    // Only an extension reload ships a static entry's edit. The next generation
+    // reloads the tabs it matches, and the producer's flag heals the rest.
+    function reloadExtensionFor(entries) {
+      var names = [];
+      for (var i = 0; i < entries.length; i++) names.push(entries[i].entry);
+      try {
+        if (chrome.storage && chrome.storage.local) {
+          var flags = {__extjsDevPendingReinject: Date.now()};
+          flags[STATIC_RELOAD_KEY] = {entries: names, at: Date.now()};
+          chrome.storage.local.set(flags, noop);
+        }
+      } catch (e) {
+        // Ignore
+      }
+      setTimeout(function () { try { chrome.runtime.reload(); } catch (e) {
+        // Ignore
+      } }, 150);
+    }
+
+    function staticBundlesOf(e) {
+      return (e.js || []).filter(isString).concat((e.css || []).filter(isString)).join("\\n");
+    }
+
+    // The static entries' hashed bundle names, as recorded by the previous
+    // generation: a service worker reload ships a shared module's edit to a
+    // static entry too, and nothing but the name says its tabs are stale.
+    function healStaticEntries() {
+      try {
+        if (!chrome.storage || !chrome.storage.local) return;
+        chrome.storage.local.get([STATIC_RELOAD_KEY, STATIC_BUNDLES_KEY], function (res) {
+          noop();
+          var flag = res && res[STATIC_RELOAD_KEY];
+          var recorded = res && res[STATIC_BUNDLES_KEY];
+          if (flag) {
+            try { chrome.storage.local.remove(STATIC_RELOAD_KEY, noop); } catch (e) {
+              // Ignore
+            }
+          }
+          var flagged = flag && typeof flag.at === "number" && Date.now() - flag.at <= 30000 && Array.isArray(flag.entries) ? flag.entries : [];
+          var known = recorded && typeof recorded === "object" ? recorded : null;
+          onReady(function () {
+            if (!registry) return;
+            var entries = [];
+            var current = {};
+            for (var i = 0; i < registry.entries.length; i++) {
+              var e = registry.entries[i];
+              if (!e || !e.static || !isString(e.entry)) continue;
+              current[e.entry] = staticBundlesOf(e);
+              var changed = known && isString(known[e.entry]) && known[e.entry] !== current[e.entry];
+              if (changed || flagged.indexOf(e.entry) !== -1) entries.push(e);
+            }
+            try {
+              var record = {};
+              record[STATIC_BUNDLES_KEY] = current;
+              chrome.storage.local.set(record, noop);
+            } catch (e) {
+              // Ignore
+            }
+            if (entries.length) reloadTabs(entries);
+          });
+        });
+      } catch (e) {
+        // Ignore
+      }
+    }
+
+    // A content script edit: re-register at the new files and reload the tabs
+    // the edited entries match, or the extension when a static one is edited.
+    function reload(names, done) {
+      load(function (reg) {
+        if (!reg) return call(function () { done(false); });
+        registry = reg;
+        var wanted = Array.isArray(names) && names.length ? names : null;
+        var edited = [], statics = [];
+        for (var i = 0; i < reg.entries.length; i++) {
+          var e = reg.entries[i];
+          if (!e || (wanted && wanted.indexOf(e.entry) === -1)) continue;
+          (e.static ? statics : edited).push(e);
+        }
+        if (statics.length) {
+          reloadExtensionFor(statics);
+          return call(function () { done(true); });
+        }
+        sync(reg, function () {
+          markReady();
+          reloadTabs(edited, function () { done(true); });
+        });
+      });
+    }
+
+    try {
+      chrome.runtime.onMessage.addListener(function (msg, sender) {
+        if (!msg || !msg[STUB]) return;
+        onStub(msg[STUB], sender);
+      });
+    } catch (e) {
+      // Ignore
+    }
+
+    g.__extjsDevContentScripts = {heal: heal, reload: reload, isReady: function () { return ready; }};
+
+    load(function (reg) {
+      registry = reg;
+      if (!reg) return markReady();
+      sync(reg, markReady);
+    });
+    healStaticEntries();
+  } catch (e) {
+    // Ignore
+  }
+})();
+`;
 function formatReloadContextLabel(context, files) {
     if (!files.length) return context;
     const shown = files.slice(0, 2).join(', ');
@@ -3338,14 +4455,14 @@ function classifyReloadFromSources(opts) {
         changedAssets: changedSources,
         label: formatReloadContextLabel('extension', changedSources)
     });
-    if (contentChanged.length > 0) return withScripts({
+    if (contentChanged.length > 0) return withScripts(withStaticEntries({
         type: "content-scripts",
         changedContentScriptEntries: [
             ...contentEntries
         ].sort(),
         changedAssets: changedSources,
         label: formatReloadContextLabel("content_script", contentChanged)
-    });
+    }, outputPath));
     if (pageChanged.length > 0 && 0 === unknown.length) return withScripts({
         type: 'page',
         changedAssets: changedSources,
@@ -3361,12 +4478,12 @@ function classifyReloadFromSources(opts) {
     if (contentScriptCount > 0) {
         const entries = [];
         for(let i = 0; i < contentScriptCount; i++)entries.push(getCanonicalContentScriptEntryName(i));
-        return withScripts({
+        return withScripts(withStaticEntries({
             type: "content-scripts",
             changedContentScriptEntries: entries,
             changedAssets: changedSources,
             label: formatReloadContextLabel("content_script", changedSources)
-        });
+        }, outputPath));
     }
     return withScripts({
         type: 'page',
@@ -3374,6 +4491,23 @@ function classifyReloadFromSources(opts) {
         label: formatReloadContextLabel(pageContextFromSources(changedSources), changedSources)
     });
 }
+function readStaticContentScriptEntries(outputPath) {
+    if (!outputPath) return [];
+    try {
+        const registry = JSON.parse(stripBom(__rspack_external_node_fs_1b05aee1.readFileSync(__rspack_external_node_path_806ed179.join(outputPath, DEV_CONTENT_SCRIPT_REGISTRY_ASSET), 'utf8')));
+        return (registry?.entries || []).filter((entry)=>entry?.static === true && 'string' == typeof entry.entry).map((entry)=>entry.entry);
+    } catch  {
+        return [];
+    }
+}
+function withStaticEntries(instruction, outputPath) {
+    const changed = new Set(instruction.changedContentScriptEntries || []);
+    const statics = readStaticContentScriptEntries(outputPath).filter((entry)=>changed.has(entry));
+    return statics.length > 0 ? {
+        ...instruction,
+        staticContentScriptEntries: statics
+    } : instruction;
+}
 function readContentScriptCount(compilation, outputPath) {
     try {
         const asset = compilation.getAsset?.('manifest.json');
@@ -3434,7 +4568,7 @@ class BrowsersPlugin {
             return false;
         }
         if ('loaded' === outcome.status) {
-            console.log(extensionLoadRecovered());
+            humanLine(extensionLoadRecovered());
             return true;
         }
         if ('refused' === outcome.status && outcome.reason && outcome.reason !== this.lastReportedRefusal) {
@@ -3668,8 +4802,8 @@ async function extensionDev(pathOrRemoteUrl, devOptions) {
         const browser = normalizeBrowser(devOptions.browser || configBrowser || 'chrome', devOptions.chromiumBinary, devOptions.geckoBinary || devOptions.firefoxBinary, devOptions.safariBinary);
         const geckoBinary = devOptions.geckoBinary || devOptions.firefoxBinary;
         if (debug) {
-            console.log(debugDirs(manifestDir, packageJsonDir));
-            console.log(debugBrowser(browser, devOptions.chromiumBinary, geckoBinary));
+            debugLine(debugDirs(manifestDir, packageJsonDir));
+            debugLine(debugBrowser(browser, devOptions.chromiumBinary, geckoBinary));
         }
         const projectConfig = await loadProjectConfigDefaults(packageJsonDir);
         const browserConfig = await loadBrowserConfig(packageJsonDir, browser);
@@ -3694,6 +4828,7 @@ async function extensionDev(pathOrRemoteUrl, devOptions) {
                     enableDevtools: true,
                     noOpen: merged.noOpen,
                     profile: merged.profile,
+                    profileSource: falseProfileSource(merged.profile, devOptions.profile),
                     persistProfile: merged.persistProfile,
                     keepProfileChanges: merged.keepProfileChanges,
                     copyFromProfile: merged.copyFromProfile,
@@ -3733,4 +4868,4 @@ async function extensionDev(pathOrRemoteUrl, devOptions) {
         process.exit(1);
     }
 }
-export { BuildEmitter, ConfigResolvedPlugin, NOT_RAW_RESOURCE_QUERY, RAW_RESOURCE_QUERY, applySplitChunksGuard, buildSourceFeatureIndex, classifyEntrySurface, classifyReloadFromSources, createChangedSourcesTracker, createNodeModulesExclude, defaultSplitChunks, dispatchReload, ensureOptionalContractPackageResolved, ensureTypeScriptConfig, extensionBuild, extensionDev, getJsxImportSource, getUserTypeScriptConfigFile, hasDependency, isSubPath, isUsingIntegration, isUsingJsxFramework, isUsingReact, isUsingTypeScript, isUsingVue, jsFrameworksConfigsDetected, jsFrameworksHmrSummary, jsFrameworksIntegrationsEnabled, loadLoaderOptions, maybeUsePreact, maybeUseReact, maybeUseSolid, maybeUseVue, mergeLoaderOptions, readContentScriptCount, recordZipArtifact, recordZipFailure, resolveDevelopDistFile, resolveDevelopInstallRoot, resolveReactRefreshEntry, resolveTranspilePackageDirs, svelteCompilerRuntimeMismatch, swcParserForFile };
+export { BuildEmitter, ConfigResolvedPlugin, DEV_CONTENT_SCRIPTS_RUNTIME_SOURCE, DEV_CONTENT_SCRIPT_REGISTRY_ASSET, NOT_RAW_RESOURCE_QUERY, RAW_RESOURCE_QUERY, applySplitChunksGuard, attachLifecycleStream, backgroundIsRequiredMessageOnly, buildDevContentScriptMarkerPrelude, buildSourceFeatureIndex, classifyEntrySurface, classifyReloadFromSources, contentScriptEntryForAsset, createChangedSourcesTracker, createLifecycleStream, createNodeModulesExclude, defaultSplitChunks, dispatchReload, ensureOptionalContractPackageResolved, ensureTypeScriptConfig, extensionBuild, extensionDev, getJsxImportSource, getUserTypeScriptConfigFile, hasDependency, isDevContentScriptStandInAsset, isUsingIntegration, isUsingJsxFramework, isUsingReact, isUsingTypeScript, isUsingVue, jsFrameworksConfigsDetected, jsFrameworksHmrSummary, jsFrameworksIntegrationsEnabled, loadLoaderOptions, maybeUsePreact, maybeUseReact, maybeUseSolid, maybeUseVue, mergeLoaderOptions, planDevContentScripts, readContentScriptCount, recordZipArtifact, recordZipFailure, resolveDevelopDistFile, resolveDevelopInstallRoot, resolveReactRefreshEntry, resolveTranspilePackageDirs, svelteCompilerRuntimeMismatch, swcParserForFile };