extension-develop 3.10.3 → 3.10.4-canary.1

package/dist/{270.cjs → 677.cjs}

@@ -3,7 +3,7 @@ const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
     return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
 }();
 exports.ids = [
-    "270"
+    "677"
 ];
 exports.modules = {
     "./webpack/dev-server/compiler-hooks.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -794,9 +794,11 @@ exports.modules = {
                 }
             };
         }
+        var contracts = __webpack_require__("./webpack/plugin-web-extension/feature-scripts/contracts.ts");
         function isBundledContentPath(filePath, ext) {
             const normalized = String(filePath || '').replace(/\\/g, '/');
-            return new RegExp(`^content_scripts/content-\\d+\\.${ext}$`).test(normalized);
+            const bundledAsset = (0, contracts.es)(normalized);
+            return bundledAsset?.extension === ext;
         }
         function isAlreadyBundledContentScripts(contentScripts) {
             if (!Array.isArray(contentScripts) || 0 === contentScripts.length) return false;
@@ -829,7 +831,7 @@ exports.modules = {
                     result.push({
                         ...rest,
                         js: [
-                            getFilename(`content_scripts/content-${bridgeIndex}.js`, 'main-world-bridge.js')
+                            getFilename((0, contracts.f6)(bridgeIndex), 'main-world-bridge.js')
                         ],
                         css: []
                     });
@@ -837,10 +839,10 @@ exports.modules = {
                 result.push({
                     ...original[index] || {},
                     js: [
-                        ...new Set(contentJs.map((js)=>getFilename(`content_scripts/content-${index}.js`, js)))
+                        ...new Set(contentJs.map((js)=>getFilename((0, contracts.f6)(index), js)))
                     ],
                     css: [
-                        ...new Set(contentCss.map((css)=>getFilename(`content_scripts/content-${index}.css`, css)))
+                        ...new Set(contentCss.map((css)=>getFilename((0, contracts.J4)(index), css)))
                     ]
                 });
             }
@@ -1455,7 +1457,14 @@ exports.modules = {
                     const manifestName = boring_readJsonFileSafe(this.manifestPath).name;
                     const line = boring(manifestName, duration, stats);
                     try {
-                        const modifiedFiles = Array.from(stats?.compilation?.modifiedFiles || []).map((file)=>String(file).replace(/\\/g, '/'));
+                        const fromCompilation = Array.from(stats?.compilation?.modifiedFiles || []);
+                        const fromCompiler = Array.from(compiler.modifiedFiles ?? []);
+                        const modifiedFiles = [
+                            ...new Set([
+                                ...fromCompilation,
+                                ...fromCompiler
+                            ])
+                        ].map((file)=>String(file).replace(/\\/g, '/'));
                         if (!this.sawUserInvalidation && modifiedFiles.length > 0) {
                             const context = String(compiler?.options?.context || '').replace(/\\/g, '/');
                             const hasUserFileChange = modifiedFiles.some((file)=>{
@@ -1576,7 +1585,7 @@ exports.modules = {
         }
         plugin_compilation_define_property(CompilationPlugin, "name", 'plugin-compilation');
         var css_lib_messages = __webpack_require__("./webpack/plugin-css/css-lib/messages.ts");
-        var optional_deps_lib = __webpack_require__("./webpack/optional-deps-lib/index.ts");
+        var external_optional_deps_lib_ = __webpack_require__("optional-deps-lib");
         var sass = __webpack_require__("./webpack/plugin-css/css-tools/sass.ts");
         var less = __webpack_require__("./webpack/plugin-css/css-tools/less.ts");
         function getStylelintConfigFile(projectPath) {
@@ -1688,7 +1697,12 @@ exports.modules = {
                     test,
                     exclude,
                     type,
-                    issuer: isContentScript
+                    issuer: isContentScript,
+                    resourceQuery: {
+                        not: [
+                            /url/
+                        ]
+                    }
                 };
                 if ('asset' === type) baseConfig.generator = {
                     filename: "content_scripts/[name].[contenthash:8].css"
@@ -1763,7 +1777,12 @@ exports.modules = {
                     test,
                     exclude,
                     type,
-                    issuer: isNotContentScript
+                    issuer: isNotContentScript,
+                    resourceQuery: {
+                        not: [
+                            /url/
+                        ]
+                    }
                 };
                 if (!loader) return {
                     ...baseConfig,
@@ -1801,8 +1820,8 @@ exports.modules = {
                 const projectPath = compiler.options.context || process.cwd();
                 const plugins = [];
                 const manifestPath = this.manifestPath;
-                const usingSass = (0, optional_deps_lib.ws)(projectPath, 'sass');
-                const usingLess = (0, optional_deps_lib.ws)(projectPath, 'less');
+                const usingSass = (0, external_optional_deps_lib_.hasDependency)(projectPath, 'sass');
+                const usingLess = (0, external_optional_deps_lib_.hasDependency)(projectPath, 'less');
                 const maybeInstallStylelint = await maybeUseStylelint(projectPath);
                 plugins.push(...maybeInstallStylelint);
                 const maybeInstallSass = await (0, sass.IZ)(projectPath);
@@ -1845,8 +1864,8 @@ exports.modules = {
                 ].filter(Boolean);
                 if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
                     const integrations = [];
-                    const usingTailwind = (0, optional_deps_lib.ws)(projectPath, 'tailwindcss');
-                    const usingPostcss = (0, optional_deps_lib.ws)(projectPath, 'postcss') || void 0 !== findPostCssConfig(projectPath) || usingSass || usingLess || usingTailwind;
+                    const usingTailwind = (0, external_optional_deps_lib_.hasDependency)(projectPath, 'tailwindcss');
+                    const usingPostcss = (0, external_optional_deps_lib_.hasDependency)(projectPath, 'postcss') || void 0 !== findPostCssConfig(projectPath) || usingSass || usingLess || usingTailwind;
                     if (usingPostcss) integrations.push('PostCSS');
                     if (usingSass) integrations.push('Sass');
                     if (usingLess) integrations.push('Less');
@@ -2111,19 +2130,61 @@ exports.modules = {
                 };
                 return merged;
             }
+            patchReactRefreshRules(rules) {
+                for (const rule of rules){
+                    if (!rule || 'object' != typeof rule) continue;
+                    const uses = Array.isArray(rule.use) ? rule.use : rule.use ? [
+                        rule.use
+                    ] : rule.loader ? [
+                        {
+                            loader: rule.loader
+                        }
+                    ] : [];
+                    const hasReactRefreshLoader = uses.some((useEntry)=>String(useEntry?.loader || '').includes('react-refresh-loader'));
+                    if (hasReactRefreshLoader) rule.issuerLayer = {
+                        not: contracts.$t
+                    };
+                    if (Array.isArray(rule.oneOf)) this.patchReactRefreshRules(rule.oneOf);
+                    if (Array.isArray(rule.rules)) this.patchReactRefreshRules(rule.rules);
+                }
+            }
             async configureOptions(compiler) {
                 const mode = compiler.options.mode || 'development';
                 const projectPath = compiler.options.context;
+                const manifestDir = external_path_.dirname(this.manifestPath);
+                const swcIncludeDirs = Array.from(new Set([
+                    projectPath,
+                    manifestDir,
+                    ...resolveTranspilePackageDirs(projectPath, this.transpilePackages)
+                ]));
+                const contentScriptLikePaths = new Set();
+                const scriptsDir = external_path_.resolve(projectPath, "scripts");
+                const isfeatureScriptsContentLike = (resourcePath)=>{
+                    const normalized = external_path_.normalize(resourcePath);
+                    if (contentScriptLikePaths.has(normalized)) return true;
+                    const relToScripts = external_path_.relative(scriptsDir, normalized);
+                    return !!relToScripts && !relToScripts.startsWith('..') && !external_path_.isAbsolute(relToScripts);
+                };
                 const devtool = compiler.options.devtool;
                 const wantsSourceMaps = false !== devtool && ('development' === mode || null != devtool);
-                const maybeInstallReact = await (0, react.b)(projectPath);
+                try {
+                    const manifest = JSON.parse(external_fs_.readFileSync(this.manifestPath, 'utf-8'));
+                    const contentScripts = Array.isArray(manifest?.content_scripts) ? manifest.content_scripts : [];
+                    for (const contentScript of contentScripts){
+                        const jsList = Array.isArray(contentScript?.js) ? contentScript.js : [];
+                        for (const jsFile of jsList)contentScriptLikePaths.add(external_path_.resolve(manifestDir, jsFile));
+                    }
+                } catch  {}
+                const maybeInstallReact = await (0, react.b)(projectPath, {
+                    disableRefresh: true,
+                    refreshExclude: (resourcePath)=>isfeatureScriptsContentLike(resourcePath)
+                });
                 const maybeInstallPreact = await (0, preact.b)(projectPath);
                 const maybeInstallVue = await (0, vue.K)(projectPath, mode);
                 const maybeInstallSvelte = await (0, svelte.X)(projectPath, mode);
                 const tsConfigPath = (0, typescript.hB)(projectPath);
-                const manifestDir = external_path_.dirname(this.manifestPath);
                 const tsRoot = tsConfigPath ? external_path_.dirname(tsConfigPath) : manifestDir;
-                const transpilePackageDirs = resolveTranspilePackageDirs(projectPath, this.transpilePackages);
+                const transpilePackageDirs = swcIncludeDirs.filter((dir)=>dir !== projectPath && dir !== manifestDir);
                 const preferTypeScript = !!tsConfigPath || (0, typescript.eE)(projectPath);
                 let targets = [
                     'chrome >= 100'
@@ -2163,59 +2224,131 @@ exports.modules = {
                         vueLoadersToAdd = [];
                     }
                 }
-                compiler.options.module.rules = [
+                const swcRuleBase = {
+                    test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
+                    include: Array.from(new Set([
+                        tsRoot,
+                        ...swcIncludeDirs
+                    ])),
+                    exclude: [
+                        (resourcePath)=>{
+                            const isInNodeModules = /[\\/]node_modules[\\/]/.test(resourcePath);
+                            if (!isInNodeModules) return false;
+                            return !transpilePackageDirs.some((dir)=>isSubPath(resourcePath, dir));
+                        }
+                    ]
+                };
+                const swcLoaderBase = {
+                    loader: 'builtin:swc-loader',
+                    options: {
+                        sync: true,
+                        module: {
+                            type: 'es6'
+                        },
+                        minify: false,
+                        isModule: true,
+                        sourceMap: wantsSourceMaps,
+                        env: {
+                            targets
+                        },
+                        jsc: {
+                            parser: {
+                                syntax: preferTypeScript ? "typescript" : "ecmascript",
+                                tsx: preferTypeScript ? true : (0, typescript.eE)(projectPath) && ((0, react.S)(projectPath) || (0, preact.K)(projectPath)),
+                                jsx: !preferTypeScript && ((0, react.S)(projectPath) || (0, preact.K)(projectPath)),
+                                dynamicImport: true
+                            },
+                            transform: {
+                                react: {
+                                    development: 'development' === mode,
+                                    runtime: 'automatic',
+                                    importSource: 'react',
+                                    ...(0, preact.K)(projectPath) ? {
+                                        pragma: 'h',
+                                        pragmaFrag: 'Fragment',
+                                        throwIfNamespace: true,
+                                        useBuiltins: false
+                                    } : {}
+                                }
+                            }
+                        }
+                    }
+                };
+                const swcRules = [
                     {
-                        test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
-                        include: Array.from(new Set([
-                            tsRoot,
-                            manifestDir,
-                            ...transpilePackageDirs
-                        ])),
-                        exclude: [
-                            (resourcePath)=>{
-                                const isInNodeModules = /[\\/]node_modules[\\/]/.test(resourcePath);
-                                if (!isInNodeModules) return false;
-                                return !transpilePackageDirs.some((dir)=>isSubPath(resourcePath, dir));
+                        ...swcRuleBase,
+                        layer: contracts.$t,
+                        include: (resourcePath)=>Array.from(new Set([
+                                tsRoot,
+                                ...swcIncludeDirs
+                            ])).some((dir)=>isSubPath(resourcePath, dir)) && isfeatureScriptsContentLike(resourcePath),
+                        use: {
+                            ...swcLoaderBase,
+                            options: {
+                                ...swcLoaderBase.options,
+                                jsc: {
+                                    ...swcLoaderBase.options.jsc,
+                                    transform: {
+                                        ...swcLoaderBase.options.jsc.transform,
+                                        react: {
+                                            ...swcLoaderBase.options.jsc.transform.react,
+                                            refresh: false
+                                        }
+                                    }
+                                }
                             }
-                        ],
+                        }
+                    },
+                    {
+                        ...swcRuleBase,
+                        issuerLayer: contracts.$t,
+                        layer: contracts.$t,
                         use: {
-                            loader: 'builtin:swc-loader',
+                            ...swcLoaderBase,
                             options: {
-                                sync: true,
-                                module: {
-                                    type: 'es6'
-                                },
-                                minify: false,
-                                isModule: true,
-                                sourceMap: wantsSourceMaps,
-                                env: {
-                                    targets
-                                },
+                                ...swcLoaderBase.options,
                                 jsc: {
-                                    parser: {
-                                        syntax: preferTypeScript ? "typescript" : "ecmascript",
-                                        tsx: preferTypeScript ? true : (0, typescript.eE)(projectPath) && ((0, react.S)(projectPath) || (0, preact.K)(projectPath)),
-                                        jsx: !preferTypeScript && ((0, react.S)(projectPath) || (0, preact.K)(projectPath)),
-                                        dynamicImport: true
-                                    },
+                                    ...swcLoaderBase.options.jsc,
                                     transform: {
+                                        ...swcLoaderBase.options.jsc.transform,
                                         react: {
-                                            development: 'development' === mode,
-                                            refresh: 'development' === mode,
-                                            runtime: 'automatic',
-                                            importSource: 'react',
-                                            ...(0, preact.K)(projectPath) ? {
-                                                pragma: 'h',
-                                                pragmaFrag: 'Fragment',
-                                                throwIfNamespace: true,
-                                                useBuiltins: false
-                                            } : {}
+                                            ...swcLoaderBase.options.jsc.transform.react,
+                                            refresh: false
                                         }
                                     }
                                 }
                             }
                         }
                     },
+                    {
+                        ...swcRuleBase,
+                        issuerLayer: {
+                            not: contracts.$t
+                        },
+                        exclude: [
+                            ...swcRuleBase.exclude,
+                            (resourcePath)=>isfeatureScriptsContentLike(resourcePath)
+                        ],
+                        use: {
+                            ...swcLoaderBase,
+                            options: {
+                                ...swcLoaderBase.options,
+                                jsc: {
+                                    ...swcLoaderBase.options.jsc,
+                                    transform: {
+                                        ...swcLoaderBase.options.jsc.transform,
+                                        react: {
+                                            ...swcLoaderBase.options.jsc.transform.react,
+                                            refresh: 'development' === mode
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ];
+                compiler.options.module.rules = [
+                    ...swcRules,
                     ...maybeInstallReact?.loaders || [],
                     ...maybeInstallPreact?.loaders || [],
                     ...vueLoadersToAdd,
@@ -2226,6 +2359,7 @@ exports.modules = {
                 maybeInstallPreact?.plugins?.forEach((plugin)=>plugin.apply(compiler));
                 maybeInstallVue?.plugins?.forEach((plugin)=>plugin.apply(compiler));
                 maybeInstallSvelte?.plugins?.forEach((plugin)=>plugin.apply(compiler));
+                this.patchReactRefreshRules(compiler.options.module.rules);
                 if ((0, typescript.eE)(projectPath) || !!tsConfigPath) compiler.options.resolve.tsConfig = {
                     configFile: tsConfigPath
                 };
@@ -2347,6 +2481,67 @@ exports.modules = {
                 this.manifestPath = options.manifestPath;
             }
         }
+        function patchDevContentScriptManifestPaths(compilation, manifest) {
+            if ('development' !== compilation.options.mode) return manifest;
+            const cs = manifest.content_scripts;
+            if (!Array.isArray(cs)) return manifest;
+            const assetNames = new Set((compilation.getAssets?.() || []).map((a)=>a.name || '').filter(Boolean));
+            const currentHashedNames = new Set();
+            const next = cs.map((group, groupIndex)=>{
+                const js = Array.isArray(group.js) ? [
+                    ...group.js
+                ] : [];
+                const css = Array.isArray(group.css) ? [
+                    ...group.css
+                ] : [];
+                const resolvedJs = js.map((p)=>resolveDevContentScriptDeclaredPath(p, groupIndex, 'js', assetNames));
+                const resolvedCss = css.map((p)=>resolveDevContentScriptDeclaredPath(p, groupIndex, 'css', assetNames));
+                for (const n of [
+                    ...resolvedJs,
+                    ...resolvedCss
+                ])currentHashedNames.add(n);
+                return {
+                    ...group,
+                    js: resolvedJs,
+                    css: resolvedCss
+                };
+            });
+            purgeStaleHashedContentScripts(compilation, currentHashedNames);
+            return {
+                ...manifest,
+                content_scripts: next
+            };
+        }
+        function resolveDevContentScriptDeclaredPath(declaredPath, groupIndex, ext, assetNames) {
+            const canonical = 'js' === ext ? (0, contracts.f6)(groupIndex) : (0, contracts.J4)(groupIndex);
+            if (declaredPath !== canonical) return declaredPath;
+            const hashed = findHashedContentScriptAsset(assetNames, groupIndex, ext);
+            return hashed || declaredPath;
+        }
+        function findHashedContentScriptAsset(assetNames, groupIndex, ext) {
+            const plain = `content_scripts/content-${groupIndex}.${ext}`;
+            if (assetNames.has(plain)) return plain;
+            const re = new RegExp(`^content_scripts/content-${groupIndex}\\.[a-f0-9]+\\.${ext}$`, 'i');
+            for (const name of assetNames)if (re.test(name)) return name;
+        }
+        function purgeStaleHashedContentScripts(compilation, currentNames) {
+            const outputPath = compilation.options.output?.path;
+            if (!outputPath) return;
+            const csDir = external_path_.join(outputPath, "content_scripts");
+            if (!external_fs_.existsSync(csDir)) return;
+            const hashedRe = /^content-\d+\.[a-f0-9]+\.(js|css)(\.map)?$/i;
+            try {
+                for (const name of external_fs_.readdirSync(csDir)){
+                    if (!hashedRe.test(name)) continue;
+                    const rel = `content_scripts/${name}`;
+                    if (!currentNames.has(rel)) {
+                        if (!currentNames.has(rel.replace(/\.map$/, ''))) try {
+                            external_fs_.unlinkSync(external_path_.join(csDir, name));
+                        } catch  {}
+                    }
+                }
+            } catch  {}
+        }
         function update_manifest_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -2375,8 +2570,9 @@ exports.modules = {
                     }, ()=>{
                         if (compilation.errors.length > 0) return;
                         const manifest = getManifestContent(compilation, this.manifestPath);
-                        const patchedManifest = buildCanonicalManifest(this.manifestPath, manifest, this.browser);
+                        let patchedManifest = buildCanonicalManifest(this.manifestPath, manifest, this.browser);
                         const overrides = getManifestOverrides(this.manifestPath, manifest);
+                        if ('development' === compiler.options.mode) patchedManifest = patchDevContentScriptManifestPaths(compilation, patchedManifest);
                         if ('development' === compiler.options.mode) {
                             if (patchedManifest.content_scripts) patchedManifest.content_scripts = this.applyDevOverrides(patchedManifest);
                         }
@@ -2822,17 +3018,17 @@ exports.modules = {
                     for (const r of fontAssets)if (!webAccessibleResourcesV2.includes(r)) webAccessibleResourcesV2.push(r);
                 }
             }
+            const assetKeys = Object.keys(compilation.assets || {});
+            const cssUnderContentScripts = assetKeys.filter((k)=>k.startsWith("content_scripts/")).filter((k)=>k.endsWith('.css')).sort();
+            if (Array.isArray(canonicalManifest.content_scripts)) for (const contentScript of canonicalManifest.content_scripts){
+                const jsFiles = Array.isArray(contentScript.js) ? contentScript.js : [];
+                const canonicalCss = jsFiles.map(toCanonicalContentScriptCss).filter((resource)=>Boolean(resource && cssUnderContentScripts.includes(resource)));
+                if (canonicalCss.length > 0) contentScript.css = Array.from(new Set([
+                    ...contentScript.css || [],
+                    ...canonicalCss
+                ])).sort();
+            }
             if (3 === canonicalManifest.manifest_version) {
-                const assetKeys = Object.keys(compilation.assets || {});
-                const cssUnderContentScripts = assetKeys.filter((k)=>k.startsWith("content_scripts/")).filter((k)=>k.endsWith('.css')).sort();
-                if (Array.isArray(canonicalManifest.content_scripts)) for (const contentScript of canonicalManifest.content_scripts){
-                    const jsFiles = Array.isArray(contentScript.js) ? contentScript.js : [];
-                    const canonicalCss = jsFiles.map(toCanonicalContentScriptCss).filter((resource)=>Boolean(resource && cssUnderContentScripts.includes(resource)));
-                    if (canonicalCss.length > 0) contentScript.css = Array.from(new Set([
-                        ...contentScript.css || [],
-                        ...canonicalCss
-                    ])).sort();
-                }
                 if (cssUnderContentScripts.length > 0) {
                     const allMatches = Array.from(new Set((canonicalManifest.content_scripts || []).flatMap((cs)=>cs.matches || [])));
                     const normalizedMatches = cleanMatches(allMatches);
@@ -2860,6 +3056,8 @@ exports.modules = {
                         });
                     }
                 }
+            } else if (2 === canonicalManifest.manifest_version) {
+                for (const resource of cssUnderContentScripts)if (!webAccessibleResourcesV2.includes(resource)) webAccessibleResourcesV2.push(resource);
             }
             if (3 === canonicalManifest.manifest_version) {
                 if (webAccessibleResourcesV3.length > 0) canonicalManifest.web_accessible_resources = webAccessibleResourcesV3.map((entry)=>({
@@ -3136,6 +3334,7 @@ exports.modules = {
                                 permissions: [
                                     ...new Set([
                                         "scripting",
+                                        'tabs',
                                         'management',
                                         ...canonicalManifest.permissions || []
                                     ])
@@ -3143,6 +3342,7 @@ exports.modules = {
                             } : {
                                 permissions: [
                                     "scripting",
+                                    'tabs',
                                     'management'
                                 ]
                             } : {},
@@ -4240,6 +4440,51 @@ exports.modules = {
                 this.browser = options.browser;
             }
         }
+        function normalizeBoolean(value, fallback) {
+            return String('boolean' == typeof value ? value : fallback);
+        }
+        function normalizeHotValue(value) {
+            if ('only' === value) return 'only';
+            if ('boolean' == typeof value) return String(value);
+            return 'true';
+        }
+        function getDevServerHmrImports(compiler) {
+            const devServer = compiler.options?.devServer;
+            const envHost = process.env.EXTENSION_DEV_SERVER_HOST;
+            const envPort = process.env.EXTENSION_DEV_SERVER_PORT;
+            const envPath = process.env.EXTENSION_DEV_SERVER_PATH;
+            const envProtocol = process.env.EXTENSION_DEV_SERVER_PROTOCOL;
+            if (!devServer && !envHost && !envPort) return [];
+            const clientConfig = devServer?.client && 'object' == typeof devServer.client ? devServer.client : {};
+            const webSocketURL = clientConfig.webSocketURL && 'object' == typeof clientConfig.webSocketURL ? clientConfig.webSocketURL : {};
+            const protocol = String(webSocketURL.protocol || envProtocol || 'ws');
+            const hostname = String(webSocketURL.hostname || devServer?.host || envHost || '127.0.0.1');
+            const port = webSocketURL.port ?? devServer?.port ?? envPort ?? process.env.EXTENSION_PUBLIC_PORT ?? 8080;
+            const pathname = String(webSocketURL.pathname || envPath || '/ws');
+            const logging = String(clientConfig.logging || 'none');
+            const progress = normalizeBoolean(clientConfig.progress, false);
+            const overlay = normalizeBoolean(clientConfig.overlay, false);
+            const reconnect = String(clientConfig.reconnect ?? 10);
+            const hot = normalizeHotValue(devServer?.hot ?? 'only');
+            const liveReload = normalizeBoolean(devServer?.liveReload, true);
+            const query = new URLSearchParams({
+                protocol,
+                hostname,
+                port: String(port),
+                pathname,
+                logging,
+                progress,
+                overlay,
+                reconnect,
+                hot,
+                'live-reload': liveReload
+            });
+            return [
+                `@rspack/dev-server/client/index.js?${query.toString()}`,
+                'webpack/hot/dev-server'
+            ];
+        }
+        var develop_context = __webpack_require__("./webpack/webpack-lib/develop-context.ts");
         function add_scripts_and_styles_to_compilation_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -4257,6 +4502,7 @@ exports.modules = {
                 const projectRoot = compiler.options.context || manifestDir;
                 const publicDir = external_path_.join(projectRoot, 'public');
                 const hasPublicDir = external_fs_.existsSync(publicDir);
+                const devServerHmrImports = 'development' === compiler.options.mode ? getDevServerHmrImports(compiler) : [];
                 for (const field of Object.entries(htmlEntries)){
                     const [feature, resource] = field;
                     if (resource) {
@@ -4271,7 +4517,8 @@ exports.modules = {
                             ...cssAssets
                         ];
                         if ('development' === compiler.options.mode) {
-                            const hmrScript = external_path_.resolve(__dirname, "minimum-script-file");
+                            if (devServerHmrImports.length > 0) fileAssets.unshift(...devServerHmrImports);
+                            const hmrScript = (0, develop_context.G)("minimum-script-file");
                             fileAssets.push(hmrScript);
                         }
                         if (external_fs_.existsSync(resource)) compiler.options.entry = {
@@ -4688,24 +4935,40 @@ exports.modules = {
                     includeList,
                     browser: this.browser
                 }).apply(compiler);
-                if ('production' !== (compiler.options.mode || 'development')) compiler.options.module.rules.push({
-                    test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
-                    include: [
-                        external_path_.dirname(this.manifestPath)
-                    ],
-                    exclude: [
-                        /([\\/])node_modules\1/
-                    ],
-                    use: [
-                        {
-                            loader: external_path_.resolve(__dirname, "ensure-hmr-for-scripts"),
-                            options: {
-                                manifestPath: this.manifestPath,
-                                includeList
-                            }
+                if ('production' !== (compiler.options.mode || 'development')) {
+                    const contentScriptEntryPaths = new Set();
+                    try {
+                        const manifest = JSON.parse(external_fs_.readFileSync(this.manifestPath, 'utf-8'));
+                        const manifestDir = external_path_.dirname(this.manifestPath);
+                        const contentScripts = Array.isArray(manifest?.content_scripts) ? manifest.content_scripts : [];
+                        for (const contentScript of contentScripts){
+                            const jsList = Array.isArray(contentScript?.js) ? contentScript.js : [];
+                            for (const jsFile of jsList)contentScriptEntryPaths.add(external_path_.normalize(external_path_.resolve(manifestDir, jsFile)));
                         }
-                    ]
-                });
+                    } catch  {}
+                    compiler.options.module.rules.push({
+                        test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
+                        include: [
+                            external_path_.dirname(this.manifestPath)
+                        ],
+                        issuerLayer: {
+                            not: contracts.$t
+                        },
+                        exclude: [
+                            /([\\/])node_modules\1/,
+                            (resourcePath)=>contentScriptEntryPaths.has(external_path_.normalize(resourcePath))
+                        ],
+                        use: [
+                            {
+                                loader: (0, develop_context.G)("ensure-hmr-for-scripts"),
+                                options: {
+                                    manifestPath: this.manifestPath,
+                                    includeList
+                                }
+                            }
+                        ]
+                    });
+                }
                 new AddToFileDependencies({
                     manifestPath: this.manifestPath,
                     includeList,
@@ -4769,6 +5032,29 @@ exports.modules = {
             });
             return fileAssets;
         }
+        function findUpLocalSync(filename, options) {
+            const root = external_path_.parse(options.cwd).root;
+            let currentDir = options.cwd;
+            while(true){
+                const candidate = external_path_.join(currentDir, filename);
+                try {
+                    const stat = external_fs_.statSync(candidate);
+                    if (stat.isFile()) return candidate;
+                } catch  {}
+                if (currentDir === root) return;
+                currentDir = external_path_.dirname(currentDir);
+            }
+        }
+        function findNearestPackageJsonSync(manifestPath) {
+            try {
+                const manifestDir = external_path_.dirname(manifestPath);
+                return findUpLocalSync('package.json', {
+                    cwd: manifestDir
+                }) || null;
+            } catch  {
+                return null;
+            }
+        }
         function findPackageRoot(startDir) {
             let current = startDir;
             for(let i = 0; i < 15; i++){
@@ -4812,12 +5098,11 @@ exports.modules = {
                     const cs = contentScripts[i];
                     if (cs?.world !== 'MAIN') continue;
                     const bridgeIndex = originalCount + bridgeOrdinal++;
-                    bridgeScripts[`content_scripts/content-${bridgeIndex}`] = bridgeSource;
+                    bridgeScripts[(0, contracts.Y0)(bridgeIndex)] = bridgeSource;
                 }
             } catch  {}
             return bridgeScripts;
         }
-        var package_json = __webpack_require__("./webpack/webpack-lib/package-json.ts");
         function add_content_script_wrapper_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -4832,20 +5117,12 @@ exports.modules = {
             static getBridgeScripts(manifestPath) {
                 return getMainWorldBridgeScripts(manifestPath);
             }
-            resolveLoader(name) {
-                const base = external_path_.resolve(__dirname, name);
-                const candidates = [
-                    `${base}.cjs`,
-                    `${base}.js`,
-                    `${base}.mjs`,
-                    base
-                ];
-                for (const candidate of candidates)if (external_fs_.existsSync(candidate)) return candidate;
-                return base;
+            resolveLoader() {
+                return (0, develop_context.G)("feature-scripts-content-script-wrapper");
             }
             apply(compiler) {
                 const manifestDir = external_path_.dirname(this.manifestPath);
-                const packageJsonPath = (0, package_json.Pb)(this.manifestPath);
+                const packageJsonPath = findNearestPackageJsonSync(this.manifestPath);
                 const packageJsonDir = packageJsonPath ? external_path_.dirname(packageJsonPath) : manifestDir;
                 const includeDirs = packageJsonDir === manifestDir ? [
                     manifestDir
@@ -4861,7 +5138,7 @@ exports.modules = {
                     ],
                     use: [
                         {
-                            loader: this.resolveLoader("content-script-wrapper"),
+                            loader: this.resolveLoader(),
                             options: {
                                 manifestPath: this.manifestPath,
                                 mode: compiler.options.mode
@@ -4869,41 +5146,6 @@ exports.modules = {
                         }
                     ]
                 });
-                if ('production' !== compiler.options.mode) {
-                    compiler.options.module.rules.push({
-                        test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
-                        include: includeDirs,
-                        exclude: [
-                            /([\\/])node_modules\1/
-                        ],
-                        use: [
-                            {
-                                loader: this.resolveLoader('warn-no-default-export'),
-                                options: {
-                                    manifestPath: this.manifestPath,
-                                    mode: compiler.options.mode
-                                }
-                            }
-                        ],
-                        enforce: 'pre'
-                    });
-                    compiler.options.module.rules.push({
-                        test: /\.(js|cjs|mjs|jsx|mjsx|ts|mts|tsx|mtsx)$/,
-                        include: includeDirs,
-                        exclude: [
-                            /([\\/])node_modules\1/
-                        ],
-                        use: [
-                            {
-                                loader: this.resolveLoader('add-hmr-accept-code'),
-                                options: {
-                                    manifestPath: this.manifestPath,
-                                    mode: compiler.options.mode
-                                }
-                            }
-                        ]
-                    });
-                }
             }
             constructor(options){
                 add_content_script_wrapper_define_property(this, "manifestPath", void 0);
@@ -4912,17 +5154,6 @@ exports.modules = {
                 this.browser = options.browser || 'chrome';
             }
         }
-        function scriptsEntriesSummary(entriesAdded, publicTracked) {
-            return `Scripts entries — added=${external_pintor_default().gray(String(entriesAdded))}, publicTracked=${external_pintor_default().gray(String(publicTracked))}`;
-        }
-        function scriptsManifestChangeDetected(before, after) {
-            const parts = [
-                "Manifest scripts change detected",
-                before ? `${external_pintor_default().gray('before')} ${external_pintor_default().underline(before)}` : '',
-                after ? `${external_pintor_default().gray('after')} ${external_pintor_default().underline(after)}` : ''
-            ].filter(Boolean);
-            return parts.join(' — ');
-        }
         function add_scripts_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -4934,14 +5165,22 @@ exports.modules = {
             return obj;
         }
         const add_scripts_isRemoteUrl = (entry)=>/^([a-z][a-z0-9+.-]*:)?\/\//i.test(entry);
+        const isContentScriptFeature = (feature)=>feature.startsWith("content_scripts/");
+        const isScriptsFolderFeature = (feature)=>feature.startsWith("scripts/");
+        function createSequentialEntryModule(feature, entryImports) {
+            const source = [
+                `/* extension.js sequential entry: ${feature} */`,
+                ...entryImports.map((entryImport)=>`import ${JSON.stringify(String(entryImport))};`)
+            ].join('\n');
+            return `data:text/javascript;charset=utf-8,${encodeURIComponent(source)}`;
+        }
         class AddScripts {
             apply(compiler) {
                 const bridgeScripts = AddContentScriptWrapper.getBridgeScripts(this.manifestPath);
-                const mergedIncludeList = {
+                const scriptFields = {
                     ...this.includeList,
                     ...bridgeScripts
                 };
-                const scriptFields = mergedIncludeList;
                 if (compiler?.hooks?.thisCompilation?.tap) compiler.hooks.thisCompilation.tap("scripts:validate-include-list", (compilation)=>{
                     try {
                         const manifestDir = external_path_.dirname(this.manifestPath);
@@ -4952,20 +5191,19 @@ exports.modules = {
                                 raw
                             ] : [];
                             for (const entry of rawEntries){
-                                if (!entry || 'string' != typeof entry) continue;
-                                if (add_scripts_isRemoteUrl(entry)) continue;
+                                if (!entry || 'string' != typeof entry || add_scripts_isRemoteUrl(entry)) continue;
                                 let resolved = entry;
                                 if (!external_fs_.existsSync(resolved)) resolved = external_path_.isAbsolute(entry) ? entry : entry.startsWith('/') ? external_path_.join(manifestDir, entry.slice(1)) : external_path_.join(manifestDir, entry);
                                 if (external_fs_.existsSync(resolved)) continue;
                                 const isPublicRoot = entry.startsWith('/') && !external_path_.isAbsolute(entry);
                                 const displayPath = isPublicRoot ? outputRoot ? external_path_.join(outputRoot, entry.slice(1)) : entry : resolved;
-                                const lines = [];
-                                lines.push(`Check the ${feature.replace('/', '.')} field in your manifest.json file.`);
-                                lines.push("The script path must point to an existing file that will be bundled.");
-                                if (isPublicRoot) lines.push("Paths starting with '/' are resolved from the extension output root (served from public/), not your source directory.");
-                                lines.push('');
-                                lines.push(`NOT FOUND ${displayPath}`);
-                                const err = new ErrorCtor(lines.join('\n'));
+                                const err = new ErrorCtor([
+                                    `Check the ${feature.replace('/', '.')} field in your manifest.json file.`,
+                                    "The script path must point to an existing file that will be bundled.",
+                                    isPublicRoot ? "Paths starting with '/' are resolved from the extension output root (served from public/), not your source directory." : '',
+                                    '',
+                                    `NOT FOUND ${displayPath}`
+                                ].filter(Boolean).join('\n'));
                                 err.file = 'manifest.json';
                                 err.name = 'ScriptsMissingFile';
                                 (compilation.errors ||= []).push(err);
@@ -4976,15 +5214,18 @@ exports.modules = {
                 const newEntries = {};
                 const manifestDir = external_path_.dirname(this.manifestPath);
                 const projectPath = compiler.options.context || manifestDir;
+                let manifestJson = {};
+                try {
+                    manifestJson = JSON.parse(external_fs_.readFileSync(this.manifestPath, 'utf8'));
+                } catch  {
+                    manifestJson = {};
+                }
                 const resolveEntryPath = (entry)=>{
-                    if (!entry) return entry;
-                    if (add_scripts_isRemoteUrl(entry)) return entry;
+                    if (!entry || add_scripts_isRemoteUrl(entry)) return entry;
                     if (entry.startsWith('/') && !external_path_.isAbsolute(entry)) return external_path_.join(projectPath, entry.slice(1));
                     if (external_path_.isAbsolute(entry)) return entry;
                     return external_path_.join(manifestDir, entry);
                 };
-                let entriesAdded = 0;
-                let publicTracked = 0;
                 for (const [feature, scriptPath] of Object.entries(scriptFields)){
                     const rawEntries = Array.isArray(scriptPath) ? scriptPath || [] : scriptPath ? [
                         scriptPath
@@ -4992,32 +5233,32 @@ exports.modules = {
                     const resolvedEntries = rawEntries.map(resolveEntryPath);
                     const scriptImports = getScriptEntries(resolvedEntries);
                     const cssImports = getCssEntries(resolvedEntries);
-                    const allImports = [
-                        ...scriptImports,
-                        ...cssImports
+                    const entryImports = [
+                        ...new Set([
+                            ...scriptImports,
+                            ...cssImports
+                        ])
                     ];
-                    const entryImports = allImports;
-                    if (cssImports.length || scriptImports.length) {
-                        if ('background/service_worker' === feature) {
-                            const manifest = JSON.parse(external_fs_.readFileSync(this.manifestPath, 'utf8'));
-                            const isModuleServiceWorker = manifest.background?.type === 'module';
-                            newEntries[feature] = {
-                                import: entryImports,
-                                ...isModuleServiceWorker ? {} : {
-                                    chunkLoading: "import-scripts"
-                                }
-                            };
-                        } else newEntries[feature] = {
-                            import: entryImports
-                        };
-                        entriesAdded++;
-                    }
+                    const shouldUseSequentialEntryModule = isContentScriptFeature(feature) && scriptImports.length > 1;
+                    const finalEntryImports = shouldUseSequentialEntryModule ? [
+                        createSequentialEntryModule(feature, entryImports)
+                    ] : entryImports;
+                    if (finalEntryImports.length) newEntries[feature] = 'background/service_worker' === feature ? {
+                        import: finalEntryImports,
+                        ...manifestJson.background?.type === 'module' ? {} : {
+                            chunkLoading: "import-scripts"
+                        }
+                    } : {
+                        import: finalEntryImports,
+                        ...isContentScriptFeature(feature) || isScriptsFolderFeature(feature) ? {
+                            layer: contracts.$t
+                        } : {}
+                    };
                 }
                 compiler.options.entry = {
                     ...compiler.options.entry,
                     ...newEntries
                 };
-                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(scriptsEntriesSummary(entriesAdded, publicTracked));
             }
             constructor(options){
                 add_scripts_define_property(this, "manifestPath", void 0);
@@ -5026,45 +5267,6 @@ exports.modules = {
                 this.includeList = options.includeList || {};
             }
         }
-        const basic = [
-            'var isBrowser = !!(() => { try { return browser.runtime.getURL("/") } catch(e) {} })()',
-            'var isChrome = !!(() => { try { return chrome.runtime.getURL("/") } catch(e) {} })()'
-        ];
-        const weakRuntimeCheck = [
-            ...basic,
-            "var runtime = isBrowser ? browser : isChrome ? chrome : { runtime: { getURL: x => x } }"
-        ];
-        class AddPublicPathRuntimeModule {
-            apply(compiler) {
-                const { RuntimeGlobals } = compiler.webpack;
-                compiler.hooks.compilation.tap('PublicPathRuntimeModule', (compilation)=>{
-                    compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.publicPath).tap(AddPublicPathRuntimeModule.name, (chunk)=>{
-                        const module = add_public_path_runtime_module_PublicPathRuntimeModule(compiler);
-                        compilation.addRuntimeModule(chunk, module);
-                        return true;
-                    });
-                });
-            }
-        }
-        function add_public_path_runtime_module_PublicPathRuntimeModule(compiler) {
-            const { Template, RuntimeModule, RuntimeGlobals } = compiler.webpack;
-            class PublicPathRuntimeModule extends RuntimeModule {
-                generate() {
-                    const publicPath = this.compilation?.outputOptions.publicPath;
-                    return Template.asString([
-                        ...weakRuntimeCheck,
-                        `var path = ${JSON.stringify(this.compilation?.getPath(publicPath || '', {
-                            hash: this.compilation.hash || 'XXXX'
-                        }))}`,
-                        `${RuntimeGlobals.publicPath} = typeof importScripts === 'function' || !(isBrowser || isChrome) ? path : runtime.runtime.getURL(path);`
-                    ]);
-                }
-                constructor(){
-                    super('publicPath', RuntimeModule.STAGE_BASIC);
-                }
-            }
-            return new PublicPathRuntimeModule();
-        }
         function TemplateFn(compilation, Template) {
             return {
                 f: (args, body)=>{
@@ -5093,9 +5295,9 @@ exports.modules = {
                         `${_let} isChrome, runtime;`,
                         'try {',
                         Template.indent([
-                            `if (typeof browser !== "undefined" && ${optionalChaining ? 'typeof browser.runtime?.getURL === "function"' : 'typeof browser.runtime === "object" && typeof browser.runtime.getURL === "function"'}) {`,
+                            `if (typeof globalThis === "object" && globalThis && typeof globalThis.browser !== "undefined" && ${optionalChaining ? 'typeof globalThis.browser.runtime?.getURL === "function"' : 'typeof globalThis.browser.runtime === "object" && typeof globalThis.browser.runtime.getURL === "function"'}) {`,
                             Template.indent([
-                                'runtime = browser;'
+                                'runtime = globalThis.browser;'
                             ]),
                             '}'
                         ]),
@@ -5104,10 +5306,10 @@ exports.modules = {
                         Template.indent([
                             'try {',
                             Template.indent([
-                                `if (typeof chrome !== "undefined" && ${optionalChaining ? 'typeof chrome.runtime?.getURL === "function"' : 'typeof chrome.runtime === "object" && typeof chrome.runtime.getURL === "function"'}) {`,
+                                `if (typeof globalThis === "object" && globalThis && typeof globalThis.chrome !== "undefined" && ${optionalChaining ? 'typeof globalThis.chrome.runtime?.getURL === "function"' : 'typeof globalThis.chrome.runtime === "object" && typeof globalThis.chrome.runtime.getURL === "function"'}) {`,
                                 Template.indent([
                                     'isChrome = true;',
-                                    'runtime = chrome;'
+                                    'runtime = globalThis.chrome;'
                                 ]),
                                 '}'
                             ]),
@@ -5158,7 +5360,7 @@ exports.modules = {
                     const bundleId = chunkName ? `${chunkName}.js` : '';
                     const world = bundleId && this.contentScriptsMeta[bundleId] ? this.contentScriptsMeta[bundleId].world : void 0;
                     const isMainWorld = 'main' === world;
-                    const HasExtensionRuntime = `${_const} hasExtensionRuntime = (function(){ try {return ((typeof browser === "object" && browser && browser.runtime && typeof browser.runtime.sendMessage === "function") || (typeof chrome === "object" && chrome && chrome.runtime && typeof chrome.runtime.sendMessage === "function"));} catch (e) { return false; } })();`;
+                    const HasExtensionRuntime = `${_const} hasExtensionRuntime = (function(){ try {return ((typeof globalThis === "object" && globalThis && globalThis.browser && globalThis.browser.runtime && typeof globalThis.browser.runtime.sendMessage === "function") || (typeof globalThis === "object" && globalThis && globalThis.chrome && globalThis.chrome.runtime && typeof globalThis.chrome.runtime.sendMessage === "function"));} catch (e) { return false; } })();`;
                     const DynamicImportLoader = `${_const} ${DYNAMIC_IMPORT_LOADER} = ` + f('url, done, key, chunkId', `import(url).then(${f('', [
                         'if (isNotIframe) return done();',
                         'try {',
@@ -5209,6 +5411,7 @@ exports.modules = {
                     const ClassicLoader = `${_const} ${CLASSIC_LOADER} = ` + f('url, done', Template.asString([
                         `${_const} msg = { type: "WTW_INJECT", file: url };`,
                         `${_const} onError = ${f('e', 'done(Object.assign(e, { type: "missing" }))')};`,
+                        'try {',
                         `if (${RuntimeGlobalIsBrowser}) {`,
                         Template.indent([
                             `${RuntimeGlobal}.runtime.sendMessage(msg).then(done, onError);`
@@ -5221,7 +5424,8 @@ exports.modules = {
                                 'else done();'
                             ])});`
                         ]),
-                        '}'
+                        '}',
+                        '} catch (e) { onError(e); }'
                     ])) + ';';
                     const ClassicLoaderDisabled = `${_const} ${CLASSIC_LOADER} = ` + f('', [
                         "throw new Error(\"[webpack-target-webextension] Failed to load async chunk in the content script. No script loader is found. You can either\\n - Set output.environment.dynamicImport to true if your environment supports native ES Module\\n - Specify the background entry to enable the fallback loader\\n - Set module.parser.javascript.dynamicImportMode to 'eager' to inline all async chunks.\");"
@@ -5323,9 +5527,15 @@ exports.modules = {
                             'try { __extjsBase = document.documentElement.getAttribute("data-extjs-extension-base") || ""; } catch(_) { __extjsBase = ""; }'
                         ]),
                         "}",
+                        'var __extjsRuntimePath = "";',
                         `if (${RuntimeGlobal} && ${RuntimeGlobal}.runtime && typeof ${RuntimeGlobal}.runtime.getURL === "function") {`,
                         Template.indent([
-                            `${RuntimeGlobals.publicPath} = ${RuntimeGlobal}.runtime.getURL(${path});`
+                            `try { __extjsRuntimePath = ${RuntimeGlobal}.runtime.getURL(${path}); } catch (_) { __extjsRuntimePath = ""; }`
+                        ]),
+                        "}",
+                        "if (__extjsRuntimePath) {",
+                        Template.indent([
+                            `${RuntimeGlobals.publicPath} = __extjsRuntimePath;`
                         ]),
                         "} else if (__extjsBase) {",
                         Template.indent([
@@ -5416,8 +5626,10 @@ exports.modules = {
                         "}",
                         "if (!scriptUrl) {",
                         Template.indent([
+                            'var __extjsRuntimeRoot = "";',
                             `if (${RuntimeGlobal} && ${RuntimeGlobal}.runtime && typeof ${RuntimeGlobal}.runtime.getURL === "function") {`,
-                            Template.indent(`scriptUrl = ${RuntimeGlobal}.runtime.getURL("/");`),
+                            Template.indent(`try { __extjsRuntimeRoot = ${RuntimeGlobal}.runtime.getURL("/"); } catch (_) { __extjsRuntimeRoot = ""; }`),
+                            Template.indent("scriptUrl = __extjsRuntimeRoot || scriptUrl;"),
                             "} else {",
                             Template.indent('scriptUrl = __extjsBase || "";'),
                             "}"
@@ -5475,6 +5687,52 @@ exports.modules = {
             else if ('.' !== part) depth++;
             return depth > 0 ? `${'../'.repeat(depth)}${append}` : enforceRelative ? `./${append}` : append;
         }
+        function BaseUriRuntimeModule(webpack) {
+            const { RuntimeGlobals, RuntimeModule, Template } = webpack;
+            class BaseUriRuntime extends RuntimeModule {
+                generate() {
+                    return Template.asString([
+                        'var __extjsBase = "";',
+                        "try {",
+                        Template.indent([
+                            `if (${RuntimeGlobal} && ${RuntimeGlobal}.runtime && typeof ${RuntimeGlobal}.runtime.getURL === "function") {`,
+                            Template.indent([
+                                `__extjsBase = String(${RuntimeGlobal}.runtime.getURL("/"));`
+                            ]),
+                            "}"
+                        ]),
+                        "} catch (_) {}",
+                        'if (!__extjsBase && typeof globalThis === "object" && globalThis && globalThis.__EXTJS_EXTENSION_BASE__) {',
+                        Template.indent([
+                            '__extjsBase = String(globalThis.__EXTJS_EXTENSION_BASE__ || "");'
+                        ]),
+                        "}",
+                        'if (!__extjsBase && typeof document === "object" && document && document.documentElement) {',
+                        Template.indent([
+                            'try { __extjsBase = String(document.documentElement.getAttribute("data-extjs-extension-base") || ""); } catch (_) { __extjsBase = ""; }'
+                        ]),
+                        "}",
+                        "if (__extjsBase) {",
+                        Template.indent([
+                            `${RuntimeGlobals.baseURI} = __extjsBase;`
+                        ]),
+                        '} else if (typeof document !== "undefined" && document.baseURI) {',
+                        Template.indent([
+                            `${RuntimeGlobals.baseURI} = document.baseURI;`
+                        ]),
+                        "} else {",
+                        Template.indent([
+                            `${RuntimeGlobals.baseURI} = self.location.href;`
+                        ]),
+                        "}"
+                    ]);
+                }
+                constructor(){
+                    super('baseURI', RuntimeModule.STAGE_BASIC);
+                }
+            }
+            return new BaseUriRuntime();
+        }
         function ChunkLoaderFallbackRuntimeModule(webpack) {
             const { RuntimeModule, Template } = webpack;
             class ChunkLoaderFallbackRuntime extends RuntimeModule {
@@ -5485,7 +5743,7 @@ exports.modules = {
                     const optionalChain = compilation.outputOptions.environment.optionalChaining;
                     const _const = compilation.outputOptions.environment.const ? 'const' : 'var';
                     const _let = compilation.outputOptions.environment.const ? 'let' : 'var';
-                    return `${RuntimeGlobal}.runtime.onMessage.addListener(` + f('message, sender, sendResponse', [
+                    return `if (${RuntimeGlobal} && ${RuntimeGlobal}.runtime && ${RuntimeGlobal}.runtime.onMessage) {${RuntimeGlobal}.runtime.onMessage.addListener(` + f('message, sender, sendResponse', [
                         optionalChain ? 'if (message?.type != "WTW_INJECT" || typeof sender?.tab?.id != "number") return;' : 'if (!message || message.type != "WTW_INJECT" || !sender || !sender.tab || sender.tab.id == null) return;',
                         `${_let} file = message.file;`,
                         'try {',
@@ -5514,7 +5772,7 @@ exports.modules = {
                         ]),
                         '}',
                         'return true;'
-                    ]) + ');';
+                    ]) + ");}";
                 }
                 constructor(){
                     super('chunk loader fallback', RuntimeModule.STAGE_TRIGGER);
@@ -5553,8 +5811,13 @@ exports.modules = {
                     compilation.addRuntimeModule(_chunk, LoadScriptRuntimeModule(compiler.webpack, false !== compilation.outputOptions.environment.dynamicImport, false !== options.classicLoader, this.contentScriptsMeta));
                     return true;
                 });
-                compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.publicPath).tap(WebExtensionChuckLoaderRuntimePlugin.name, (chunk, set)=>{
-                    const { outputOptions } = compilation;
+                compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.baseURI).tap(WebExtensionChuckLoaderRuntimePlugin.name, (chunk, set)=>{
+                    set.add(RuntimeGlobal);
+                    compilation.addRuntimeModule(chunk, BaseUriRuntimeModule(compiler.webpack));
+                    return true;
+                });
+                compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.publicPath).tap(WebExtensionChuckLoaderRuntimePlugin.name, (chunk, set)=>{
+                    const { outputOptions } = compilation;
                     const { publicPath, scriptType } = outputOptions;
                     if ('auto' === publicPath || '' === publicPath && this.rspackAutoPublicPath) {
                         const module = AutoPublicPathRuntimeModule(compiler.webpack);
@@ -5794,7 +6057,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                                 } else code = [
                                     ';(() => {',
                                     Template.indent([
-                                        'const getURL = typeof browser === "object" ? browser.runtime.getURL : chrome.runtime.getURL;',
+                                        'const getURL = typeof globalThis === "object" && globalThis && typeof globalThis.browser === "object" ? globalThis.browser.runtime.getURL : globalThis.chrome.runtime.getURL;',
                                         `${JSON.stringify(files)}.forEach(file => import(getURL(file)));`
                                     ]),
                                     '})();',
@@ -5982,12 +6245,23 @@ Set background.noDynamicEntryWarning to true to disable this warning.
             }
         }
         const webpack_target_webextension_fork = WebExtensionPlugin;
+        function manifest_getManifestContent(compilation, manifestPath) {
+            return getManifestContent(compilation, manifestPath);
+        }
         function scripts_lib_manifest_filterKeysForThisBrowser(manifest, browser) {
             return manifest_filterKeysForThisBrowser(manifest, browser);
         }
         function backgroundIsRequiredMessageOnly(backgroundChunkName) {
             return `Check the ${external_pintor_default().yellow(backgroundChunkName.replace('/', '.'))} field in your ${external_pintor_default().yellow('manifest.json')} file.`;
         }
+        function scriptsManifestChangeDetected(before, after) {
+            const parts = [
+                "Manifest scripts change detected",
+                before ? `${external_pintor_default().gray('before')} ${external_pintor_default().underline(before)}` : '',
+                after ? `${external_pintor_default().gray('after')} ${external_pintor_default().underline(after)}` : ''
+            ].filter(Boolean);
+            return parts.join(' — ');
+        }
         function setup_background_entry_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -6020,7 +6294,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
             apply(compiler) {
                 const manifest = JSON.parse(external_fs_.readFileSync(this.manifestPath, 'utf-8'));
                 const browser = this.browser;
-                const minimumBgScript = external_path_.resolve(__dirname, 'firefox' === browser || 'gecko-based' === browser ? 'minimum-firefox-file' : 'minimum-chromium-file');
+                const minimumBgScript = (0, develop_context.G)('firefox' === browser || 'gecko-based' === browser ? 'minimum-firefox-file' : 'minimum-chromium-file');
                 const dirname = external_path_.dirname(this.manifestPath);
                 let manifestBg = scripts_lib_manifest_filterKeysForThisBrowser(manifest, browser);
                 manifestBg = manifestBg?.background ?? manifest.background;
@@ -6063,6 +6337,263 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 this.browser = options.browser || 'chrome';
             }
         }
+        function patch_csp_resolveV2Policy(policy) {
+            if (!policy) return;
+            if ('string' == typeof policy) return policy;
+            if ('object' == typeof policy) {
+                const extensionPages = policy.extension_pages;
+                if ('string' == typeof extensionPages) return extensionPages;
+            }
+        }
+        function patch_csp_buildCSP(cspObject) {
+            const directives = Object.entries(cspObject).map(([directive, values])=>`${directive} ${values.join(' ')}`);
+            return directives.join('; ') + '; ';
+        }
+        function patch_csp_patchV2CSP(manifest) {
+            let policy = patch_csp_resolveV2Policy(manifest.content_security_policy);
+            if (!policy) return patch_csp_buildCSP({
+                "script-src": [
+                    "'self'",
+                    "'unsafe-eval'",
+                    'blob:',
+                    'filesystem:'
+                ],
+                'object-src': [
+                    "'self'",
+                    'blob:',
+                    'filesystem:'
+                ]
+            });
+            const csp = external_content_security_policy_parser_default()(policy);
+            if (csp.get("script-src")) {
+                const scriptSrc = csp.get("script-src") || [];
+                if (!scriptSrc.includes("'unsafe-eval'")) scriptSrc.push("'unsafe-eval'");
+                if (!scriptSrc.includes('blob:')) scriptSrc.push('blob:');
+                if (!scriptSrc.includes('filesystem:')) scriptSrc.push('filesystem:');
+                csp.set("script-src", scriptSrc);
+            } else csp.set("script-src", [
+                "'self'",
+                "'unsafe-eval'",
+                'blob:',
+                'filesystem:'
+            ]);
+            if (csp.get('object-src')) {
+                const objectSrc = csp.get('object-src') || [];
+                if (!objectSrc.includes('blob:')) objectSrc.push('blob:');
+                if (!objectSrc.includes('filesystem:')) objectSrc.push('filesystem:');
+                csp.set('object-src', objectSrc);
+            } else csp.set('object-src', [
+                "'self'",
+                'blob:',
+                'filesystem:'
+            ]);
+            const cspObject = Object.fromEntries(csp.entries());
+            return patch_csp_buildCSP(cspObject);
+        }
+        function patch_csp_patchV3CSP(manifest) {
+            const policy = manifest.content_security_policy;
+            if (!policy) return {
+                extension_pages: patch_csp_buildCSP({
+                    "script-src": [
+                        "'self'"
+                    ],
+                    'object-src': [
+                        "'self'"
+                    ]
+                })
+            };
+            const csp = external_content_security_policy_parser_default()(policy.extension_pages || '');
+            const defaultDirectives = {
+                "script-src": [
+                    "'self'"
+                ],
+                'object-src': [
+                    "'self'"
+                ]
+            };
+            for(const directive in defaultDirectives)if (!csp.get(directive)) csp.set(directive, defaultDirectives[directive]);
+            const cspObject = Object.fromEntries(csp.entries());
+            const extensionPagesPolicy = patch_csp_buildCSP(cspObject);
+            return {
+                extension_pages: extensionPagesPolicy
+            };
+        }
+        function patch_web_resources_patchWebResourcesV2(manifest) {
+            const defaultResources = [
+                '/*.json',
+                '/*.js',
+                '/*.css',
+                '/*.scss',
+                '/*.sass',
+                '/*.less',
+                '*.styl',
+                "/scripts/*.js",
+                "/scripts/*.css",
+                '/hot/*',
+                '/*.png',
+                '/*.jpg',
+                '/*.jpeg',
+                '/*.svg',
+                '/*.gif',
+                '/*.webp',
+                '/*.ico',
+                '/*.avif'
+            ];
+            const resources = manifest.web_accessible_resources;
+            if (!resources || 0 === resources.length) return defaultResources;
+            const webResources = new Set(resources);
+            for (const resource of defaultResources)if (!webResources.has(resource)) webResources.add(resource);
+            return Array.from(webResources);
+        }
+        function patch_web_resources_patchWebResourcesV3(manifest) {
+            const defaultResources = [
+                '/*.json',
+                '/*.js',
+                '/*.css',
+                '/*.scss',
+                '/*.sass',
+                '/*.less',
+                '*.styl',
+                "/scripts/*.js",
+                "/scripts/*.css",
+                '/hot/*',
+                '/*.png',
+                '/*.jpg',
+                '/*.jpeg',
+                '/*.svg',
+                '/*.gif',
+                '/*.webp',
+                '/*.ico',
+                '/*.avif'
+            ];
+            return [
+                ...manifest.web_accessible_resources || [],
+                {
+                    resources: defaultResources,
+                    matches: [
+                        '<all_urls>'
+                    ]
+                }
+            ];
+        }
+        function patch_background_patchBackground(manifest, browser) {
+            if (!manifest.background) {
+                if ('firefox' === browser || 'gecko-based' === browser) return {
+                    background: {
+                        ...manifest.background || {},
+                        scripts: [
+                            "background/script.js"
+                        ]
+                    }
+                };
+                if (2 === manifest.manifest_version) return {
+                    background: {
+                        ...manifest.background || {},
+                        scripts: [
+                            "background/script.js"
+                        ]
+                    }
+                };
+                return {
+                    background: {
+                        ...manifest.background || {},
+                        service_worker: 'background/service_worker.js'
+                    }
+                };
+            }
+            return {
+                background: {
+                    ...manifest.background
+                }
+            };
+        }
+        function patch_externally_connectable_patchExternallyConnectable(manifest) {
+            if (manifest.externally_connectable && !manifest.externally_connectable.ids) return {
+                externally_connectable: {
+                    ...manifest.externally_connectable,
+                    ids: [
+                        ...new Set(manifest.externally_connectable.ids || []),
+                        '*'
+                    ]
+                }
+            };
+            if (manifest.externally_connectable && !manifest.externally_connectable.ids) return {
+                externally_connectable: {
+                    ...manifest.externally_connectable,
+                    ids: [
+                        '*'
+                    ]
+                }
+            };
+            return {};
+        }
+        function apply_manifest_dev_defaults_define_property(obj, key, value) {
+            if (key in obj) Object.defineProperty(obj, key, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+            else obj[key] = value;
+            return obj;
+        }
+        class ApplyManifestDevDefaults {
+            generateManifestPatches(compilation) {
+                const canonicalManifest = manifest_getManifestContent(compilation, this.manifestPath);
+                const patchedManifest = {
+                    ...canonicalManifest,
+                    content_security_policy: 3 === canonicalManifest.manifest_version ? patch_csp_patchV3CSP(canonicalManifest) : patch_csp_patchV2CSP(canonicalManifest),
+                    ...3 === canonicalManifest.manifest_version ? canonicalManifest.permissions ? {
+                        permissions: [
+                            ...new Set([
+                                "scripting",
+                                'tabs',
+                                'management',
+                                ...canonicalManifest.permissions
+                            ])
+                        ]
+                    } : {
+                        permissions: [
+                            "scripting",
+                            'tabs',
+                            'management'
+                        ]
+                    } : {},
+                    ...patch_background_patchBackground(canonicalManifest, this.browser),
+                    ...patch_externally_connectable_patchExternallyConnectable(canonicalManifest),
+                    web_accessible_resources: 3 === canonicalManifest.manifest_version ? patch_web_resources_patchWebResourcesV3(canonicalManifest) : patch_web_resources_patchWebResourcesV2(canonicalManifest)
+                };
+                const source = JSON.stringify(patchedManifest, null, 2);
+                const rawSource = new core_.sources.RawSource(source);
+                if (compilation.getAsset('manifest.json')) compilation.updateAsset('manifest.json', rawSource);
+            }
+            apply(compiler) {
+                if (!compiler?.hooks?.thisCompilation) return;
+                compiler.hooks.thisCompilation.tap('run-chromium:apply-manifest-dev-defaults', (compilation)=>{
+                    if (!compilation?.hooks?.processAssets) return;
+                    compilation.hooks.processAssets.tap({
+                        name: 'run-chromium:apply-manifest-dev-defaults',
+                        stage: core_.Compilation.PROCESS_ASSETS_STAGE_REPORT + 100
+                    }, (_assets)=>{
+                        if (!this.manifestPath) {
+                            const errorMessage = 'No manifest.json found in your extension bundle. Unable to patch manifest.json.';
+                            try {
+                                const WebpackErrorCtor = compiler?.rspack?.WebpackError;
+                                compilation.errors.push(WebpackErrorCtor ? new WebpackErrorCtor(`run-chromium: ${errorMessage}`) : new Error(`run-chromium: ${errorMessage}`));
+                            } catch  {}
+                            return;
+                        }
+                        this.generateManifestPatches(compilation);
+                    });
+                });
+            }
+            constructor(options){
+                apply_manifest_dev_defaults_define_property(this, "manifestPath", void 0);
+                apply_manifest_dev_defaults_define_property(this, "browser", void 0);
+                this.manifestPath = options.manifestPath;
+                this.browser = options.browser || 'chrome';
+            }
+        }
         function setup_reload_strategy_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -6108,17 +6639,17 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     let bridgeOrdinal = 0;
                     for(let i = 0; i < csList.length; i++){
                         const cs = csList[i];
-                        const bundleId = `content_scripts/content-${i}.js`;
+                        const bundleId = (0, contracts.f6)(i);
                         const isMain = cs?.world === 'MAIN';
                         if (isMain) {
                             const bridgeIndex = originalCount + bridgeOrdinal++;
+                            const bridgeBundleId = (0, contracts.f6)(bridgeIndex);
                             contentScriptsMeta[bundleId] = {
                                 index: i,
                                 bundleId,
                                 world: 'main',
-                                bridgeBundleId: `content_scripts/content-${bridgeIndex}.js`
+                                bridgeBundleId
                             };
-                            const bridgeBundleId = `content_scripts/content-${bridgeIndex}.js`;
                             contentScriptsMeta[bridgeBundleId] = {
                                 index: bridgeIndex,
                                 bundleId: bridgeBundleId,
@@ -6133,12 +6664,17 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                         };
                     }
                 } catch  {}
+                new ApplyManifestDevDefaults({
+                    manifestPath: this.manifestPath,
+                    browser: this.browser
+                }).apply(compiler);
                 new SetupBackgroundEntry({
                     manifestPath: this.manifestPath,
                     browser: this.browser
                 }).apply(compiler);
                 new webpack_target_webextension_fork({
                     background: this.getEntryName(patchedManifest),
+                    hmrConfig: false,
                     weakRuntimeCheck: true,
                     contentScriptsMeta
                 }).apply(compiler);
@@ -6150,6 +6686,135 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 this.browser = options.browser || 'chrome';
             }
         }
+        const DEV_SERVER_CLIENT_MARKERS = [
+            '@rspack/dev-server/client/index.js?',
+            '@rspack/dev-server/client/utils/ansiHTML.js',
+            'webpack-dev-server',
+            'WebSocketClient'
+        ];
+        const DEV_SERVER_HOT_MARKERS = [
+            '[HMR] Waiting for update signal from WDS...',
+            '[HMR] Cannot find update. Need to do a full reload!',
+            'module.hot.check()'
+        ];
+        function stripDevServerStartupFromContentScript(source) {
+            let nextSource = source;
+            const startupModuleIds = getStartupModuleIds(source);
+            for (const moduleId of startupModuleIds){
+                const moduleBody = getModuleBody(source, moduleId);
+                if (!moduleBody) continue;
+                const shouldStrip = DEV_SERVER_CLIENT_MARKERS.some((marker)=>moduleBody.includes(marker)) || DEV_SERVER_HOT_MARKERS.some((marker)=>moduleBody.includes(marker));
+                if (shouldStrip) nextSource = stripStartupRequire(nextSource, moduleId);
+            }
+            return stripExtraStartupRequires(nextSource);
+        }
+        function getStartupModuleIds(source) {
+            const startupIndex = source.indexOf('// startup');
+            if (-1 === startupIndex) return [];
+            const startupSection = source.slice(startupIndex);
+            const requirePattern = /__webpack_require__\((\d+)\);/g;
+            const ids = [];
+            let match = null;
+            while(match = requirePattern.exec(startupSection))ids.push(match[1]);
+            return ids;
+        }
+        function getModuleBody(source, moduleId) {
+            const moduleHeaderPattern = new RegExp(`(?:^|\\n)${moduleId}\\([^)]*\\)\\s*\\{`, 'm');
+            const headerMatch = moduleHeaderPattern.exec(source);
+            if (!headerMatch) return null;
+            const moduleStart = headerMatch.index;
+            const nextHeaderPattern = /(?:^|\n)\d+\([^)]*\)\s*\{/g;
+            nextHeaderPattern.lastIndex = moduleStart + headerMatch[0].length;
+            const nextHeaderMatch = nextHeaderPattern.exec(source);
+            return source.slice(moduleStart, nextHeaderMatch ? nextHeaderMatch.index : source.length);
+        }
+        function stripExtraStartupRequires(source) {
+            const startupMarker = '// startup';
+            const startupIndex = source.indexOf(startupMarker);
+            if (-1 === startupIndex) return source;
+            const startupSection = source.slice(startupIndex);
+            const mainEntryMatch = startupSection.match(/var __webpack_exports__ = __webpack_require__\(\d+\);/);
+            if (!mainEntryMatch) return source;
+            const requireMatches = Array.from(startupSection.matchAll(/^\s*__webpack_require__\(\d+\);\s*$/gm));
+            if (requireMatches.length <= 1) return source;
+            const requiresToRemove = requireMatches.slice(1).map((match)=>match[0]);
+            let nextSource = source;
+            for (const requireLine of requiresToRemove)nextSource = nextSource.replace(requireLine, '');
+            return nextSource;
+        }
+        function stripStartupRequire(source, moduleId) {
+            const startupRequirePattern = new RegExp(`^\\s*__webpack_require__\\(${moduleId}\\);\\n?`, 'm');
+            return source.replace(startupRequirePattern, '');
+        }
+        const strip_content_script_dev_server_runtime_CONTENT_SCRIPT_ASSET = /(^|\/)content_scripts\/content-\d+(?:\.[a-f0-9]+)?\.js$/i;
+        class StripContentScriptDevServerRuntime {
+            apply(compiler) {
+                compiler.hooks.thisCompilation.tap(StripContentScriptDevServerRuntime.name, (compilation)=>{
+                    compilation.hooks.processAssets.tap({
+                        name: StripContentScriptDevServerRuntime.name,
+                        stage: core_.Compilation.PROCESS_ASSETS_STAGE_REPORT
+                    }, ()=>{
+                        for (const asset of compilation.getAssets()){
+                            if (!strip_content_script_dev_server_runtime_CONTENT_SCRIPT_ASSET.test(asset.name)) continue;
+                            const originalSource = asset.source.source().toString();
+                            const strippedSource = stripDevServerStartupFromContentScript(originalSource);
+                            if (strippedSource !== originalSource) compilation.updateAsset(asset.name, new core_.sources.RawSource(strippedSource));
+                        }
+                    });
+                });
+            }
+        }
+        const basic = [
+            'var isBrowser = !!(() => { try { return globalThis.browser.runtime.getURL("/") } catch(e) {} })()',
+            'var isChrome = !!(() => { try { return globalThis.chrome.runtime.getURL("/") } catch(e) {} })()'
+        ];
+        const weakRuntimeCheck = [
+            ...basic,
+            "var runtime = isBrowser ? globalThis.browser : isChrome ? globalThis.chrome : { runtime: { getURL: x => x } }"
+        ];
+        class AddPublicPathRuntimeModule {
+            apply(compiler) {
+                const { RuntimeGlobals } = compiler.webpack;
+                compiler.hooks.compilation.tap('PublicPathRuntimeModule', (compilation)=>{
+                    compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.publicPath).tap(AddPublicPathRuntimeModule.name, (chunk)=>{
+                        const module = add_public_path_runtime_module_PublicPathRuntimeModule(compiler);
+                        compilation.addRuntimeModule(chunk, module);
+                        return true;
+                    });
+                });
+            }
+        }
+        function add_public_path_runtime_module_PublicPathRuntimeModule(compiler) {
+            const { Template, RuntimeModule, RuntimeGlobals } = compiler.webpack;
+            class PublicPathRuntimeModule extends RuntimeModule {
+                generate() {
+                    const publicPath = this.compilation?.outputOptions.publicPath;
+                    return Template.asString([
+                        ...weakRuntimeCheck,
+                        'var __extjsBase = (typeof globalThis === "object" && globalThis && globalThis.__EXTJS_EXTENSION_BASE__) ? String(globalThis.__EXTJS_EXTENSION_BASE__) : "";',
+                        'if (!__extjsBase && typeof document === "object" && document && document.documentElement) {',
+                        Template.indent([
+                            'try { __extjsBase = document.documentElement.getAttribute("data-extjs-extension-base") || ""; } catch(_) { __extjsBase = ""; }'
+                        ]),
+                        "}",
+                        `var path = ${JSON.stringify(this.compilation?.getPath(publicPath || '', {
+                            hash: this.compilation.hash || 'XXXX'
+                        }))}`,
+                        'var __extjsRuntimePath = "";',
+                        "if (!(typeof importScripts === 'function') && (isBrowser || isChrome)) {",
+                        Template.indent([
+                            'try { __extjsRuntimePath = runtime.runtime.getURL(path); } catch (_) { __extjsRuntimePath = ""; }'
+                        ]),
+                        "}",
+                        `${RuntimeGlobals.publicPath} = typeof importScripts === 'function' || !(isBrowser || isChrome) ? path : (__extjsRuntimePath || (__extjsBase ? __extjsBase.replace(/\\/+$/, "/") + String(path).replace(/^\\/+/, "") : ""));`
+                    ]);
+                }
+                constructor(){
+                    super('publicPath', RuntimeModule.STAGE_BASIC);
+                }
+            }
+            return new PublicPathRuntimeModule();
+        }
         function throw_if_manifest_scripts_change_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -6272,6 +6937,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 }).apply(compiler);
                 if ('production' === compiler.options.mode) new AddPublicPathRuntimeModule().apply(compiler);
                 if ('production' !== compiler.options.mode) {
+                    new StripContentScriptDevServerRuntime().apply(compiler);
                     new SetupReloadStrategy({
                         manifestPath: this.manifestPath,
                         browser: this.browser
@@ -7661,6 +8327,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 instanceId: options.instanceId
             };
         }
+        var runtime_options = __webpack_require__("./webpack/plugin-browsers/browsers-lib/runtime-options.ts");
         var browsers_lib_messages = __webpack_require__("./webpack/plugin-browsers/browsers-lib/messages.ts");
         var chromium_context = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-context/index.ts");
         var chromium_launch = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-launch/index.ts");
@@ -8016,19 +8683,21 @@ Set background.noDynamicEntryWarning to true to disable this warning.
             return hash.toString(16).padStart(8, '0');
         }
         function diffDomSnapshots(prev, next) {
+            const prevNodes = Array.isArray(prev?.nodes) ? prev.nodes : [];
+            const nextNodes = Array.isArray(next?.nodes) ? next.nodes : [];
             if (!prev) return {
-                added: next.nodes.length,
+                added: nextNodes.length,
                 removed: 0,
                 changed: 0,
-                addedKeys: next.nodes.slice(0, 50).map((n)=>n.key),
+                addedKeys: nextNodes.slice(0, 50).map((n)=>n.key),
                 removedKeys: [],
                 changedKeys: []
             };
-            const prevMap = new Map(prev.nodes.map((n)=>[
+            const prevMap = new Map(prevNodes.map((n)=>[
                     n.key,
                     n
                 ]));
-            const nextMap = new Map(next.nodes.map((n)=>[
+            const nextMap = new Map(nextNodes.map((n)=>[
                     n.key,
                     n
                 ]));
@@ -8135,6 +8804,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
             return '<<<EXTJS_HTML_END>>>';
         }
         var manifest_readiness = __webpack_require__("./webpack/plugin-browsers/run-chromium/manifest-readiness.ts");
+        var content_script_targets = __webpack_require__("./webpack/plugin-browsers/browsers-lib/content-script-targets.ts");
         function chromium_hard_reload_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
                 value: value,
@@ -8164,6 +8834,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 };
                 if (compiler.hooks?.watchRun?.tapAsync) compiler.hooks.watchRun.tapAsync('run-browsers:watch', (compilerWithModifiedFiles, done)=>{
                     try {
+                        this.contentReloadGeneration += 1;
                         const modifiedFiles = compilerWithModifiedFiles?.modifiedFiles || new Set();
                         const normalizedModifiedFilePaths = Array.from(modifiedFiles).map((filePath)=>String(filePath).replace(/\\/g, '/'));
                         const compilerContextRoot = String(compiler?.options?.context || '').replace(/\\/g, '/');
@@ -8196,9 +8867,34 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                                 });
                             }
                         }
-                        if (hitManifest) this.ctx.setPendingReloadReason('manifest');
-                        else if (localeChanged) this.ctx.setPendingReloadReason('locales');
-                        else if (serviceWorkerChanged) this.ctx.setPendingReloadReason('sw');
+                        if (hitManifest) {
+                            this.pendingContentReloadEntryNames = [];
+                            this.ctx.setPendingReloadReason('manifest');
+                        } else if (localeChanged) {
+                            this.pendingContentReloadEntryNames = [];
+                            this.ctx.setPendingReloadReason('locales');
+                        } else if (serviceWorkerChanged) {
+                            this.pendingContentReloadEntryNames = [];
+                            this.ctx.setPendingReloadReason('sw');
+                        } else {
+                            const changedContentEntries = (0, content_script_targets.JY)(sourceModifiedFilePaths, this.contentScriptSourceDependencyPathsByEntry);
+                            this.lastWatchIncludedContentChanges = changedContentEntries.length > 0;
+                            if (changedContentEntries.length > 0) {
+                                this.pendingContentReloadEntryNames = changedContentEntries;
+                                this.awaitingSettledContentBuild = true;
+                                globalThis.__EXTJS_PENDING_CHROMIUM_CONTENT_RELOAD__ = true;
+                            }
+                            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[reload] changed content entries: ${this.pendingContentReloadEntryNames.join(', ') || '<none>'}`);
+                            if (this.shouldEmitReloadActionEvent()) emitActionEvent('reload_debug', {
+                                phase: 'watch',
+                                browser: this.options?.browser,
+                                sourceModifiedFilePaths,
+                                changedContentEntries,
+                                pendingContentReloadEntryNames: [
+                                    ...this.pendingContentReloadEntryNames
+                                ]
+                            });
+                        }
                     } catch (error) {
                         this.logger?.warn?.('[reload-debug] watchRun inspect failed:', String(error));
                     }
@@ -8207,17 +8903,139 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 compiler.hooks.done.tapPromise('run-browsers:module', async (stats)=>{
                     const hasErrors = 'function' == typeof stats?.hasErrors ? stats.hasErrors() : !!stats?.compilation?.errors?.length;
                     if (hasErrors) return;
+                    const inferredEntryNamesFromSourceSignatures = this.inferContentReloadEntryNamesFromSourceSignatures();
+                    const inferredHardReloadReason = this.inferHardReloadReasonFromSourceSignatures(compiler);
+                    const nextManifestSourceSignatures = this.collectManifestSourceSignatures(compiler);
+                    const nextLocaleSourceSignatures = this.collectLocaleSourceSignatures(compiler);
+                    const nextServiceWorkerSourceDependencyPaths = this.collectEntrypointModuleResourcePaths(stats.compilation, 'background/service_worker');
+                    const nextServiceWorkerSourceSignatures = this.collectSourceSignaturesFromPaths(nextServiceWorkerSourceDependencyPaths);
+                    const nextContentScriptSourceDependencyPaths = this.collectContentScriptSourceDependencyPaths(stats.compilation);
+                    const nextContentScriptSourceSignatures = this.collectContentScriptSourceSignatures(nextContentScriptSourceDependencyPaths);
+                    const contentScriptOutputRoot = this.ctx.getExtensionRoot() || String(stats?.compilation?.options?.output?.path || '');
+                    const nextContentScriptOutputSignatures = this.collectContentScriptOutputSignatures(stats.compilation, contentScriptOutputRoot || void 0);
+                    const inferredEntryNamesFromOutputSignatures = this.inferContentReloadEntryNamesFromOutputSignatures(nextContentScriptOutputSignatures);
                     this.refreshSWFromManifest(stats.compilation);
-                    this.refreshServiceWorkerSourceDependencyPaths(stats.compilation);
+                    this.serviceWorkerSourceDependencyPaths = nextServiceWorkerSourceDependencyPaths;
+                    this.serviceWorkerSourceSignatures = nextServiceWorkerSourceSignatures;
+                    this.manifestSourceSignatures = nextManifestSourceSignatures;
+                    this.localeSourceSignatures = nextLocaleSourceSignatures;
+                    this.contentScriptSourceDependencyPathsByEntry = nextContentScriptSourceDependencyPaths;
+                    this.contentScriptSourceSignaturesByEntry = nextContentScriptSourceSignatures;
+                    this.contentScriptOutputSignaturesByEntry = nextContentScriptOutputSignatures;
                     if (!this.hasCompletedSuccessfulBuild) {
                         this.hasCompletedSuccessfulBuild = true;
                         this.firstSuccessfulBuildAtMs = Date.now();
+                        this.pendingContentReloadEntryNames = [];
                         this.ctx.clearPendingReloadReason();
                         return;
                     }
+                    const assetsArr = Array.isArray(stats?.compilation?.getAssets?.()) ? stats.compilation.getAssets() : [];
+                    const changedAssets = assetsArr.filter((asset)=>asset?.emitted).map((asset)=>String(asset?.name || ''));
                     const pendingReason = this.ctx.getPendingReloadReason();
-                    const reason = pendingReason;
-                    if (!reason) return;
+                    const inferredAssetReason = this.inferHardReloadReasonFromChangedAssets(this.pendingContentReloadEntryNames.length > 0 ? changedAssets.filter((a)=>'manifest.json' !== String(a || '').replace(/\\/g, '/')) : changedAssets);
+                    const reason = pendingReason || inferredHardReloadReason || inferredAssetReason;
+                    const inferredEntryNames = Array.from(new Set([
+                        ...this.inferContentReloadEntryNamesFromChangedAssets(changedAssets),
+                        ...inferredEntryNamesFromSourceSignatures,
+                        ...inferredEntryNamesFromOutputSignatures
+                    ]));
+                    const targetEntryNames = this.pendingContentReloadEntryNames.length > 0 ? [
+                        ...this.pendingContentReloadEntryNames
+                    ] : inferredEntryNames;
+                    if (this.shouldEmitReloadActionEvent()) emitActionEvent('reload_debug', {
+                        phase: 'done',
+                        browser: this.options?.browser,
+                        reason: reason || null,
+                        changedAssets,
+                        inferredEntryNamesFromSourceSignatures,
+                        inferredEntryNamesFromOutputSignatures,
+                        pendingContentReloadEntryNames: [
+                            ...this.pendingContentReloadEntryNames
+                        ],
+                        inferredEntryNames,
+                        targetEntryNames
+                    });
+                    if (!reason) {
+                        if (targetEntryNames.length > 0) {
+                            const ctrl = this.ctx.getController() ?? await new Promise((resolve)=>{
+                                const timeout = setTimeout(()=>resolve(void 0), 8000);
+                                this.ctx.onControllerReady((c)=>{
+                                    clearTimeout(timeout);
+                                    resolve(c);
+                                });
+                            });
+                            if (!ctrl) return;
+                            const selectedEntryNames = [
+                                ...targetEntryNames
+                            ];
+                            const selectedGeneration = this.contentReloadGeneration;
+                            const selectedRules = (0, content_script_targets.Il)((0, content_script_targets.iw)(stats.compilation, this.ctx.getExtensionRoot()), selectedEntryNames);
+                            const sourceOverridesByBundleId = this.collectContentScriptSourceOverrides(stats.compilation, selectedRules);
+                            if (0 === selectedRules.length) {
+                                this.pendingContentReloadEntryNames = [];
+                                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log('[reload] selected content rules: <none>');
+                                return;
+                            }
+                            if (this.lastWatchIncludedContentChanges && this.contentReloadQuietPeriodMs > 0) {
+                                await new Promise((resolve)=>setTimeout(resolve, this.contentReloadQuietPeriodMs));
+                                if (selectedGeneration !== this.contentReloadGeneration) {
+                                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log('[reload] skipping content reinjection during active watch churn');
+                                    return;
+                                }
+                            }
+                            let reinjectionSourceOverridesByBundleId;
+                            const extensionRoot = this.ctx.getExtensionRoot();
+                            if (extensionRoot) {
+                                const selectedEntryFiles = this.collectEntrypointFiles(stats.compilation, selectedEntryNames, extensionRoot);
+                                const expectedAssetSignatures = this.collectAssetTextSignatures(stats.compilation, selectedEntryFiles);
+                                const filesReady = await this.waitForStableContentOutputs(extensionRoot, selectedEntryFiles, expectedAssetSignatures);
+                                const hasSourceOverrides = Object.keys(sourceOverridesByBundleId).length >= selectedRules.length;
+                                reinjectionSourceOverridesByBundleId = filesReady ? void 0 : hasSourceOverrides ? sourceOverridesByBundleId : void 0;
+                                if (!filesReady) {
+                                    if (!hasSourceOverrides) return void this.logger?.warn?.("[reload] content script assets did not stabilize before targeted reload");
+                                }
+                            }
+                            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[reload] selected content rules for ${selectedEntryNames.join(', ')}`);
+                            const reinjectedTabs = await ctrl.reloadMatchingTabsForContentScripts(selectedRules, {
+                                sourceOverridesByBundleId: reinjectionSourceOverridesByBundleId
+                            });
+                            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[reload] reinjected tabs for ${selectedEntryNames.join(', ')}: ${reinjectedTabs}`);
+                            ctrl.hardReload().catch(()=>{});
+                            if (this.lastWatchIncludedContentChanges && this.contentReloadFollowupMs > 0) {
+                                await new Promise((resolve)=>setTimeout(resolve, this.contentReloadFollowupMs));
+                                if (selectedGeneration === this.contentReloadGeneration) {
+                                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[reload] follow-up reinjection for ${selectedEntryNames.join(', ')}`);
+                                    const followupReinjectedTabs = await ctrl.reloadMatchingTabsForContentScripts(selectedRules, {
+                                        sourceOverridesByBundleId: reinjectionSourceOverridesByBundleId
+                                    });
+                                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[reload] follow-up reinjected tabs for ${selectedEntryNames.join(', ')}: ${followupReinjectedTabs}`);
+                                    if (this.contentReloadQuietPeriodMs > 0) await new Promise((resolve)=>setTimeout(resolve, this.contentReloadQuietPeriodMs));
+                                }
+                            }
+                            if (this.awaitingSettledContentBuild && this.lastWatchIncludedContentChanges) {
+                                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log('[reload] preserving pending content reinjection until settled follow-up build');
+                            } else {
+                                this.pendingContentReloadEntryNames = [];
+                                this.awaitingSettledContentBuild = false;
+                            }
+                            if (this.awaitingSettledContentBuild && !this.lastWatchIncludedContentChanges) {
+                                this.pendingContentReloadEntryNames = [];
+                                this.awaitingSettledContentBuild = false;
+                            }
+                            this.broadcastSourceWatchMessage(compiler, {
+                                type: 'contentReloaded',
+                                browser: this.options?.browser,
+                                entries: selectedEntryNames
+                            });
+                            globalThis.__EXTJS_PENDING_CHROMIUM_CONTENT_RELOAD__ = false;
+                            try {
+                                await globalThis.__EXTJS_ON_CHROMIUM_CONTENT_RELOADED__?.();
+                            } catch  {}
+                        }
+                        return;
+                    }
+                    this.pendingContentReloadEntryNames = [];
+                    globalThis.__EXTJS_PENDING_CHROMIUM_CONTENT_RELOAD__ = false;
                     this.ctx.clearPendingReloadReason();
                     const now = Date.now();
                     if (this.firstSuccessfulBuildAtMs && now - this.firstSuccessfulBuildAtMs < ChromiumHardReloadPlugin.INITIAL_RELOAD_COOLDOWN_MS) return void this.logger?.info?.(`[reload] skipping early reload during startup cooldown (reason:${reason})`);
@@ -8238,7 +9056,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     });
                     const extensionRoot = this.ctx.getExtensionRoot();
                     if (extensionRoot) {
-                        const manifestReady = await (0, manifest_readiness.f)(extensionRoot, {
+                        const manifestReady = await (0, manifest_readiness.fR)(extensionRoot, {
                             timeoutMs: 8000
                         });
                         if (!manifestReady) return void this.logger?.warn?.('[reload] manifest.json did not stabilize before hard reload');
@@ -8257,6 +9075,40 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                         this.warnedHardReloadFailure = true;
                         this.logger?.warn?.(browsers_lib_messages.WsE(this.options?.browser));
                     }
+                    if ('function' == typeof ctrl.reloadMatchingTabsForContentScripts) {
+                        const allContentRules = (0, content_script_targets.iw)(stats.compilation, extensionRoot);
+                        if (allContentRules.length > 0) {
+                            let reinjectedTabs = 0;
+                            if ('function' == typeof ctrl.reinjectMatchingTabsViaExtensionRuntime) for(let attempt = 0; attempt < 3 && 0 === reinjectedTabs; attempt++){
+                                await new Promise((resolve)=>setTimeout(resolve, 0 === attempt ? 1500 : 1000));
+                                const runtimeReinjectedTabs = await ctrl.reinjectMatchingTabsViaExtensionRuntime(allContentRules);
+                                reinjectedTabs = Math.max(reinjectedTabs, runtimeReinjectedTabs);
+                                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[reload] extension-runtime reinjected tabs after hard reload: ${runtimeReinjectedTabs}`);
+                            }
+                            if (0 === reinjectedTabs && 'function' == typeof ctrl.getLastRuntimeReinjectionReport) {
+                                const runtimeReport = ctrl.getLastRuntimeReinjectionReport();
+                                if (runtimeReport) this.logger?.debug?.(`[reload] extension-runtime reinjection report: ${JSON.stringify(runtimeReport)}`);
+                            }
+                            if (0 === reinjectedTabs && 'function' == typeof ctrl.reloadMatchingTabsForContentScripts) {
+                                reinjectedTabs = await ctrl.reloadMatchingTabsForContentScripts(allContentRules, {
+                                    allowCoarseCleanup: false
+                                });
+                                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[reload] direct reinjected tabs after hard reload: ${reinjectedTabs}`);
+                            }
+                            if (reinjectedTabs > 0 && 'function' == typeof ctrl.reloadMatchingTabsForContentScripts) {
+                                const pageReloadedTabs = await ctrl.reloadMatchingTabsForContentScripts(allContentRules, {
+                                    preferPageReload: true
+                                });
+                                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(`[reload] page reloaded tabs after direct reinjection: ${pageReloadedTabs}`);
+                            }
+                            if (0 === reinjectedTabs && 'function' == typeof ctrl.reloadMatchingTabsForContentScripts) for(let attempt = 0; attempt < 3; attempt++){
+                                await new Promise((resolve)=>setTimeout(resolve, 0 === attempt ? 1500 : 2000));
+                                await ctrl.reloadMatchingTabsForContentScripts(allContentRules, {
+                                    preferPageReload: true
+                                });
+                            }
+                        }
+                    }
                 });
             }
             refreshSWFromManifest(compilation) {
@@ -8273,12 +9125,164 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     }
                 } catch  {}
             }
-            refreshServiceWorkerSourceDependencyPaths(compilation) {
+            collectServiceWorkerSourceSignatures() {
+                return this.collectSourceSignaturesFromPaths(this.serviceWorkerSourceDependencyPaths);
+            }
+            collectManifestSourceSignatures(compiler) {
+                return this.collectSourceSignaturesFromPaths(this.getWatchedManifestSourcePaths(compiler));
+            }
+            collectLocaleSourceSignatures(compiler) {
+                const compilerContextRoot = String(compiler?.options?.context || '').replace(/\\/g, '/');
+                if (!compilerContextRoot) return new Map();
+                const localesRoot = external_path_.join(compilerContextRoot, 'src', '_locales');
+                const discoveredLocaleFiles = [];
+                const walk = (dirPath)=>{
+                    let entries;
+                    try {
+                        entries = external_fs_.readdirSync(dirPath, {
+                            withFileTypes: true
+                        });
+                    } catch  {
+                        return;
+                    }
+                    for (const entry of entries){
+                        const absoluteEntryPath = external_path_.join(dirPath, entry.name);
+                        if (entry.isDirectory()) {
+                            walk(absoluteEntryPath);
+                            continue;
+                        }
+                        if (entry.isFile() && absoluteEntryPath.endsWith('.json')) discoveredLocaleFiles.push(absoluteEntryPath.replace(/\\/g, '/'));
+                    }
+                };
+                walk(localesRoot);
+                return this.collectSourceSignaturesFromPaths(discoveredLocaleFiles);
+            }
+            collectSourceSignaturesFromPaths(dependencyPaths) {
+                const signatures = new Map();
+                for (const dependencyPath of dependencyPaths){
+                    const normalizedDependencyPath = String(dependencyPath).replace(/\\/g, '/');
+                    const signature = this.readSourceFileSignature(normalizedDependencyPath);
+                    if (signature) signatures.set(normalizedDependencyPath, signature);
+                }
+                return signatures;
+            }
+            collectContentScriptSourceDependencyPaths(compilation) {
+                return (0, content_script_targets.im)(compilation);
+            }
+            collectContentScriptSourceSignatures(dependencyPathsByEntry) {
+                const nextSignatures = new Map();
+                for (const [entryName, dependencyPaths] of dependencyPathsByEntry.entries()){
+                    const signatures = new Map();
+                    for (const dependencyPath of dependencyPaths){
+                        const signature = this.readSourceFileSignature(dependencyPath);
+                        if (signature) signatures.set(dependencyPath, signature);
+                    }
+                    nextSignatures.set(entryName, signatures);
+                }
+                return nextSignatures;
+            }
+            inferContentReloadEntryNamesFromSourceSignatures() {
+                const changedEntries = new Set();
+                for (const [entryName, dependencySignatures] of this.contentScriptSourceSignaturesByEntry.entries())for (const [dependencyPath, previousSignature] of dependencySignatures){
+                    const nextSignature = this.readSourceFileSignature(dependencyPath);
+                    if (!nextSignature || nextSignature !== previousSignature) {
+                        changedEntries.add(entryName);
+                        break;
+                    }
+                }
+                return Array.from(changedEntries).sort();
+            }
+            inferContentReloadEntryNamesFromOutputSignatures(nextOutputSignaturesByEntry) {
+                const changedEntries = new Set();
+                for (const [entryName, nextOutputSignatures] of nextOutputSignaturesByEntry.entries()){
+                    const previousOutputSignatures = this.contentScriptOutputSignaturesByEntry.get(entryName);
+                    if (previousOutputSignatures && 0 !== previousOutputSignatures.size) {
+                        if (previousOutputSignatures.size !== nextOutputSignatures.size) {
+                            changedEntries.add(entryName);
+                            continue;
+                        }
+                        for (const [outputFile, previousSignature] of previousOutputSignatures){
+                            const nextSignature = nextOutputSignatures.get(outputFile);
+                            if (!nextSignature || nextSignature !== previousSignature) {
+                                changedEntries.add(entryName);
+                                break;
+                            }
+                        }
+                    }
+                }
+                return Array.from(changedEntries).sort();
+            }
+            inferHardReloadReasonFromSourceSignatures(compiler) {
+                const nextManifestSourceSignatures = this.collectManifestSourceSignatures(compiler);
+                if (this.haveSourceSignaturesChanged(this.manifestSourceSignatures, nextManifestSourceSignatures)) return 'manifest';
+                const nextLocaleSourceSignatures = this.collectLocaleSourceSignatures(compiler);
+                if (this.haveSourceSignaturesChanged(this.localeSourceSignatures, nextLocaleSourceSignatures)) return 'locales';
+                const nextServiceWorkerSourceSignatures = this.collectServiceWorkerSourceSignatures();
+                if (this.haveSourceSignaturesChanged(this.serviceWorkerSourceSignatures, nextServiceWorkerSourceSignatures)) return 'sw';
+            }
+            haveSourceSignaturesChanged(previousSignatures, nextSignatures) {
+                if (0 === previousSignatures.size) return false;
+                if (previousSignatures.size !== nextSignatures.size) return true;
+                for (const [dependencyPath, previousSignature] of previousSignatures){
+                    const nextSignature = nextSignatures.get(dependencyPath);
+                    if (!nextSignature || nextSignature !== previousSignature) return true;
+                }
+                return false;
+            }
+            inferContentReloadEntryNamesFromChangedAssets(changedAssets) {
+                const entries = new Set();
+                for (const assetName of changedAssets){
+                    const normalizedAssetName = String(assetName || '').replace(/\\/g, '/');
+                    const canonicalAsset = (0, contracts.es)(normalizedAssetName);
+                    if (canonicalAsset) {
+                        entries.add((0, contracts.Y0)(canonicalAsset.index));
+                        continue;
+                    }
+                    const hotMatch = /^hot\/content_scripts\/content-(\d+)\.[^.]+\.json$/.exec(normalizedAssetName);
+                    if (!hotMatch) {
+                        if (!(0, content_script_targets.HE)(normalizedAssetName)) continue;
+                    }
+                    if (hotMatch) entries.add((0, contracts.Y0)(Number(hotMatch[1])));
+                }
+                return Array.from(entries);
+            }
+            inferHardReloadReasonFromChangedAssets(changedAssets) {
+                for (const assetName of changedAssets){
+                    const normalizedAssetName = String(assetName || '').replace(/\\/g, '/');
+                    if (normalizedAssetName) {
+                        if ('manifest.json' === normalizedAssetName) return 'manifest';
+                        if (/(^|\/)_locales\/.+\.json$/i.test(normalizedAssetName)) return 'locales';
+                        if (/(^|\/)background\/(service_worker|script)\.(m?js|cjs)$/i.test(normalizedAssetName)) return 'sw';
+                    }
+                }
+            }
+            readSourceFileSignature(absoluteFilePath) {
                 try {
-                    const serviceWorkerEntrypointName = 'background/service_worker';
-                    const discovered = this.collectEntrypointModuleResourcePaths(compilation, serviceWorkerEntrypointName);
-                    this.serviceWorkerSourceDependencyPaths = discovered;
-                } catch  {}
+                    const stats = external_fs_.statSync(absoluteFilePath);
+                    if (!stats.isFile()) return;
+                    return `${stats.size}:${stats.mtimeMs}`;
+                } catch  {
+                    return;
+                }
+            }
+            collectContentScriptOutputSignatures(compilation, extensionRoot) {
+                const outputSignaturesByEntry = new Map();
+                const entrypoints = compilation?.entrypoints;
+                if (!entrypoints || !extensionRoot) return outputSignaturesByEntry;
+                for (const [entryName] of entrypoints.entries()){
+                    if (!(0, content_script_targets.wH)(entryName)) continue;
+                    const entryFiles = this.collectEntrypointFiles(compilation, [
+                        entryName
+                    ], extensionRoot);
+                    const outputSignatures = new Map();
+                    for (const entryFile of entryFiles){
+                        const absoluteEntryFilePath = external_path_.join(extensionRoot, entryFile);
+                        const signature = this.readSourceFileSignature(absoluteEntryFilePath);
+                        if (signature) outputSignatures.set(entryFile, signature);
+                    }
+                    if (outputSignatures.size > 0) outputSignaturesByEntry.set(entryName, outputSignatures);
+                }
+                return outputSignaturesByEntry;
             }
             collectEntrypointModuleResourcePaths(compilation, entrypointName) {
                 const collectedResourcePaths = new Set();
@@ -8291,15 +9295,175 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 for (const chunk of entrypointChunks){
                     const modulesIterable = chunkGraph.getChunkModulesIterable?.(chunk) || chunkGraph.getChunkModulesIterableBySourceType?.(chunk, "javascript") || chunkGraph.getChunkModules?.(chunk);
                     if (modulesIterable) for (const module of modulesIterable){
-                        const resourcePath = module?.resource || module?.rootModule?.resource || module?.originalSource?.()?.resource;
-                        if ('string' == typeof resourcePath && resourcePath.length > 0) collectedResourcePaths.add(resourcePath.replace(/\\/g, '/'));
+                        const resourcePath = (0, content_script_targets.Rt)(module?.resource || module?.rootModule?.resource || module?.originalSource?.()?.resource);
+                        if (resourcePath) collectedResourcePaths.add(resourcePath);
                     }
                 }
                 return collectedResourcePaths;
             }
+            collectEntrypointFiles(compilation, entrypointNames, extensionRoot) {
+                const entrypoints = compilation?.entrypoints;
+                if (!entrypoints) return this.deriveCanonicalContentEntryFiles(entrypointNames, extensionRoot);
+                const collectedFiles = new Set();
+                for (const entrypointName of entrypointNames){
+                    const entrypoint = entrypoints.get?.(entrypointName);
+                    const entryFiles = 'function' == typeof entrypoint?.getFiles ? entrypoint.getFiles() : [];
+                    for (const file of entryFiles){
+                        const normalizedFile = String(file || '').replace(/\\/g, '/');
+                        if (!(!normalizedFile || normalizedFile.endsWith('.map'))) {
+                            if (!normalizedFile.startsWith('hot/')) collectedFiles.add(normalizedFile);
+                        }
+                    }
+                }
+                if (0 === collectedFiles.size) return this.deriveCanonicalContentEntryFiles(entrypointNames, extensionRoot);
+                return Array.from(collectedFiles);
+            }
+            deriveCanonicalContentEntryFiles(entrypointNames, extensionRoot) {
+                const collectedFiles = new Set();
+                for (const entrypointName of entrypointNames){
+                    const normalizedEntrypointName = String(entrypointName || '').replace(/\\/g, '/');
+                    if (normalizedEntrypointName) try {
+                        const jsRelativePath = `${normalizedEntrypointName}.js`;
+                        if (!extensionRoot || external_fs_.existsSync(external_path_.join(extensionRoot, jsRelativePath))) collectedFiles.add(jsRelativePath);
+                        if (!extensionRoot) continue;
+                        const cssRelativePath = `${normalizedEntrypointName}.css`;
+                        if (external_fs_.existsSync(external_path_.join(extensionRoot, cssRelativePath))) collectedFiles.add(cssRelativePath);
+                    } catch  {}
+                }
+                return Array.from(collectedFiles);
+            }
+            async waitForStableContentOutputs(extensionRoot, entryFiles, expectedAssetSignatures = new Map(), timeoutMs = 8000, pollIntervalMs = 150, stableReadsRequired = 2) {
+                const normalizedEntryFiles = entryFiles.map((file)=>String(file || '').replace(/\\/g, '/')).filter(Boolean);
+                if (0 === normalizedEntryFiles.length) return true;
+                const start = Date.now();
+                let lastSignature = '';
+                let stableReads = 0;
+                while(Date.now() - start < timeoutMs){
+                    const referencedFiles = new Set(normalizedEntryFiles);
+                    const signatureParts = [];
+                    let allFilesReady = true;
+                    for (const entryFile of normalizedEntryFiles){
+                        const absoluteEntryFilePath = external_path_.join(extensionRoot, entryFile);
+                        const source = this.readFileTextSafe(absoluteEntryFilePath);
+                        const expectedAssetSignature = expectedAssetSignatures.get(entryFile);
+                        const signature = expectedAssetSignature ? this.readTextSignature(source) : this.readStableFileSignature(absoluteEntryFilePath);
+                        if (!signature) {
+                            allFilesReady = false;
+                            break;
+                        }
+                        if (expectedAssetSignature && signature !== expectedAssetSignature) {
+                            allFilesReady = false;
+                            break;
+                        }
+                        signatureParts.push(`${entryFile}:${signature}`);
+                        if (entryFile.endsWith('.js')) {
+                            if (!source) {
+                                allFilesReady = false;
+                                break;
+                            }
+                            for (const referencedFile of this.extractReferencedOutputFiles(source))referencedFiles.add(referencedFile);
+                        }
+                    }
+                    if (!allFilesReady) {
+                        lastSignature = '';
+                        stableReads = 0;
+                        await new Promise((resolve)=>setTimeout(resolve, pollIntervalMs));
+                        continue;
+                    }
+                    for (const referencedFile of referencedFiles){
+                        if (normalizedEntryFiles.includes(referencedFile)) continue;
+                        const absoluteReferencedFilePath = external_path_.join(extensionRoot, referencedFile);
+                        const signature = this.readStableFileSignature(absoluteReferencedFilePath);
+                        if (!signature) {
+                            allFilesReady = false;
+                            break;
+                        }
+                        signatureParts.push(`${referencedFile}:${signature}`);
+                    }
+                    if (!allFilesReady) {
+                        lastSignature = '';
+                        stableReads = 0;
+                        await new Promise((resolve)=>setTimeout(resolve, pollIntervalMs));
+                        continue;
+                    }
+                    const currentSignature = signatureParts.sort().join('|');
+                    if (currentSignature === lastSignature) stableReads += 1;
+                    else {
+                        lastSignature = currentSignature;
+                        stableReads = 1;
+                    }
+                    if (stableReads >= stableReadsRequired) return true;
+                    await new Promise((resolve)=>setTimeout(resolve, pollIntervalMs));
+                }
+                return false;
+            }
+            readStableFileSignature(absoluteFilePath) {
+                try {
+                    const stats = external_fs_.statSync(absoluteFilePath);
+                    if (!stats.isFile()) return;
+                    return `${stats.size}:${stats.mtimeMs}`;
+                } catch  {
+                    return;
+                }
+            }
+            readFileTextSafe(absoluteFilePath) {
+                try {
+                    return external_fs_.readFileSync(absoluteFilePath, 'utf-8');
+                } catch  {
+                    return;
+                }
+            }
+            collectAssetTextSignatures(compilation, assetNames) {
+                const signatures = new Map();
+                for (const assetName of assetNames){
+                    const normalizedAssetName = String(assetName || '').replace(/\\/g, '/');
+                    if (normalizedAssetName) try {
+                        const asset = compilation.getAsset?.(normalizedAssetName) || compilation?.assets?.[normalizedAssetName];
+                        const source = asset && 'function' == typeof asset.source?.source ? asset.source.source() : asset && 'function' == typeof asset.source ? asset.source() : void 0;
+                        const signature = this.readTextSignature('string' == typeof source || Buffer.isBuffer(source) ? source.toString() : void 0);
+                        if (signature) signatures.set(normalizedAssetName, signature);
+                    } catch  {}
+                }
+                return signatures;
+            }
+            collectContentScriptSourceOverrides(compilation, rules) {
+                const overrides = {};
+                for (const rule of rules){
+                    const bundleId = (0, contracts.Y0)(rule.index);
+                    const assetName = `${bundleId}.js`;
+                    try {
+                        const asset = compilation.getAsset?.(assetName) || compilation?.assets?.[assetName];
+                        const source = asset && 'function' == typeof asset.source?.source ? asset.source.source() : asset && 'function' == typeof asset.source ? asset.source() : void 0;
+                        const text = 'string' == typeof source || Buffer.isBuffer(source) ? source.toString() : '';
+                        if (text) overrides[bundleId] = text;
+                    } catch  {}
+                }
+                return overrides;
+            }
+            readTextSignature(source) {
+                if ('string' != typeof source) return;
+                let hash = 0;
+                for(let index = 0; index < source.length; index++)hash = 31 * hash + source.charCodeAt(index) >>> 0;
+                return `${source.length}:${hash.toString(16)}`;
+            }
+            extractReferencedOutputFiles(source) {
+                const matches = source.match(/(?:content_scripts|assets)\/[^"'`\s)]+\.(?:css|js|json|png|jpg|jpeg|svg|gif|webp|ico|avif)/g);
+                return Array.from(new Set(matches || []));
+            }
             shouldEmitReloadActionEvent() {
                 return Boolean(this.options?.source || this.options?.watchSource);
             }
+            broadcastSourceWatchMessage(compiler, payload) {
+                const webSocketServer = compiler?.options?.webSocketServer;
+                const clients = webSocketServer?.clients;
+                if (!clients || 'function' != typeof clients.forEach) return;
+                const message = JSON.stringify(payload);
+                clients.forEach((client)=>{
+                    try {
+                        if ('function' == typeof client?.send) client.send(message);
+                    } catch  {}
+                });
+            }
             constructor(options, ctx){
                 chromium_hard_reload_define_property(this, "options", void 0);
                 chromium_hard_reload_define_property(this, "ctx", void 0);
@@ -8308,17 +9472,89 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 chromium_hard_reload_define_property(this, "warnedHardReloadFailure", void 0);
                 chromium_hard_reload_define_property(this, "hasCompletedSuccessfulBuild", void 0);
                 chromium_hard_reload_define_property(this, "firstSuccessfulBuildAtMs", void 0);
+                chromium_hard_reload_define_property(this, "contentReloadGeneration", void 0);
+                chromium_hard_reload_define_property(this, "contentReloadQuietPeriodMs", void 0);
+                chromium_hard_reload_define_property(this, "contentReloadFollowupMs", void 0);
+                chromium_hard_reload_define_property(this, "lastWatchIncludedContentChanges", void 0);
+                chromium_hard_reload_define_property(this, "awaitingSettledContentBuild", void 0);
                 chromium_hard_reload_define_property(this, "serviceWorkerSourceDependencyPaths", void 0);
+                chromium_hard_reload_define_property(this, "serviceWorkerSourceSignatures", void 0);
+                chromium_hard_reload_define_property(this, "manifestSourceSignatures", void 0);
+                chromium_hard_reload_define_property(this, "localeSourceSignatures", void 0);
+                chromium_hard_reload_define_property(this, "contentScriptSourceDependencyPathsByEntry", void 0);
+                chromium_hard_reload_define_property(this, "contentScriptSourceSignaturesByEntry", void 0);
+                chromium_hard_reload_define_property(this, "contentScriptOutputSignaturesByEntry", void 0);
+                chromium_hard_reload_define_property(this, "pendingContentReloadEntryNames", void 0);
                 this.options = options;
                 this.ctx = ctx;
                 this.hasCompletedSuccessfulBuild = false;
                 this.firstSuccessfulBuildAtMs = null;
+                this.contentReloadGeneration = 0;
+                this.contentReloadQuietPeriodMs = 1200;
+                this.contentReloadFollowupMs = 1200;
+                this.lastWatchIncludedContentChanges = false;
+                this.awaitingSettledContentBuild = false;
                 this.serviceWorkerSourceDependencyPaths = new Set();
+                this.serviceWorkerSourceSignatures = new Map();
+                this.manifestSourceSignatures = new Map();
+                this.localeSourceSignatures = new Map();
+                this.contentScriptSourceDependencyPathsByEntry = new Map();
+                this.contentScriptSourceSignaturesByEntry = new Map();
+                this.contentScriptOutputSignaturesByEntry = new Map();
+                this.pendingContentReloadEntryNames = [];
             }
         }
         chromium_hard_reload_define_property(ChromiumHardReloadPlugin, "INITIAL_RELOAD_COOLDOWN_MS", 5000);
         var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
         var cdp_client = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-source-inspection/cdp-client.ts");
+        const CONTENT_HTML_HINT_RE = /(id=\"extension-root\"|data-extension-root=|content_script|content_title|js-probe|data-extjs-last-reinject-status=\"mounted\"|data-extjs-reinject-marker=)/i;
+        async function extractPageHtml(cdpClient, sessionId, logSamples = 'true' === process.env.EXTENSION_AUTHOR_MODE, includeShadow = 'open-only') {
+            let html = await cdpClient.getPageHTML(sessionId, includeShadow);
+            if (!html) try {
+                const targets = await cdpClient.getTargets();
+                const fallbackTarget = targets.find((target)=>'page' === target.type && /example\.com|http/.test(String(target.url || '')));
+                if (fallbackTarget && fallbackTarget.targetId) {
+                    const newSessionId = await cdpClient.attachToTarget(fallbackTarget.targetId);
+                    await cdpClient.waitForContentScriptInjection(newSessionId);
+                    const retryHtml = await cdpClient.getPageHTML(newSessionId, includeShadow);
+                    if (logSamples) {
+                        const sample2 = (retryHtml || '').slice(0, 200).replace(/\n/g, ' ');
+                        console.log(browsers_lib_messages.LcW(sample2));
+                    }
+                    if (retryHtml) return retryHtml;
+                }
+            } catch  {}
+            if (!html || !CONTENT_HTML_HINT_RE.test(html)) for(let i = 0; i < 1; i++){
+                await new Promise((r)=>setTimeout(r, 250));
+                try {
+                    const againHtml = await cdpClient.getPageHTML(sessionId, includeShadow);
+                    if (logSamples) {
+                        const sample3 = (againHtml || '').slice(0, 200).replace(/\n/g, ' ');
+                        console.log(browsers_lib_messages.jUj(sample3));
+                    }
+                    if (againHtml && CONTENT_HTML_HINT_RE.test(againHtml)) {
+                        html = againHtml;
+                        break;
+                    }
+                } catch  {}
+            }
+            if (!html || 0 === html.trim().length) for(let i = 0; i < 2; i++){
+                try {
+                    const evaluatedHtml = await cdpClient.evaluate(sessionId, '(() => { try { return String(document.documentElement.outerHTML||"") } catch(e) { return "" } })()');
+                    if (logSamples) {
+                        const sample4 = (evaluatedHtml || '').slice(0, 200).replace(/\n/g, ' ');
+                        console.log(browsers_lib_messages.jUj(sample4));
+                    }
+                    if (evaluatedHtml && evaluatedHtml.trim().length > 0) {
+                        html = evaluatedHtml;
+                        break;
+                    }
+                } catch  {}
+                await new Promise((r)=>setTimeout(r, 200));
+            }
+            if (logSamples) console.log(browsers_lib_messages.ehY());
+            return html || '';
+        }
         var instance_registry = __webpack_require__("./webpack/plugin-browsers/browsers-lib/instance-registry.ts");
         var discovery = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-source-inspection/discovery.ts");
         async function waitForChromeRemoteDebugging(port, instanceId) {
@@ -8346,10 +9582,21 @@ Set background.noDynamicEntryWarning to true to disable this warning.
             }
             throw new Error(browsers_lib_messages.olb(port));
         }
+        function normalizeInspectableUrl(rawUrl) {
+            try {
+                const parsed = new URL(String(rawUrl || ''));
+                if (('http:' === parsed.protocol || 'https:' === parsed.protocol) && '/' === parsed.pathname) parsed.pathname = '';
+                parsed.hash = '';
+                return parsed.toString();
+            } catch  {
+                return String(rawUrl || '').trim().replace(/\/$/, '');
+            }
+        }
         async function ensureTargetAndSession(cdpClient, url, options) {
             const forceNavigate = Boolean(options?.forceNavigate);
+            const normalizedUrl = normalizeInspectableUrl(url);
             const targets = await cdpClient.getTargets();
-            const existingTarget = (targets || []).find((t)=>String(t?.url || '') === url && 'page' === String(t?.type || ''));
+            const existingTarget = (targets || []).find((t)=>normalizeInspectableUrl(String(t?.url || '')) === normalizedUrl && 'page' === String(t?.type || ''));
             let targetId = '';
             if (existingTarget && existingTarget.targetId) {
                 targetId = String(existingTarget.targetId);
@@ -8376,70 +9623,23 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     try {
                         await cdpClient.enableRuntimeAndLog(String(tempSession));
                     } catch  {}
-                    await cdpClient.navigate(String(tempSession), url);
-                }
-            }
-            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(browsers_lib_messages.MjP());
-            const sessionId = String(await cdpClient.attachToTarget(targetId) || '');
-            if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
-                console.log(browsers_lib_messages.v5i(sessionId));
-                console.log(browsers_lib_messages._JL());
-            }
-            await cdpClient.sendCommand('Page.enable', {}, sessionId);
-            try {
-                await cdpClient.enableRuntimeAndLog(sessionId);
-            } catch  {}
-            return {
-                targetId: String(targetId),
-                sessionId: String(sessionId)
-            };
-        }
-        async function extractPageHtml(cdpClient, sessionId, logSamples = 'true' === process.env.EXTENSION_AUTHOR_MODE, includeShadow = 'open-only') {
-            let html = await cdpClient.getPageHTML(sessionId, includeShadow);
-            if (!html) try {
-                const targets = await cdpClient.getTargets();
-                const fallbackTarget = targets.find((target)=>'page' === target.type && /example\.com|http/.test(String(target.url || '')));
-                if (fallbackTarget && fallbackTarget.targetId) {
-                    const newSessionId = await cdpClient.attachToTarget(fallbackTarget.targetId);
-                    await cdpClient.waitForContentScriptInjection(newSessionId);
-                    const retryHtml = await cdpClient.getPageHTML(newSessionId, includeShadow);
-                    if (logSamples) {
-                        const sample2 = (retryHtml || '').slice(0, 200).replace(/\n/g, ' ');
-                        console.log(browsers_lib_messages.LcW(sample2));
-                    }
-                    if (retryHtml) return retryHtml;
+                    await cdpClient.navigate(String(tempSession), url);
                 }
-            } catch  {}
-            if (!html || !/(id=\"extension-root\"|content_script|content_title|js-probe)/.test(html)) for(let i = 0; i < 3; i++){
-                await new Promise((r)=>setTimeout(r, 500));
-                try {
-                    const againHtml = await cdpClient.getPageHTML(sessionId, includeShadow);
-                    if (logSamples) {
-                        const sample3 = (againHtml || '').slice(0, 200).replace(/\n/g, ' ');
-                        console.log(browsers_lib_messages.jUj(sample3));
-                    }
-                    if (againHtml && /(id=\"extension-root\"|content_script|content_title|js-probe)/.test(againHtml)) {
-                        html = againHtml;
-                        break;
-                    }
-                } catch  {}
             }
-            if (!html || 0 === html.trim().length) for(let i = 0; i < 6; i++){
-                try {
-                    const evaluatedHtml = await cdpClient.evaluate(sessionId, '(() => { try { return String(document.documentElement.outerHTML||"") } catch(e) { return "" } })()');
-                    if (logSamples) {
-                        const sample4 = (evaluatedHtml || '').slice(0, 200).replace(/\n/g, ' ');
-                        console.log(browsers_lib_messages.jUj(sample4));
-                    }
-                    if (evaluatedHtml && evaluatedHtml.trim().length > 0) {
-                        html = evaluatedHtml;
-                        break;
-                    }
-                } catch  {}
-                await new Promise((r)=>setTimeout(r, 400));
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(browsers_lib_messages.MjP());
+            const sessionId = String(await cdpClient.attachToTarget(targetId) || '');
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
+                console.log(browsers_lib_messages.v5i(sessionId));
+                console.log(browsers_lib_messages._JL());
             }
-            if (logSamples) console.log(browsers_lib_messages.ehY());
-            return html || '';
+            await cdpClient.sendCommand('Page.enable', {}, sessionId);
+            try {
+                await cdpClient.enableRuntimeAndLog(sessionId);
+            } catch  {}
+            return {
+                targetId: String(targetId),
+                sessionId: String(sessionId)
+            };
         }
         function chromium_source_inspection_define_property(obj, key, value) {
             if (key in obj) Object.defineProperty(obj, key, {
@@ -8504,7 +9704,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 const includeShadow = 'off' !== this.devOptions.sourceIncludeShadow;
                 try {
                     const payload = await this.cdpClient.evaluate(this.currentSessionId, `(() => {
-          const rootEl = document.querySelector('#extension-root,[data-extension-root="true"]');
+          const rootEl = document.querySelector('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])');
           if (!rootEl) return null;
           const root = (${includeShadow ? 'rootEl.shadowRoot || rootEl' : 'rootEl'});
           const maxDepth = 6;
@@ -8568,6 +9768,28 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     if (payload && 'object' == typeof payload) return payload;
                 } catch  {}
             }
+            async getExtensionRootMeta() {
+                if (!this.cdpClient || !this.currentSessionId) return;
+                try {
+                    return await this.cdpClient.getExtensionRootMeta(this.currentSessionId);
+                } catch  {
+                    return;
+                }
+            }
+            async shouldEmitContentScriptInjected(injectionWaitOk) {
+                if (!injectionWaitOk || !this.cdpClient || !this.currentSessionId) return false;
+                const sessionId = this.currentSessionId;
+                const deadline = Date.now() + 2800;
+                while(Date.now() < deadline){
+                    const rootMeta = await this.cdpClient.getExtensionRootMeta(sessionId);
+                    const shadow = await this.cdpClient.getShadowStyleSnapshot(sessionId);
+                    const hasUserRoot = Boolean(rootMeta && rootMeta.rootCount >= 1);
+                    const hasShadowStyles = shadow && 'number' == typeof shadow.count && Number(shadow.count) > 0;
+                    if (hasUserRoot || hasShadowStyles) return true;
+                    await new Promise((r)=>setTimeout(r, 200));
+                }
+                return this.cdpClient.hasVisibleShadowHostContent(sessionId);
+            }
             async getPageMetaSnapshot() {
                 if (!this.cdpClient || !this.currentSessionId) return {};
                 try {
@@ -8629,7 +9851,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 const includeShadow = 'off' !== this.devOptions.sourceIncludeShadow;
                 try {
                     const payload = await this.cdpClient.evaluate(this.currentSessionId, `(() => {
-          const rootEl = document.querySelector('#extension-root,[data-extension-root="true"]');
+          const rootEl = document.querySelector('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])');
           if (!rootEl) return null;
           const root = (${includeShadow ? 'rootEl.shadowRoot || rootEl' : 'rootEl'});
           const maxDepth = 4;
@@ -8849,6 +10071,10 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 if (this.devOptions.sourceMeta) {
                     const metaSnapshot = await this.getPageMetaSnapshot();
                     this.emitEventPayload('page_meta', stage, meta, metaSnapshot);
+                    const rootMeta = await this.getExtensionRootMeta();
+                    if (rootMeta) this.emitEventPayload('extension_root_meta', stage, meta, rootMeta);
+                    const styleSnapshot = await this.getShadowStyleSnapshot();
+                    if (styleSnapshot) this.emitEventPayload('shadow_style_output', stage, meta, styleSnapshot);
                 }
                 if (Array.isArray(this.devOptions.sourceProbe)) {
                     const probes = await this.getSelectorProbes(this.devOptions.sourceProbe);
@@ -8911,6 +10137,14 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     ...payload
                 }));
             }
+            async getShadowStyleSnapshot() {
+                if (!this.cdpClient || !this.currentSessionId) return;
+                try {
+                    return await this.cdpClient.getShadowStyleSnapshot(this.currentSessionId);
+                } catch  {
+                    return;
+                }
+            }
             async getCdpPort() {
                 const instanceId = this.devOptions.instanceId;
                 return (0, shared_utils.jl)(this.devOptions.port, instanceId);
@@ -8954,30 +10188,14 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                         await this.emitSourceOutput(String(initialHtml || ''), 'pre_injection');
                     } catch  {}
                     if (this.isAuthorMode()) console.log(browsers_lib_messages.mOc());
-                    await this.cdpClient.waitForContentScriptInjection(this.currentSessionId);
-                    emitActionEvent("content_script_injected", {
+                    const injected = await this.cdpClient.waitForContentScriptInjection(this.currentSessionId);
+                    const emitInjection = await this.shouldEmitContentScriptInjected(injected);
+                    if (emitInjection) emitActionEvent("content_script_injected", {
                         url
                     });
+                    if (!injected) await this.cdpClient.pollForVisibleShadowHostContent(this.currentSessionId);
                     try {
-                        const deadline = Date.now() + 20000;
-                        const started = Date.now();
-                        while(Date.now() < deadline){
-                            const hasRoot = await this.cdpClient.evaluate(this.currentSessionId, `(() => { try {
-              const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root="true"]'));
-              if (!hosts.length) return false;
-              for (const h of hosts) {
-                try {
-                  const sr = h && h.shadowRoot;
-                  if (sr && (String(sr.innerHTML||'').length > 0)) return true;
-                } catch { /* ignore */ }
-              }
-              return false;
-            } catch { return false } })()`);
-                            if (hasRoot) break;
-                            const elapsed = Date.now() - started;
-                            const delay = elapsed < 2000 ? 150 : 500;
-                            await new Promise((r)=>setTimeout(r, delay));
-                        }
+                        await this.waitForContentScriptStyles(this.currentSessionId);
                     } catch  {}
                     const outputConfig = this.getOutputConfig();
                     const html = await extractPageHtml(this.cdpClient, this.currentSessionId, this.isAuthorMode(), outputConfig.includeShadow);
@@ -9011,14 +10229,104 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 ws.on('message', async (data)=>{
                     try {
                         const message = JSON.parse(data);
-                        if ('changedFile' === message.type && this.isWatching) await this.handleFileChange();
+                        if ('changedFile' === message.type && this.isWatching) {
+                            if (!this.pendingWatchSourceUpdate) this.pendingWatchSourceRootMeta = await this.getExtensionRootMeta().catch(()=>void 0);
+                            this.pendingWatchSourceUpdate = true;
+                        } else if ('contentReloaded' === message.type && this.isWatching) {
+                            if (this.pendingWatchSourceUpdate) {
+                                const previousRootMeta = this.pendingWatchSourceRootMeta;
+                                this.pendingWatchSourceUpdate = false;
+                                this.pendingWatchSourceRootMeta = void 0;
+                                this.scheduleWatchSourceUpdate(previousRootMeta);
+                            }
+                        }
                     } catch (error) {}
                 });
             }
             stopWatching() {
                 this.isWatching = false;
+                this.pendingWatchSourceUpdate = false;
+                this.pendingWatchSourceRootMeta = void 0;
+                if (this.watchSourceFlushTimer) {
+                    clearTimeout(this.watchSourceFlushTimer);
+                    this.watchSourceFlushTimer = null;
+                }
                 if (this.isAuthorMode()) console.log(browsers_lib_messages.Qx1());
             }
+            registerContentReloadSnapshotHook() {
+                globalThis.__EXTJS_ON_CHROMIUM_CONTENT_RELOADED__ = async ()=>{
+                    if (!this.currentSessionId || !this.hasInspectedSourceOnce) return;
+                    if (this.isWatching) return;
+                    if (this.watchSourceFlushTimer) clearTimeout(this.watchSourceFlushTimer);
+                    this.watchSourceFlushTimer = setTimeout(async ()=>{
+                        this.watchSourceFlushTimer = null;
+                        if (this.isFlushingWatchSourceUpdate || !this.currentSessionId) return;
+                        this.isFlushingWatchSourceUpdate = true;
+                        try {
+                            await this.emitImmediateUpdatedSnapshotFromCurrentSession(this.currentSessionId);
+                        } finally{
+                            this.isFlushingWatchSourceUpdate = false;
+                        }
+                    }, 0);
+                };
+            }
+            scheduleWatchSourceUpdate(previousRootMeta) {
+                if (this.watchSourceFlushTimer) clearTimeout(this.watchSourceFlushTimer);
+                this.watchSourceFlushTimer = setTimeout(async ()=>{
+                    if (this.isFlushingWatchSourceUpdate) return void this.scheduleWatchSourceUpdate(previousRootMeta);
+                    this.watchSourceFlushTimer = null;
+                    if (!this.currentSessionId) return;
+                    this.isFlushingWatchSourceUpdate = true;
+                    try {
+                        await this.emitUpdatedSnapshotFromCurrentSession(this.currentSessionId, previousRootMeta);
+                    } finally{
+                        this.isFlushingWatchSourceUpdate = false;
+                    }
+                }, 0);
+            }
+            async emitImmediateUpdatedSnapshotFromCurrentSession(sessionId) {
+                if (!this.cdpClient) return;
+                const readBuildSignature = (rootMeta)=>{
+                    const builds = [
+                        rootMeta?.page?.build,
+                        ...(rootMeta?.roots || []).map((entry)=>entry?.build),
+                        ...(rootMeta?.markers || []).map((entry)=>entry?.build),
+                        ...(rootMeta?.registries || []).map((entry)=>entry?.build)
+                    ].filter((value)=>'string' == typeof value && value.length > 0).sort();
+                    return JSON.stringify(builds);
+                };
+                const previousOutputHash = this.lastOutputHash;
+                const previousRootMeta = await this.getExtensionRootMeta().catch(()=>void 0);
+                const previousBuildSignature = readBuildSignature(previousRootMeta);
+                try {
+                    await this.waitForContentScriptStyles(sessionId);
+                } catch  {}
+                try {
+                    await this.waitForMeaningfulContentScriptContent(sessionId);
+                } catch  {}
+                let html = '';
+                const outputConfig = this.getOutputConfig();
+                const deadline = Date.now() + 5000;
+                while(Date.now() < deadline){
+                    try {
+                        html = await this.cdpClient.getPageHTML(sessionId, outputConfig.includeShadow);
+                    } catch  {
+                        await new Promise((resolve)=>setTimeout(resolve, 250));
+                        html = await this.cdpClient.getPageHTML(sessionId, outputConfig.includeShadow);
+                    }
+                    if (!html) {
+                        await new Promise((resolve)=>setTimeout(resolve, 300));
+                        html = await this.cdpClient.getPageHTML(sessionId, outputConfig.includeShadow);
+                    }
+                    const currentRootMeta = await this.getExtensionRootMeta().catch(()=>void 0);
+                    const currentBuildSignature = readBuildSignature(currentRootMeta);
+                    const htmlChanged = !previousOutputHash || hashStringFNV1a(html || '') !== previousOutputHash;
+                    const buildsChanged = previousBuildSignature.length > 2 && currentBuildSignature.length > 2 && previousBuildSignature !== currentBuildSignature;
+                    if (htmlChanged || buildsChanged) break;
+                    await new Promise((resolve)=>setTimeout(resolve, 350));
+                }
+                await this.emitSourceOutput(html || '', 'updated');
+            }
             async handleFileChange() {
                 if (!this.cdpClient || !this.currentSessionId) return void console.warn(browsers_lib_messages.MfN());
                 if (this.debounceTimer) clearTimeout(this.debounceTimer);
@@ -9029,52 +10337,188 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                             console.log(browsers_lib_messages.$xt());
                             console.log(browsers_lib_messages.Tev());
                         }
+                        'string' == typeof this.devOptions.source && 'true' !== this.devOptions.source && this.devOptions.source;
+                        const previousRootMeta = await this.getExtensionRootMeta();
+                        await new Promise((resolve)=>setTimeout(resolve, 1000));
+                        await this.waitForContentScriptReinjection(this.currentSessionId, previousRootMeta);
+                        try {
+                            await this.waitForContentScriptStyles(this.currentSessionId);
+                        } catch  {}
+                        if (this.isAuthorMode()) console.log(browsers_lib_messages.Mcx());
+                        await this.emitUpdatedSnapshotFromCurrentSession(this.currentSessionId, previousRootMeta);
+                    } catch (error) {
                         const sourceUrl = 'string' == typeof this.devOptions.source && 'true' !== this.devOptions.source ? this.devOptions.source : '';
-                        if (sourceUrl) {
+                        if (sourceUrl) try {
                             emitActionEvent('watch_reinspect_source_url', {
                                 url: sourceUrl
                             });
                             const html = await this.inspectSource(sourceUrl, {
-                                forceNavigate: true
+                                forceNavigate: false
                             });
                             await this.emitSourceOutput(html || '', 'updated');
                             return;
-                        }
-                        await this.cdpClient.waitForContentScriptInjection(this.currentSessionId);
-                        if (this.isAuthorMode()) console.log(browsers_lib_messages.Mcx());
-                        let html = '';
-                        const outputConfig = this.getOutputConfig();
-                        try {
-                            html = await this.cdpClient.getPageHTML(this.currentSessionId, outputConfig.includeShadow);
-                        } catch (e) {
-                            await new Promise((r)=>setTimeout(r, 250));
-                            try {
-                                html = await this.cdpClient.getPageHTML(this.currentSessionId, outputConfig.includeShadow);
-                            } catch  {}
-                        }
-                        if (!html) {
-                            await new Promise((r)=>setTimeout(r, 300));
-                            try {
-                                html = await this.cdpClient.getPageHTML(this.currentSessionId, outputConfig.includeShadow);
-                            } catch  {}
-                        }
-                        await this.emitSourceOutput(html || '', 'updated');
-                    } catch (error) {
+                        } catch  {}
                         console.error(browsers_lib_messages.acp(error.message));
-                        if (error.message.includes('session') || error.message.includes('target')) {
+                        const errorMessage = String(error.message || error || '');
+                        if (errorMessage.includes('session') || errorMessage.includes('target') || errorMessage.includes('WebSocket is not open') || errorMessage.includes('connection is closed')) {
                             console.log(browsers_lib_messages.bGB());
-                            await this.reconnectToTarget();
+                            await this.reconnectToTarget(sourceUrl || void 0);
                         }
                     }
                 }, 300);
             }
-            async reconnectToTarget() {
+            async waitForContentScriptReinjection(sessionId, previousRootMeta) {
+                if (!this.cdpClient) return;
+                const readBuildSignature = (rootMeta)=>{
+                    const builds = [
+                        rootMeta?.page?.build,
+                        ...(rootMeta?.roots || []).map((entry)=>entry?.build),
+                        ...(rootMeta?.markers || []).map((entry)=>entry?.build),
+                        ...(rootMeta?.registries || []).map((entry)=>entry?.build)
+                    ].filter((value)=>'string' == typeof value && value.length > 0).sort();
+                    return JSON.stringify(builds);
+                };
+                const previousGeneration = Number(previousRootMeta?.latestGeneration || 0);
+                const previousBuildSignature = readBuildSignature(previousRootMeta);
+                const deadline = Date.now() + 20000;
+                while(Date.now() < deadline){
+                    try {
+                        const rootMeta = await this.getExtensionRootMeta();
+                        if (rootMeta) {
+                            const nextBuildSignature = readBuildSignature(rootMeta);
+                            const generationAdvanced = Number(rootMeta.latestGeneration || 0) > previousGeneration;
+                            const buildAdvanced = previousBuildSignature.length > 2 && nextBuildSignature.length > 2 && previousBuildSignature !== nextBuildSignature;
+                            const pageMounted = rootMeta.page?.status === void 0 || rootMeta.page?.status === 'mounted';
+                            if ((generationAdvanced || buildAdvanced) && rootMeta.rootCount >= 1 && rootMeta.markerCount >= 1 && pageMounted) return;
+                        }
+                    } catch  {}
+                    await new Promise((resolve)=>setTimeout(resolve, 200));
+                }
+                await this.cdpClient.waitForContentScriptInjection(sessionId);
+            }
+            async emitUpdatedSnapshotFromCurrentSession(sessionId, previousRootMeta) {
+                const readBuildSignature = (rootMeta)=>{
+                    const builds = [
+                        rootMeta?.page?.build,
+                        ...(rootMeta?.roots || []).map((entry)=>entry?.build),
+                        ...(rootMeta?.markers || []).map((entry)=>entry?.build),
+                        ...(rootMeta?.registries || []).map((entry)=>entry?.build)
+                    ].filter((value)=>'string' == typeof value && value.length > 0).sort();
+                    return JSON.stringify(builds);
+                };
+                await this.waitForContentScriptReinjection(sessionId, previousRootMeta);
+                try {
+                    await this.waitForContentScriptStyles(sessionId);
+                } catch  {}
+                try {
+                    await this.waitForMeaningfulContentScriptContent(sessionId);
+                } catch  {}
+                const previousOutputHash = this.lastOutputHash;
+                const previousBuildSignature = readBuildSignature(previousRootMeta);
+                let html = '';
+                const outputConfig = this.getOutputConfig();
+                const deadline = Date.now() + 5000;
+                while(Date.now() < deadline){
+                    try {
+                        html = await this.cdpClient.getPageHTML(sessionId, outputConfig.includeShadow);
+                    } catch  {
+                        await new Promise((resolve)=>setTimeout(resolve, 250));
+                        html = await this.cdpClient.getPageHTML(sessionId, outputConfig.includeShadow);
+                    }
+                    if (!html) {
+                        await new Promise((resolve)=>setTimeout(resolve, 300));
+                        html = await this.cdpClient.getPageHTML(sessionId, outputConfig.includeShadow);
+                    }
+                    const currentRootMeta = await this.getExtensionRootMeta().catch(()=>void 0);
+                    const currentBuildSignature = readBuildSignature(currentRootMeta);
+                    const htmlChanged = !previousOutputHash || hashStringFNV1a(html || '') !== previousOutputHash;
+                    const buildsChanged = previousBuildSignature.length > 2 && currentBuildSignature.length > 2 && previousBuildSignature !== currentBuildSignature;
+                    if (htmlChanged || buildsChanged) break;
+                    await new Promise((resolve)=>setTimeout(resolve, 350));
+                }
+                await this.emitSourceOutput(html || '', 'updated');
+            }
+            async waitForMeaningfulContentScriptContent(sessionId) {
+                if (!this.cdpClient) return;
+                const deadline = Date.now() + 10000;
+                while(Date.now() < deadline){
+                    try {
+                        const hasMeaningfulContent = await this.cdpClient.evaluate(sessionId, `(() => { try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            if (!hosts.length) return false;
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const elements = Array.from(sr.querySelectorAll('*')).filter((element) => {
+                const tagName = String(element?.nodeName || '').toLowerCase();
+                return tagName !== 'style' && tagName !== 'script';
+              });
+              const hasMeaningfulText = elements.some((element) => {
+                const text = String(element?.textContent || '').replace(/\\s+/g, ' ').trim();
+                return text.length > 0;
+              });
+              if (hasMeaningfulText) return true;
+              const hasMeaningfulVisualElement = elements.some((element) => {
+                const tagName = String(element?.nodeName || '').toLowerCase();
+                return ['img', 'svg', 'canvas', 'input', 'button', 'textarea', 'select'].includes(tagName);
+              });
+              if (hasMeaningfulVisualElement) return true;
+            }
+            return false;
+          } catch { return false } })()`);
+                        if (hasMeaningfulContent) return;
+                    } catch  {}
+                    await new Promise((resolve)=>setTimeout(resolve, 200));
+                }
+            }
+            async waitForContentScriptStyles(sessionId) {
+                if (!this.cdpClient) return;
+                const deadline = Date.now() + 10000;
+                while(Date.now() < deadline){
+                    try {
+                        const hasStyles = await this.cdpClient.evaluate(sessionId, `(() => { try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            if (!hosts.length) return false;
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const styles = Array.from(sr.querySelectorAll('style'));
+              if (styles.some((styleEl) => String(styleEl.outerHTML || '').includes('<style') && String(styleEl.textContent || '').trim().length > 0)) {
+                return true;
+              }
+            }
+            return false;
+          } catch { return false } })()`);
+                        if (hasStyles) return;
+                    } catch  {}
+                    await new Promise((resolve)=>setTimeout(resolve, 200));
+                }
+            }
+            async reconnectToTarget(sourceUrl) {
                 if (!this.isAuthorMode()) return;
                 try {
-                    if (!this.cdpClient || !this.currentTargetId) return void console.warn(browsers_lib_messages.tVJ());
                     console.log(browsers_lib_messages.kGe());
-                    this.currentSessionId = await this.cdpClient.attachToTarget(this.currentTargetId) || null;
-                    console.log(browsers_lib_messages.PQY(this.currentSessionId || ''));
+                    if (!this.cdpClient || !this.cdpClient.isConnected()) {
+                        try {
+                            this.cdpClient?.disconnect();
+                        } catch  {}
+                        this.cdpClient = null;
+                        this.currentSessionId = null;
+                        await this.initialize();
+                    }
+                    if (this.cdpClient && this.currentTargetId) {
+                        this.currentSessionId = await this.cdpClient.attachToTarget(this.currentTargetId) || null;
+                        console.log(browsers_lib_messages.PQY(this.currentSessionId || ''));
+                        return;
+                    }
+                    if (sourceUrl) {
+                        await this.inspectSource(sourceUrl, {
+                            forceNavigate: false
+                        });
+                        console.log(browsers_lib_messages.PQY('source-url'));
+                        return;
+                    }
+                    console.warn(browsers_lib_messages.tVJ());
                 } catch (error) {
                     console.error(browsers_lib_messages.pcF(error.message));
                 }
@@ -9105,19 +10549,32 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                         if (this.devOptions.source && 'string' == typeof this.devOptions.source && 'true' !== this.devOptions.source) urlToInspect = this.devOptions.source;
                         else if (this.devOptions.startingUrl) urlToInspect = this.devOptions.startingUrl;
                         else throw new Error(browsers_lib_messages.Pu4());
+                        const webSocketServer = compiler.options.webSocketServer;
+                        if (this.devOptions.watchSource && this.hasInspectedSourceOnce) {
+                            if (webSocketServer) {
+                                if (!this.isWatching) await this.startWatching(webSocketServer);
+                                return;
+                            }
+                            if (this.currentSessionId) {
+                                if (globalThis.__EXTJS_PENDING_CHROMIUM_CONTENT_RELOAD__) return;
+                                const previousRootMeta = await this.getExtensionRootMeta();
+                                this.scheduleWatchSourceUpdate(previousRootMeta);
+                                return;
+                            }
+                        }
                         const html = await this.inspectSource(urlToInspect, {
                             forceNavigate: this.devOptions.watchSource && this.hasInspectedSourceOnce
                         });
                         this.hasInspectedSourceOnce = true;
                         await this.printHTML(html);
-                        const webSocketServer = compiler.options.webSocketServer;
-                        if (this.devOptions.watchSource) if (webSocketServer) await this.startWatching(webSocketServer);
-                        else try {
-                            const updated = await this.inspectSource(urlToInspect, {
-                                forceNavigate: true
-                            });
-                            await this.printUpdatedHTML(updated || '');
-                        } catch  {}
+                        if (this.devOptions.watchSource) {
+                            this.registerContentReloadSnapshotHook();
+                            if (webSocketServer) await this.startWatching(webSocketServer);
+                            else try {
+                                const previousRootMeta = await this.getExtensionRootMeta();
+                                if (this.currentSessionId) await this.emitUpdatedSnapshotFromCurrentSession(this.currentSessionId, previousRootMeta);
+                            } catch  {}
+                        }
                     } catch (error) {
                         if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.error(browsers_lib_messages.b82(error.message));
                     }
@@ -9131,7 +10588,11 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 chromium_source_inspection_define_property(this, "isInitialized", false);
                 chromium_source_inspection_define_property(this, "isWatching", false);
                 chromium_source_inspection_define_property(this, "hasInspectedSourceOnce", false);
+                chromium_source_inspection_define_property(this, "pendingWatchSourceUpdate", false);
+                chromium_source_inspection_define_property(this, "pendingWatchSourceRootMeta", void 0);
                 chromium_source_inspection_define_property(this, "debounceTimer", null);
+                chromium_source_inspection_define_property(this, "watchSourceFlushTimer", null);
+                chromium_source_inspection_define_property(this, "isFlushingWatchSourceUpdate", false);
                 chromium_source_inspection_define_property(this, "runtimeMode", void 0);
                 chromium_source_inspection_define_property(this, "lastOutputHash", void 0);
                 chromium_source_inspection_define_property(this, "lastByteLength", void 0);
@@ -9204,38 +10665,8 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 run_chromium_define_property(this, "logTab", void 0);
                 run_chromium_define_property(this, "logger", void 0);
                 run_chromium_define_property(this, "chromiumCtx", void 0);
-                this.extension = options.extension;
-                this.browser = options.browser;
-                this.startingUrl = options.startingUrl;
-                this.preferences = options.preferences;
-                this.profile = options.profile;
-                this.browserFlags = options.browserFlags;
-                this.excludeBrowserFlags = options.excludeBrowserFlags;
-                this.noOpen = options.noOpen;
+                Object.assign(this, (0, runtime_options.pA)(options));
                 this.chromiumBinary = options.chromiumBinary;
-                this.instanceId = options.instanceId;
-                this.port = options.port;
-                this.source = options.source;
-                this.watchSource = options.watchSource;
-                this.sourceFormat = options.sourceFormat;
-                this.sourceSummary = options.sourceSummary;
-                this.sourceMeta = options.sourceMeta;
-                this.sourceProbe = options.sourceProbe;
-                this.sourceTree = options.sourceTree;
-                this.sourceConsole = options.sourceConsole;
-                this.sourceDom = options.sourceDom;
-                this.sourceMaxBytes = options.sourceMaxBytes;
-                this.sourceRedact = options.sourceRedact;
-                this.sourceIncludeShadow = options.sourceIncludeShadow;
-                this.sourceDiff = options.sourceDiff;
-                this.logLevel = options.logLevel;
-                this.logContexts = options.logContexts;
-                this.logFormat = options.logFormat;
-                this.logTimestamps = options.logTimestamps;
-                this.logColor = options.logColor;
-                this.logUrl = options.logUrl;
-                this.logTab = options.logTab;
-                this.dryRun = options.dryRun;
             }
         }
         var firefox_context = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-context/index.ts");
@@ -9288,17 +10719,65 @@ Set background.noDynamicEntryWarning to true to disable this warning.
             return obj;
         }
         class FirefoxHardReloadPlugin {
+            getWatchedManifestSourcePaths(compiler) {
+                const compilerContextRoot = String(compiler?.options?.context || '').replace(/\\/g, '/');
+                if (!compilerContextRoot) return [];
+                return [
+                    `${compilerContextRoot}/manifest.json`,
+                    `${compilerContextRoot}/src/manifest.json`
+                ];
+            }
             apply(compiler) {
                 if (compiler?.hooks?.watchRun?.tapAsync) compiler.hooks.watchRun.tapAsync('run-browsers:watch', (compilation, done)=>{
                     try {
+                        this.contentReloadGeneration += 1;
                         const files = compilation?.modifiedFiles || new Set();
                         const normalized = Array.from(files).map((p)=>String(p).replace(/\\/g, '/'));
-                        const hitManifest = normalized.some((p)=>/(^|\/)manifest\.json$/i.test(p));
-                        const hitLocales = normalized.some((p)=>/(^|\/)__?locales\/.+\.json$/i.test(p));
-                        const hitServiceWorker = normalized.some((p)=>/(^|\/)(service_worker|background)\.(m?js|cjs|ts)$/i.test(p));
-                        if (hitManifest) this.ctx.setPendingReloadReason?.('manifest');
-                        else if (hitLocales) this.ctx.setPendingReloadReason?.('locales');
-                        else if (hitServiceWorker) this.ctx.setPendingReloadReason?.('sw');
+                        const compilerContextRoot = String(compiler?.options?.context || '').replace(/\\/g, '/');
+                        const filesInCurrentCompilerContext = compilerContextRoot ? normalized.filter((filePath)=>filePath === compilerContextRoot || filePath.startsWith(`${compilerContextRoot}/`)) : normalized;
+                        const normalizedOutputPath = String(compiler?.options?.output?.path || '').replace(/\\/g, '/');
+                        const watchedModifiedFilePaths = compilerContextRoot ? filesInCurrentCompilerContext : normalized;
+                        const sourceModifiedFilePaths = watchedModifiedFilePaths.filter((filePath)=>!(normalizedOutputPath && (filePath === normalizedOutputPath || filePath.startsWith(`${normalizedOutputPath}/`))));
+                        const normalizedManifestSourcePaths = this.getWatchedManifestSourcePaths(compiler);
+                        const hitManifest = sourceModifiedFilePaths.some((filePath)=>{
+                            if (normalizedManifestSourcePaths.length > 0) return normalizedManifestSourcePaths.includes(filePath);
+                            return /(^|\/)manifest\.json$/i.test(filePath);
+                        });
+                        const hitLocales = sourceModifiedFilePaths.some((filePath)=>{
+                            if (compilerContextRoot) return filePath.startsWith(`${compilerContextRoot}/src/_locales/`);
+                            return /(^|\/)__?locales\/.+\.json$/i.test(filePath);
+                        });
+                        const hitServiceWorker = sourceModifiedFilePaths.some((p)=>/(^|\/)(service_worker|background)\.(m?js|cjs|ts)$/i.test(p));
+                        if (hitManifest) {
+                            this.pendingContentReloadEntryNames = [];
+                            this.ctx.setPendingReloadReason?.('manifest');
+                        } else if (hitLocales) {
+                            this.pendingContentReloadEntryNames = [];
+                            this.ctx.setPendingReloadReason?.('locales');
+                        } else if (hitServiceWorker) {
+                            this.pendingContentReloadEntryNames = [];
+                            this.ctx.setPendingReloadReason?.('sw');
+                        } else {
+                            const changedContentEntries = (0, content_script_targets.JY)(sourceModifiedFilePaths, this.contentScriptSourceDependencyPathsByEntry);
+                            this.lastWatchIncludedContentChanges = changedContentEntries.length > 0;
+                            if (changedContentEntries.length > 0) {
+                                this.pendingContentReloadEntryNames = changedContentEntries;
+                                this.awaitingSettledContentBuild = true;
+                                globalThis.__EXTJS_PENDING_FIREFOX_CONTENT_RELOAD__ = true;
+                            }
+                            if (this.shouldEmitReloadActionEvent()) emitActionEvent('reload_debug', {
+                                phase: 'watch',
+                                browser: this.host.browser,
+                                sourceModifiedFilePaths,
+                                hitManifest,
+                                hitLocales,
+                                hitServiceWorker,
+                                changedContentEntries,
+                                pendingContentReloadEntryNames: [
+                                    ...this.pendingContentReloadEntryNames
+                                ]
+                            });
+                        }
                     } catch (error) {
                         this.ctx.logger?.warn?.('[reload] watchRun inspect failed:', String(error));
                     }
@@ -9309,43 +10788,600 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     if (hasErrors) return void done();
                     try {
                         const compilation = stats?.compilation;
-                        const assetsArr = Array.isArray(compilation?.getAssets?.()) ? compilation.getAssets() : [];
-                        const changed = assetsArr.filter((a)=>a?.emitted).map((a)=>String(a?.name || ''));
+                        const inferredHardReloadReason = this.inferHardReloadReasonFromSourceSignatures(compiler);
+                        const nextManifestSourceSignatures = this.collectManifestSourceSignatures(compiler);
+                        const nextLocaleSourceSignatures = this.collectLocaleSourceSignatures(compiler);
+                        const nextServiceWorkerSourceDependencyPaths = this.collectEntrypointModuleResourcePaths(compilation, 'background/service_worker');
+                        const nextServiceWorkerSourceSignatures = this.collectSourceSignaturesFromPaths(nextServiceWorkerSourceDependencyPaths);
+                        this.refreshContentScriptSourceDependencyPaths(compilation);
+                        this.serviceWorkerSourceDependencyPaths = nextServiceWorkerSourceDependencyPaths;
+                        this.serviceWorkerSourceSignatures = nextServiceWorkerSourceSignatures;
+                        this.manifestSourceSignatures = nextManifestSourceSignatures;
+                        this.localeSourceSignatures = nextLocaleSourceSignatures;
+                        const changed = this.collectChangedAssetNames(compilation);
+                        const contentScriptOutputRoot = this.ctx.getExtensionRoot() || String(compilation?.options?.output?.path || '');
+                        const nextContentScriptOutputSignatures = this.collectContentScriptOutputSignatures(compilation, contentScriptOutputRoot || void 0);
+                        const inferredEntryNamesFromOutputSignatures = this.inferContentReloadEntryNamesFromOutputSignatures(nextContentScriptOutputSignatures);
                         const controller = this.host?.rdpController;
+                        if (!this.hasSeenFirstSuccessfulDone) {
+                            this.hasSeenFirstSuccessfulDone = true;
+                            this.contentScriptOutputSignaturesByEntry = nextContentScriptOutputSignatures;
+                            this.pendingContentReloadEntryNames = [];
+                            this.awaitingSettledContentBuild = false;
+                            this.lastWatchIncludedContentChanges = false;
+                            this.ctx.clearPendingReloadReason?.();
+                            if (controller && 'function' == typeof controller.reloadMatchingTabsForContentScripts) {
+                                const allRules = (0, content_script_targets.iw)(compilation, this.ctx.getExtensionRoot());
+                                if (allRules.length > 0) controller.reloadMatchingTabsForContentScripts(allRules).catch(()=>{});
+                            }
+                            done();
+                            return;
+                        }
                         if (controller && 'function' == typeof controller.hardReload) {
-                            const reason = this.ctx.getPendingReloadReason?.();
+                            const inferredAssetReason = this.inferHardReloadReasonFromChangedAssets(this.pendingContentReloadEntryNames.length > 0 ? changed.filter((a)=>'manifest.json' !== String(a || '').replace(/\\/g, '/')) : changed);
+                            const reason = this.ctx.getPendingReloadReason?.() || inferredHardReloadReason || inferredAssetReason;
+                            const inferredEntryNames = Array.from(new Set([
+                                ...this.inferContentReloadEntryNamesFromChangedAssets(changed),
+                                ...inferredEntryNamesFromOutputSignatures
+                            ]));
+                            this.contentScriptOutputSignaturesByEntry = nextContentScriptOutputSignatures;
+                            const targetEntryNames = this.pendingContentReloadEntryNames.length > 0 ? [
+                                ...this.pendingContentReloadEntryNames
+                            ] : inferredEntryNames;
+                            if (this.shouldEmitReloadActionEvent()) emitActionEvent('reload_debug', {
+                                phase: 'done',
+                                browser: this.host.browser,
+                                reason: reason || null,
+                                pendingContentReloadEntryNames: [
+                                    ...this.pendingContentReloadEntryNames
+                                ],
+                                inferredEntryNamesFromOutputSignatures,
+                                inferredEntryNames,
+                                targetEntryNames,
+                                changedAssets: changed
+                            });
+                            if (!reason && 0 === targetEntryNames.length) {
+                                this.pendingContentReloadEntryNames = [];
+                                this.awaitingSettledContentBuild = false;
+                                this.lastWatchIncludedContentChanges = false;
+                                done();
+                                return;
+                            }
+                            if (!reason && targetEntryNames.length > 0 && 'function' == typeof controller.reloadMatchingTabsForContentScripts) {
+                                const selectedEntryNames = targetEntryNames;
+                                const selectedGeneration = this.contentReloadGeneration;
+                                const selectedRules = (0, content_script_targets.Il)((0, content_script_targets.iw)(compilation, this.ctx.getExtensionRoot()), selectedEntryNames);
+                                if (selectedRules.length > 0) {
+                                    if (this.lastWatchIncludedContentChanges && this.contentReloadQuietPeriodMs > 0) {
+                                        await new Promise((resolve)=>setTimeout(resolve, this.contentReloadQuietPeriodMs));
+                                        if (selectedGeneration !== this.contentReloadGeneration) return void done();
+                                    }
+                                    await controller.reloadMatchingTabsForContentScripts(selectedRules);
+                                    if (this.lastWatchIncludedContentChanges && this.contentReloadFollowupMs > 0) {
+                                        await new Promise((resolve)=>setTimeout(resolve, this.contentReloadFollowupMs));
+                                        if (selectedGeneration === this.contentReloadGeneration) await controller.reloadMatchingTabsForContentScripts(selectedRules);
+                                    }
+                                }
+                                globalThis.__EXTJS_PENDING_FIREFOX_CONTENT_RELOAD__ = false;
+                                try {
+                                    await globalThis.__EXTJS_ON_FIREFOX_CONTENT_RELOADED__?.();
+                                } catch  {}
+                                if (this.awaitingSettledContentBuild && this.lastWatchIncludedContentChanges) ;
+                                else {
+                                    this.pendingContentReloadEntryNames = [];
+                                    this.awaitingSettledContentBuild = false;
+                                }
+                                if (this.awaitingSettledContentBuild && !this.lastWatchIncludedContentChanges) {
+                                    this.pendingContentReloadEntryNames = [];
+                                    this.awaitingSettledContentBuild = false;
+                                }
+                                done();
+                                return;
+                            }
                             if (this.shouldEmitReloadActionEvent()) emitActionEvent('extension_reload', {
                                 reason: reason || 'unknown',
                                 browser: this.host.browser
                             });
+                            this.pendingContentReloadEntryNames = [];
+                            globalThis.__EXTJS_PENDING_FIREFOX_CONTENT_RELOAD__ = false;
+                            this.ctx.clearPendingReloadReason?.();
                             await controller.hardReload(stats.compilation, changed);
+                            if ('function' == typeof controller.reloadMatchingTabsForContentScripts) {
+                                const allContentRules = (0, content_script_targets.iw)(compilation, this.ctx.getExtensionRoot());
+                                if (allContentRules.length > 0) await controller.reloadMatchingTabsForContentScripts(allContentRules);
+                            }
+                            if (this.host.watchSource || this.host.source) this.host.__extjsForceSourceReinspect = true;
+                        }
+                    } catch  {}
+                    done();
+                });
+            }
+            shouldEmitReloadActionEvent() {
+                return Boolean(this.host.source || this.host.watchSource);
+            }
+            refreshContentScriptSourceDependencyPaths(compilation) {
+                this.contentScriptSourceDependencyPathsByEntry = (0, content_script_targets.im)(compilation);
+                if (this.shouldEmitReloadActionEvent()) {
+                    const summary = Array.from(this.contentScriptSourceDependencyPathsByEntry.entries()).map(([entryName, dependencyPaths])=>{
+                        const matches = [
+                            ...dependencyPaths
+                        ].filter((dependencyPath)=>/contentapp\.(t|j)sx?$/i.test(dependencyPath));
+                        return `${entryName}:${dependencyPaths.size}${matches.length ? `:has-ContentApp=${matches.join('|')}` : ''}`;
+                    }).join(', ');
+                    emitActionEvent('reload_debug', {
+                        phase: 'dependencies',
+                        browser: this.host.browser,
+                        summary: summary || '<none>'
+                    });
+                }
+            }
+            collectManifestSourceSignatures(compiler) {
+                return this.collectSourceSignaturesFromPaths(this.getWatchedManifestSourcePaths(compiler));
+            }
+            collectLocaleSourceSignatures(compiler) {
+                const compilerContextRoot = String(compiler?.options?.context || '').replace(/\\/g, '/');
+                if (!compilerContextRoot) return new Map();
+                const localesRoot = external_path_.join(compilerContextRoot, 'src', '_locales');
+                const discoveredLocaleFiles = [];
+                const walk = (dirPath)=>{
+                    let entries;
+                    try {
+                        entries = external_fs_.readdirSync(dirPath, {
+                            withFileTypes: true
+                        });
+                    } catch  {
+                        return;
+                    }
+                    for (const entry of entries){
+                        const absoluteEntryPath = external_path_.join(dirPath, entry.name);
+                        if (entry.isDirectory()) {
+                            walk(absoluteEntryPath);
+                            continue;
+                        }
+                        if (entry.isFile() && absoluteEntryPath.endsWith('.json')) discoveredLocaleFiles.push(absoluteEntryPath.replace(/\\/g, '/'));
+                    }
+                };
+                walk(localesRoot);
+                return this.collectSourceSignaturesFromPaths(discoveredLocaleFiles);
+            }
+            collectSourceSignaturesFromPaths(dependencyPaths) {
+                const signatures = new Map();
+                for (const dependencyPath of dependencyPaths){
+                    const normalizedDependencyPath = String(dependencyPath).replace(/\\/g, '/');
+                    const signature = this.readSourceFileSignature(normalizedDependencyPath);
+                    if (signature) signatures.set(normalizedDependencyPath, signature);
+                }
+                return signatures;
+            }
+            inferHardReloadReasonFromSourceSignatures(compiler) {
+                const nextManifestSourceSignatures = this.collectManifestSourceSignatures(compiler);
+                if (this.haveSourceSignaturesChanged(this.manifestSourceSignatures, nextManifestSourceSignatures)) return 'manifest';
+                const nextLocaleSourceSignatures = this.collectLocaleSourceSignatures(compiler);
+                if (this.haveSourceSignaturesChanged(this.localeSourceSignatures, nextLocaleSourceSignatures)) return 'locales';
+                const nextServiceWorkerSourceSignatures = this.collectSourceSignaturesFromPaths(this.serviceWorkerSourceDependencyPaths);
+                if (this.haveSourceSignaturesChanged(this.serviceWorkerSourceSignatures, nextServiceWorkerSourceSignatures)) return 'sw';
+            }
+            haveSourceSignaturesChanged(previousSignatures, nextSignatures) {
+                if (0 === previousSignatures.size) return false;
+                if (previousSignatures.size !== nextSignatures.size) return true;
+                for (const [dependencyPath, previousSignature] of previousSignatures){
+                    const nextSignature = nextSignatures.get(dependencyPath);
+                    if (!nextSignature || nextSignature !== previousSignature) return true;
+                }
+                return false;
+            }
+            collectChangedAssetNames(compilation) {
+                const changed = new Set();
+                const assetsArr = Array.isArray(compilation?.getAssets?.()) ? compilation.getAssets() : [];
+                for (const asset of assetsArr){
+                    if (!asset?.emitted) continue;
+                    const assetName = String(asset?.name || '').replace(/\\/g, '/');
+                    if (assetName) changed.add(assetName);
+                }
+                const assetsInfo = compilation?.assetsInfo;
+                if (assetsInfo instanceof Map) for (const key of assetsInfo.keys()){
+                    const assetName = String(key || '').replace(/\\/g, '/');
+                    if (assetName) changed.add(assetName);
+                }
+                return Array.from(changed);
+            }
+            inferHardReloadReasonFromChangedAssets(changedAssets) {
+                for (const assetName of changedAssets){
+                    const normalizedAssetName = String(assetName || '').replace(/\\/g, '/');
+                    if (normalizedAssetName) {
+                        if ('manifest.json' === normalizedAssetName) return 'manifest';
+                        if (/(^|\/)_locales\/.+\.json$/i.test(normalizedAssetName)) return 'locales';
+                        if (/(^|\/)background\/(service_worker|script)\.(m?js|cjs)$/i.test(normalizedAssetName)) return 'sw';
+                    }
+                }
+            }
+            inferContentReloadEntryNamesFromChangedAssets(changedAssets) {
+                const entries = new Set();
+                for (const assetName of changedAssets){
+                    const normalizedAssetName = String(assetName || '').replace(/\\/g, '/');
+                    if (!(0, content_script_targets.HE)(normalizedAssetName)) continue;
+                    const canonicalAsset = (0, contracts.es)(normalizedAssetName);
+                    if (canonicalAsset) entries.add((0, contracts.Y0)(canonicalAsset.index));
+                }
+                return Array.from(entries);
+            }
+            inferContentReloadEntryNamesFromOutputSignatures(nextOutputSignaturesByEntry) {
+                const changedEntries = new Set();
+                for (const [entryName, nextOutputSignatures] of nextOutputSignaturesByEntry.entries()){
+                    const previousOutputSignatures = this.contentScriptOutputSignaturesByEntry.get(entryName);
+                    if (previousOutputSignatures && 0 !== previousOutputSignatures.size) {
+                        if (previousOutputSignatures.size !== nextOutputSignatures.size) {
+                            changedEntries.add(entryName);
+                            continue;
+                        }
+                        for (const [outputFile, previousSignature] of previousOutputSignatures){
+                            const nextSignature = nextOutputSignatures.get(outputFile);
+                            if (!nextSignature || nextSignature !== previousSignature) {
+                                changedEntries.add(entryName);
+                                break;
+                            }
+                        }
+                    }
+                }
+                return Array.from(changedEntries).sort();
+            }
+            collectEntrypointModuleResourcePaths(compilation, entrypointName) {
+                const collectedResourcePaths = new Set();
+                const entrypoints = compilation?.entrypoints;
+                const entrypoint = entrypoints?.get?.(entrypointName);
+                if (!entrypoint) return collectedResourcePaths;
+                const chunkGraph = compilation?.chunkGraph;
+                if (!chunkGraph) return collectedResourcePaths;
+                const entrypointChunks = Array.from(entrypoint?.chunks || []);
+                for (const chunk of entrypointChunks){
+                    const modulesIterable = chunkGraph.getChunkModulesIterable?.(chunk) || chunkGraph.getChunkModulesIterableBySourceType?.(chunk, "javascript") || chunkGraph.getChunkModules?.(chunk);
+                    if (modulesIterable) for (const module of modulesIterable){
+                        const resourcePath = module?.resource || module?.rootModule?.resource || module?.originalSource?.()?.resource;
+                        if ('string' == typeof resourcePath && resourcePath.length > 0) collectedResourcePaths.add(resourcePath.replace(/\\/g, '/'));
+                    }
+                }
+                return collectedResourcePaths;
+            }
+            readSourceFileSignature(absoluteFilePath) {
+                try {
+                    const stats = external_fs_.statSync(absoluteFilePath);
+                    if (!stats.isFile()) return;
+                    return `${stats.size}:${stats.mtimeMs}`;
+                } catch  {
+                    return;
+                }
+            }
+            collectContentScriptOutputSignatures(compilation, extensionRoot) {
+                const outputSignaturesByEntry = new Map();
+                const entrypoints = compilation?.entrypoints;
+                if (!entrypoints || !extensionRoot) return outputSignaturesByEntry;
+                for (const [entryName] of entrypoints.entries()){
+                    if (!(0, content_script_targets.wH)(entryName)) continue;
+                    const entryFiles = this.collectEntrypointFiles(compilation, [
+                        entryName
+                    ]);
+                    const outputSignatures = new Map();
+                    for (const entryFile of entryFiles){
+                        const absoluteEntryFilePath = external_path_.join(extensionRoot, entryFile);
+                        const signature = this.readSourceFileSignature(absoluteEntryFilePath);
+                        if (signature) outputSignatures.set(entryFile, signature);
+                    }
+                    if (outputSignatures.size > 0) outputSignaturesByEntry.set(entryName, outputSignatures);
+                }
+                return outputSignaturesByEntry;
+            }
+            collectEntrypointFiles(compilation, entrypointNames) {
+                const collectedFiles = new Set();
+                const entrypoints = compilation?.entrypoints;
+                if (!entrypoints) return [];
+                for (const entrypointName of entrypointNames){
+                    const entrypoint = entrypoints.get?.(entrypointName);
+                    const entryFiles = 'function' == typeof entrypoint?.getFiles ? entrypoint.getFiles() : [];
+                    for (const file of entryFiles){
+                        const normalizedFile = String(file || '').replace(/\\/g, '/');
+                        if (!(!normalizedFile || normalizedFile.endsWith('.map'))) {
+                            if (!normalizedFile.startsWith('hot/')) collectedFiles.add(normalizedFile);
+                        }
+                    }
+                }
+                return Array.from(collectedFiles);
+            }
+            async waitForStableContentOutputs(extensionRoot, entryFiles, timeoutMs = 8000, pollIntervalMs = 150, stableReadsRequired = 2) {
+                const normalizedEntryFiles = entryFiles.map((file)=>String(file || '').replace(/\\/g, '/')).filter(Boolean);
+                if (0 === normalizedEntryFiles.length) return true;
+                const start = Date.now();
+                let lastSignature = '';
+                let stableReads = 0;
+                while(Date.now() - start < timeoutMs){
+                    const referencedFiles = new Set(normalizedEntryFiles);
+                    const signatureParts = [];
+                    let allFilesReady = true;
+                    for (const entryFile of normalizedEntryFiles){
+                        const absoluteEntryFilePath = external_path_.join(extensionRoot, entryFile);
+                        const signature = this.readStableFileSignature(absoluteEntryFilePath);
+                        if (!signature) {
+                            allFilesReady = false;
+                            break;
                         }
-                    } catch  {}
-                    done();
-                });
+                        signatureParts.push(`${entryFile}:${signature}`);
+                        if (entryFile.endsWith('.js')) {
+                            const source = this.readFileTextSafe(absoluteEntryFilePath);
+                            if (!source) {
+                                allFilesReady = false;
+                                break;
+                            }
+                            for (const referencedFile of this.extractReferencedOutputFiles(source))referencedFiles.add(referencedFile);
+                        }
+                    }
+                    if (!allFilesReady) {
+                        lastSignature = '';
+                        stableReads = 0;
+                        await new Promise((resolve)=>setTimeout(resolve, pollIntervalMs));
+                        continue;
+                    }
+                    for (const referencedFile of referencedFiles){
+                        if (normalizedEntryFiles.includes(referencedFile)) continue;
+                        const absoluteReferencedFilePath = external_path_.join(extensionRoot, referencedFile);
+                        const signature = this.readStableFileSignature(absoluteReferencedFilePath);
+                        if (!signature) {
+                            allFilesReady = false;
+                            break;
+                        }
+                        signatureParts.push(`${referencedFile}:${signature}`);
+                    }
+                    if (!allFilesReady) {
+                        lastSignature = '';
+                        stableReads = 0;
+                        await new Promise((resolve)=>setTimeout(resolve, pollIntervalMs));
+                        continue;
+                    }
+                    const currentSignature = signatureParts.sort().join('|');
+                    if (currentSignature === lastSignature) stableReads += 1;
+                    else {
+                        lastSignature = currentSignature;
+                        stableReads = 1;
+                    }
+                    if (stableReads >= stableReadsRequired) return true;
+                    await new Promise((resolve)=>setTimeout(resolve, pollIntervalMs));
+                }
+                return false;
             }
-            shouldEmitReloadActionEvent() {
-                return Boolean(this.host.source || this.host.watchSource);
+            readStableFileSignature(absoluteFilePath) {
+                try {
+                    const stats = external_fs_.statSync(absoluteFilePath);
+                    if (!stats.isFile()) return;
+                    return `${stats.size}:${stats.mtimeMs}`;
+                } catch  {
+                    return;
+                }
+            }
+            readFileTextSafe(absoluteFilePath) {
+                try {
+                    return external_fs_.readFileSync(absoluteFilePath, 'utf-8');
+                } catch  {
+                    return;
+                }
+            }
+            extractReferencedOutputFiles(source) {
+                const matches = source.match(/(?:content_scripts|assets)\/[^"'`\s)]+\.(?:css|js|json|png|jpg|jpeg|svg|gif|webp|ico|avif)/g);
+                return Array.from(new Set(matches || []));
             }
             constructor(host, ctx){
                 firefox_hard_reload_define_property(this, "host", void 0);
                 firefox_hard_reload_define_property(this, "ctx", void 0);
+                firefox_hard_reload_define_property(this, "hasSeenFirstSuccessfulDone", false);
+                firefox_hard_reload_define_property(this, "serviceWorkerSourceDependencyPaths", new Set());
+                firefox_hard_reload_define_property(this, "serviceWorkerSourceSignatures", new Map());
+                firefox_hard_reload_define_property(this, "manifestSourceSignatures", new Map());
+                firefox_hard_reload_define_property(this, "localeSourceSignatures", new Map());
+                firefox_hard_reload_define_property(this, "contentScriptSourceDependencyPathsByEntry", new Map());
+                firefox_hard_reload_define_property(this, "contentScriptOutputSignaturesByEntry", new Map());
+                firefox_hard_reload_define_property(this, "pendingContentReloadEntryNames", []);
+                firefox_hard_reload_define_property(this, "contentReloadGeneration", 0);
+                firefox_hard_reload_define_property(this, "contentReloadQuietPeriodMs", 1200);
+                firefox_hard_reload_define_property(this, "contentReloadFollowupMs", 1200);
+                firefox_hard_reload_define_property(this, "lastWatchIncludedContentChanges", false);
+                firefox_hard_reload_define_property(this, "awaitingSettledContentBuild", false);
                 this.host = host;
                 this.ctx = ctx;
             }
         }
+        var evaluate = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/evaluate.ts");
+        var remote_firefox_logging = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/logging.ts");
         var messaging_client = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/messaging-client.ts");
-        var logging = __webpack_require__("./webpack/plugin-browsers/run-firefox/firefox-source-inspection/remote-firefox/logging.ts");
+        var external_url_ = __webpack_require__("url");
         const TARGET_SCAN_INTERVAL_MS = 250;
+        function guessRepoRoot(startDir) {
+            let dir = external_path_default().resolve(startDir);
+            for(let depth = 0; depth < 24; depth++){
+                if ((0, external_fs_.existsSync)(external_path_default().join(dir, 'programs', 'develop', 'package.json'))) return dir;
+                const parent = external_path_default().dirname(dir);
+                if (parent === dir) break;
+                dir = parent;
+            }
+            dir = external_path_default().resolve(startDir);
+            for(let depth = 0; depth < 16; depth++){
+                if ((0, external_fs_.existsSync)(external_path_default().join(dir, 'pnpm-workspace.yaml')) || (0, external_fs_.existsSync)(external_path_default().join(dir, '.git'))) return dir;
+                const parent = external_path_default().dirname(dir);
+                if (parent === dir) break;
+                dir = parent;
+            }
+            return null;
+        }
+        function guessRepoRootFromThisModule() {
+            try {
+                const here = external_path_default().dirname((0, external_url_.fileURLToPath)(__rslib_import_meta_url__));
+                return guessRepoRoot(here);
+            } catch  {
+                return null;
+            }
+        }
+        function appendDebugLogLine(line) {
+            const paths = [];
+            const fromEnv = process.env.EXTENSION_DEBUG_SESSION_LOG;
+            if ('string' == typeof fromEnv && fromEnv.length > 0) paths.push(fromEnv);
+            const repoFromModule = guessRepoRootFromThisModule();
+            if (repoFromModule) paths.push(external_path_default().join(repoFromModule, '.cursor', 'debug-a87efc.log'));
+            const repoFromCwd = guessRepoRoot(process.cwd());
+            if (repoFromCwd) paths.push(external_path_default().join(repoFromCwd, '.cursor', 'debug-a87efc.log'));
+            for (const root of [
+                process.env.INIT_CWD,
+                process.env.PROJECT_ROOT,
+                process.cwd()
+            ])if ('string' == typeof root && root.length > 0) paths.push(external_path_default().join(root, '.cursor', 'debug-a87efc.log'));
+            const seen = new Set();
+            for (const filePath of paths)if (!seen.has(filePath)) {
+                seen.add(filePath);
+                try {
+                    (0, external_fs_.mkdirSync)(external_path_default().dirname(filePath), {
+                        recursive: true
+                    });
+                    (0, external_fs_.appendFileSync)(filePath, `${line}\n`);
+                    return;
+                } catch  {}
+            }
+            console.error('[extension-develop][debug-session a87efc] log file write failed', line);
+        }
+        function agentDebugLog(payload) {
+            const line = JSON.stringify({
+                sessionId: 'a87efc',
+                timestamp: Date.now(),
+                ...payload
+            });
+            fetch('http://127.0.0.1:7795/ingest/9eb8f923-a325-4455-a46c-a6e706558307', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Debug-Session-Id': 'a87efc'
+                },
+                body: line
+            }).catch(()=>{});
+            appendDebugLogLine(line);
+        }
+        function shouldDeferFallbackUntilExactMatch(normalizedUrl) {
+            try {
+                const parsed = new URL(String(normalizedUrl || ''));
+                return 'http:' === parsed.protocol || 'https:' === parsed.protocol || 'file:' === parsed.protocol || 'moz-extension:' === parsed.protocol || 'chrome-extension:' === parsed.protocol || 'edge:' === parsed.protocol;
+            } catch  {
+                return false;
+            }
+        }
+        async function findActorsMatchingLiveHref(client, allTargets, normalizedUrlToInspect) {
+            const withActor = allTargets.filter((t)=>t && 'string' == typeof t.actor);
+            for(let i = withActor.length - 1; i >= 0; i--){
+                const target = withActor[i];
+                const tabActor = String(target.actor);
+                let consoleActor = 'string' == typeof target.consoleActor && target.consoleActor.length > 0 ? target.consoleActor : void 0;
+                if (!consoleActor || consoleActor === tabActor) try {
+                    const detail = await client.getTargetFromDescriptor(tabActor);
+                    if ('string' == typeof detail.consoleActor && detail.consoleActor.length > 0) consoleActor = detail.consoleActor;
+                } catch  {}
+                if (consoleActor) try {
+                    const hrefRaw = await client.evaluate(consoleActor, 'String(location.href || "")');
+                    const href = 'string' == typeof hrefRaw ? hrefRaw : String(hrefRaw ?? '');
+                    if (setup_firefox_inspection_actors_normalizeInspectableUrl(href) === normalizedUrlToInspect) return {
+                        tabActor,
+                        consoleActor
+                    };
+                } catch  {}
+            }
+            return null;
+        }
+        function setup_firefox_inspection_actors_normalizeInspectableUrl(rawUrl) {
+            try {
+                const parsed = new URL(String(rawUrl || ''));
+                if (('http:' === parsed.protocol || 'https:' === parsed.protocol) && '/' === parsed.pathname) parsed.pathname = '';
+                parsed.hash = '';
+                return parsed.toString();
+            } catch  {
+                return String(rawUrl || '').trim().replace(/\/$/, '');
+            }
+        }
         async function selectActors(client, urlToInspect) {
             const deadline = Date.now() + 10000;
             let triedAddTab = false;
+            const normalizedUrlToInspect = setup_firefox_inspection_actors_normalizeInspectableUrl(urlToInspect);
             while(Date.now() < deadline){
                 const allTargets = await client.getTargets() || [];
-                for (const target of allTargets)if (target && 'string' == typeof target.url && target.url === urlToInspect && target.actor) return {
-                    tabActor: target.actor,
-                    consoleActor: target.consoleActor || target.actor
-                };
+                const exactMatches = allTargets.filter((target)=>target && 'string' == typeof target.url && setup_firefox_inspection_actors_normalizeInspectableUrl(target.url) === normalizedUrlToInspect && target.actor);
+                const exactMatch = exactMatches.length > 0 ? exactMatches[exactMatches.length - 1] : void 0;
+                if (exactMatch?.actor) {
+                    const matchDiagnostics = [];
+                    for (const target of exactMatches.slice(-5)){
+                        const actor = String(target.actor || '');
+                        const consoleActor = String(target.consoleActor || actor);
+                        let hostCount;
+                        let href;
+                        try {
+                            const probe = await client.evaluate(consoleActor, `(() => JSON.stringify({
+              href: String(location.href || ''),
+              readyState: String(document.readyState || ''),
+              hostCount: document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])').length
+            }))()`);
+                            if ('string' == typeof probe && probe) {
+                                const parsed = JSON.parse(probe);
+                                hostCount = 'number' == typeof parsed?.hostCount ? parsed.hostCount : void 0;
+                                href = 'string' == typeof parsed?.href ? parsed.href : void 0;
+                            }
+                        } catch  {}
+                        matchDiagnostics.push({
+                            actor,
+                            consoleActor,
+                            url: target.url || '',
+                            href,
+                            hostCount
+                        });
+                    }
+                    agentDebugLog({
+                        runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-select-actors',
+                        hypothesisId: 'H20',
+                        location: 'setup-firefox-inspection-actors.ts:exact-match-selection',
+                        message: 'Firefox exact URL match selection diagnostics',
+                        data: {
+                            urlToInspect,
+                            selectedActor: exactMatch.actor,
+                            selectedConsoleActor: exactMatch.consoleActor || exactMatch.actor,
+                            matchDiagnostics
+                        }
+                    });
+                    return {
+                        tabActor: exactMatch.actor,
+                        consoleActor: exactMatch.consoleActor || exactMatch.actor
+                    };
+                }
+                if (shouldDeferFallbackUntilExactMatch(normalizedUrlToInspect)) {
+                    const livePair = await findActorsMatchingLiveHref(client, allTargets, normalizedUrlToInspect);
+                    if (livePair) {
+                        let hostCount;
+                        let href;
+                        try {
+                            const probe = await client.evaluate(livePair.consoleActor, `(() => JSON.stringify({
+              href: String(location.href || ''),
+              readyState: String(document.readyState || ''),
+              hostCount: document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])').length
+            }))()`);
+                            if ('string' == typeof probe && probe) {
+                                const parsed = JSON.parse(probe);
+                                hostCount = 'number' == typeof parsed?.hostCount ? parsed.hostCount : void 0;
+                                href = 'string' == typeof parsed?.href ? parsed.href : void 0;
+                            }
+                        } catch  {}
+                        agentDebugLog({
+                            runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-select-actors',
+                            hypothesisId: 'H23',
+                            location: 'setup-firefox-inspection-actors.ts:live-href-match',
+                            message: 'Firefox actor matched by live location.href (listTabs URL was stale)',
+                            data: {
+                                urlToInspect,
+                                selectedActor: livePair.tabActor,
+                                selectedConsoleActor: livePair.consoleActor,
+                                href,
+                                hostCount
+                            }
+                        });
+                        return livePair;
+                    }
+                }
                 if (!triedAddTab && urlToInspect) {
                     triedAddTab = true;
                     try {
@@ -9359,15 +11395,48 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                         }
                     }
                 }
-                for (const target of allTargets)if (target && ('string' == typeof target.actor || 'number' == typeof target.outerWindowID || 'number' == typeof target.outerWindowId)) return {
-                    tabActor: String(target.actor || ''),
-                    consoleActor: String(target.consoleActor || target.actor || '')
-                };
+                if (!shouldDeferFallbackUntilExactMatch(normalizedUrlToInspect)) {
+                    for (const target of allTargets)if (target && ('string' == typeof target.actor || 'number' == typeof target.outerWindowID || 'number' == typeof target.outerWindowId)) {
+                        agentDebugLog({
+                            runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-select-actors',
+                            hypothesisId: 'H21',
+                            location: 'setup-firefox-inspection-actors.ts:fallback-selection',
+                            message: 'Firefox actor selection fell back to first valid target',
+                            data: {
+                                urlToInspect,
+                                selectedActor: String(target.actor || ''),
+                                selectedConsoleActor: String(target.consoleActor || target.actor || ''),
+                                targets: allTargets.slice(0, 10).map((item, index)=>({
+                                        index,
+                                        actor: String(item?.actor || ''),
+                                        consoleActor: String(item?.consoleActor || ''),
+                                        url: String(item?.url || ''),
+                                        outerWindowID: 'number' == typeof item?.outerWindowID ? item.outerWindowID : void 0,
+                                        outerWindowId: 'number' == typeof item?.outerWindowId ? item.outerWindowId : void 0
+                                    }))
+                            }
+                        });
+                        return {
+                            tabActor: String(target.actor || ''),
+                            consoleActor: String(target.consoleActor || target.actor || '')
+                        };
+                    }
+                }
                 await new Promise((r)=>setTimeout(r, TARGET_SCAN_INTERVAL_MS));
             }
             throw new Error(browsers_lib_messages.Itp());
         }
         const PAGE_READY_TIMEOUT_MS = 8000;
+        function setup_firefox_inspection_navigation_normalizeInspectableUrl(rawUrl) {
+            try {
+                const parsed = new URL(String(rawUrl || ''));
+                if (('http:' === parsed.protocol || 'https:' === parsed.protocol) && '/' === parsed.pathname) parsed.pathname = '';
+                parsed.hash = '';
+                return parsed.toString();
+            } catch  {
+                return String(rawUrl || '').trim().replace(/\/$/, '');
+            }
+        }
         async function ensureNavigatedAndLoaded(client, urlToInspect, tabActor) {
             if (!tabActor) throw new Error(browsers_lib_messages.R4W());
             let consoleActor = tabActor;
@@ -9390,6 +11459,31 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     console.warn('[RDP] attach(frameActor) failed:', String(err.message || err));
                 }
             }
+            try {
+                const currentUrl = await client.evaluate(consoleActor, 'String(location.href || "")');
+                const sameDocumentTarget = 'string' == typeof currentUrl && setup_firefox_inspection_navigation_normalizeInspectableUrl(currentUrl) === setup_firefox_inspection_navigation_normalizeInspectableUrl(urlToInspect);
+                if (sameDocumentTarget) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE || '1' === process.env.EXTENSION_DEBUG_FIREFOX_INSPECTION) console.log(`[RDP] forcing native same-url reload for ${urlToInspect}`);
+                    const detail = await client.getTargetFromDescriptor(tabActor);
+                    const targetActor = detail.targetActor || frameActor || tabActor;
+                    try {
+                        await client.attach(targetActor);
+                    } catch (error) {
+                        if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
+                            const err = error;
+                            console.warn('[RDP] attach(targetActor for same-url reload) failed:', String(err.message || err));
+                        }
+                    }
+                    await client.navigate(targetActor, urlToInspect);
+                    await client.waitForLoadEvent(targetActor);
+                    return;
+                }
+            } catch (error) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
+                    const err = error;
+                    console.warn('[RDP] current URL check before navigate failed:', String(err.message || err));
+                }
+            }
             try {
                 await client.navigateViaScript(consoleActor, urlToInspect);
                 await client.waitForPageReady(consoleActor, urlToInspect, PAGE_READY_TIMEOUT_MS);
@@ -9658,6 +11752,10 @@ Set background.noDynamicEntryWarning to true to disable this warning.
           }
         })()`);
                     this.emitEventPayload('page_meta', stage, meta, metaSnapshot || {});
+                    const rootMeta = await this.getExtensionRootMeta();
+                    if (rootMeta) this.emitEventPayload('extension_root_meta', stage, meta, rootMeta);
+                    const styleSnapshot = await this.getShadowStyleSnapshot();
+                    if (styleSnapshot) this.emitEventPayload('shadow_style_output', stage, meta, styleSnapshot);
                 }
                 if (Array.isArray(this.devOptions?.sourceProbe)) {
                     const probes = await this.evaluateJson(this.currentConsoleActor, `(() => {
@@ -9692,7 +11790,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 }
                 if (this.devOptions?.sourceTree && 'off' !== this.devOptions.sourceTree) {
                     const tree = await this.evaluateJson(this.currentConsoleActor, `(() => {
-          const rootEl = document.querySelector('#extension-root,[data-extension-root="true"]');
+          const rootEl = document.querySelector('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])');
           if (!rootEl) return null;
           const root = (${'off' !== this.devOptions.sourceIncludeShadow ? 'rootEl.shadowRoot || rootEl' : 'rootEl'});
           const maxDepth = 4;
@@ -9773,11 +11871,238 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     if ('string' == typeof json && json.length > 0) return JSON.parse(json);
                 } catch  {}
             }
+            async evaluateString(actor, expression) {
+                if (!this.client) return;
+                try {
+                    const response = await this.client.evaluateRaw(actor, expression);
+                    const value = await (0, evaluate.vA)(this.client, actor, response, {
+                        fallbackToFullDocument: false
+                    });
+                    return 'string' == typeof value ? value : String(value || '');
+                } catch  {
+                    return;
+                }
+            }
+            async getShadowStyleSnapshot() {
+                if (!this.client || !this.currentConsoleActor) return;
+                try {
+                    const count = await this.client.evaluate(this.currentConsoleActor, `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const childStyleCount = Array.from(sr.childNodes || []).filter((node) => {
+                try {
+                  return (
+                    node &&
+                    node.nodeType === 1 &&
+                    String(node.nodeName || '').toLowerCase() === 'style'
+                  )
+                } catch {
+                  return false
+                }
+              }).length
+              if (childStyleCount > 0) return childStyleCount
+              return Array.from(sr.querySelectorAll('style')).length;
+            }
+            return 0;
+          } catch {
+            return 0;
+          }
+        })()`);
+                    const totalCount = Number(count || 0);
+                    const childNodeCss = await this.evaluateString(this.currentConsoleActor, `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const css = Array.from(sr.childNodes || [])
+                .map((node) => {
+                  try {
+                    if (!node || node.nodeType !== 1) return '';
+                    if (String(node.nodeName || '').toLowerCase() !== 'style') return '';
+                    return String(node.textContent || '');
+                  } catch {
+                    return '';
+                  }
+                })
+                .filter(Boolean)
+                .join('\\n');
+              return css;
+            }
+            return '';
+          } catch {
+            return '';
+          }
+        })()`);
+                    const adoptedCss = await this.evaluateString(this.currentConsoleActor, `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const sheets = Array.from(sr.adoptedStyleSheets || []);
+              const css = sheets
+                .map((sheet) => {
+                  try {
+                    return Array.from(sheet.cssRules || [])
+                      .map((rule) => String(rule.cssText || ''))
+                      .join('\\n');
+                  } catch {
+                    return '';
+                  }
+                })
+                .filter(Boolean)
+                .join('\\n');
+              return css;
+            }
+            return '';
+          } catch {
+            return '';
+          }
+        })()`);
+                    const stylesheetCss = await this.evaluateString(this.currentConsoleActor, `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const sheets = Array.from(sr.styleSheets || []);
+              const css = sheets
+                .map((sheet) => {
+                  try {
+                    return Array.from(sheet.cssRules || [])
+                      .map((rule) => String(rule.cssText || ''))
+                      .join('\\n');
+                  } catch {
+                    return '';
+                  }
+                })
+                .filter(Boolean)
+                .join('\\n');
+              return css;
+            }
+            return '';
+          } catch {
+            return '';
+          }
+        })()`);
+                    if ((!Number.isFinite(totalCount) || totalCount <= 0) && !('string' == typeof childNodeCss && childNodeCss.trim().length > 0) && !('string' == typeof adoptedCss && adoptedCss.trim().length > 0) && !('string' == typeof stylesheetCss && stylesheetCss.trim().length > 0)) return;
+                    if ('string' == typeof childNodeCss && childNodeCss.trim().length > 0) return {
+                        rootMode: 'shadow',
+                        count: totalCount > 0 ? totalCount : 1,
+                        styles: [
+                            {
+                                html: `<style>${childNodeCss}</style>`,
+                                textLength: childNodeCss.length,
+                                textSnippet: childNodeCss.trim().slice(0, 200)
+                            }
+                        ]
+                    };
+                    if ('string' == typeof adoptedCss && adoptedCss.trim().length > 0) return {
+                        rootMode: 'shadow',
+                        count: totalCount > 0 ? totalCount : 1,
+                        styles: [
+                            {
+                                html: `<style>${adoptedCss}</style>`,
+                                textLength: adoptedCss.length,
+                                textSnippet: adoptedCss.trim().slice(0, 200)
+                            }
+                        ]
+                    };
+                    if ('string' == typeof stylesheetCss && stylesheetCss.trim().length > 0) return {
+                        rootMode: 'shadow',
+                        count: totalCount > 0 ? totalCount : 1,
+                        styles: [
+                            {
+                                html: `<style>${stylesheetCss}</style>`,
+                                textLength: stylesheetCss.length,
+                                textSnippet: stylesheetCss.trim().slice(0, 200)
+                            }
+                        ]
+                    };
+                    const shadowHtml = await this.evaluateString(this.currentConsoleActor, `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              return String(sr.innerHTML || '');
+            }
+            return '';
+          } catch {
+            return '';
+          }
+        })()`);
+                    if ('string' == typeof shadowHtml && shadowHtml.includes('<style')) {
+                        const matches = Array.from(shadowHtml.matchAll(/<style[\s\S]*?<\/style>/g)).slice(0, 3);
+                        if (matches.length > 0) return {
+                            rootMode: 'shadow',
+                            count: totalCount,
+                            styles: matches.map((match)=>{
+                                const html = String(match[0] || '');
+                                const text = html.replace(/<style[^>]*>|<\/style>/g, '');
+                                return {
+                                    html,
+                                    textLength: text.length,
+                                    textSnippet: text.trim().slice(0, 200)
+                                };
+                            })
+                        };
+                    }
+                    const styles = [];
+                    const sampleCount = Math.min(totalCount, 3);
+                    for(let index = 0; index < sampleCount; index++){
+                        const selectStyleExpression = `(() => {
+          try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const styleEl = Array.from(sr.querySelectorAll('style'))[${index}];
+              if (!styleEl) return null;
+              return styleEl;
+            }
+            return null;
+          } catch {
+            return null;
+          }
+        })()`;
+                        const html = await this.evaluateString(this.currentConsoleActor, `(() => {
+            const styleEl = ${selectStyleExpression};
+            return styleEl ? String(styleEl.outerHTML || '') : '';
+          })()`);
+                        const textLength = await this.client.evaluate(this.currentConsoleActor, `(() => {
+            const styleEl = ${selectStyleExpression};
+            return styleEl ? String(styleEl.textContent || '').length : 0;
+          })()`);
+                        const textSnippet = await this.evaluateString(this.currentConsoleActor, `(() => {
+            const styleEl = ${selectStyleExpression};
+            return styleEl ? String(styleEl.textContent || '').trim().slice(0, 200) : '';
+          })()`);
+                        if ('string' == typeof html && html.length > 0) styles.push({
+                            html,
+                            textLength: Number(textLength || 0),
+                            textSnippet: 'string' == typeof textSnippet ? textSnippet : String(textSnippet || '')
+                        });
+                    }
+                    if (0 === styles.length) return;
+                    return {
+                        rootMode: 'shadow',
+                        count: totalCount,
+                        styles
+                    };
+                } catch  {
+                    return;
+                }
+            }
             async getDomSnapshot() {
                 if (!this.client || !this.currentConsoleActor) return;
                 const includeShadow = this.devOptions?.sourceIncludeShadow !== 'off';
                 const payload = await this.evaluateJson(this.currentConsoleActor, `(() => {
-        const rootEl = document.querySelector('#extension-root,[data-extension-root="true"]');
+        const rootEl = document.querySelector('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])');
         if (!rootEl) return null;
         const root = (${includeShadow ? 'rootEl.shadowRoot || rootEl' : 'rootEl'});
         const maxDepth = 6;
@@ -9837,6 +12162,173 @@ Set background.noDynamicEntryWarning to true to disable this warning.
           truncated,
           nodes
         };
+      })()`);
+                if (payload && 'object' == typeof payload) return payload;
+            }
+            async getExtensionRootMeta() {
+                if (!this.client || !this.currentConsoleActor) return;
+                const payload = await this.evaluateJson(this.currentConsoleActor, `(() => {
+        const readGeneration = (node) => {
+          try {
+            const raw = node && node.getAttribute
+              ? node.getAttribute('data-extjs-reinject-generation')
+              : '';
+            if (typeof raw !== 'string' || raw.trim() === '') return undefined;
+            const parsed = Number(raw);
+            return Number.isFinite(parsed) ? parsed : undefined;
+          } catch (error) {
+            return undefined;
+          }
+        };
+        const readRegistryGeneration = (entry) => {
+          try {
+            if (!entry) return undefined;
+            if (typeof entry === 'function' && typeof entry.__extjsGeneration === 'number') {
+              return entry.__extjsGeneration;
+            }
+            if (typeof entry === 'object') {
+              if (typeof entry.__extjsGeneration === 'number') return entry.__extjsGeneration;
+              if (typeof entry.generation === 'number') return entry.generation;
+              if (typeof entry.cleanup === 'function' && typeof entry.cleanup.__extjsGeneration === 'number') {
+                return entry.cleanup.__extjsGeneration;
+              }
+            }
+          } catch (error) {
+            return undefined;
+          }
+          return undefined;
+        };
+        const normalize = (node) => ({
+          tag: node && node.tagName ? String(node.tagName).toLowerCase() : 'unknown',
+          id: node && node.id ? String(node.id) : undefined,
+          key: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-key') || undefined : undefined,
+          generation: readGeneration(node),
+          status: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-status') || undefined : undefined,
+          build: node && node.getAttribute ? node.getAttribute('data-extjs-reinject-build') || undefined : undefined
+        });
+        const roots = Array.from(
+          document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])')
+        )
+          .slice(0, 10)
+          .map(normalize);
+        const page = (() => {
+          try {
+            const node = document.documentElement;
+            if (!node || typeof node.getAttribute !== 'function') return undefined;
+            const raw = node.getAttribute('data-extjs-last-reinject-generation');
+            const generation =
+              typeof raw === 'string' && raw.trim() !== '' && Number.isFinite(Number(raw))
+                ? Number(raw)
+                : undefined;
+            return {
+              key: node.getAttribute('data-extjs-last-reinject-key') || undefined,
+              generation,
+              status: node.getAttribute('data-extjs-last-reinject-status') || undefined,
+              build: node.getAttribute('data-extjs-last-reinject-build') || undefined
+            };
+          } catch (error) {
+            return undefined;
+          }
+        })();
+        const debug = (() => {
+          try {
+            const node = document.documentElement;
+            if (!node || typeof node.getAttribute !== 'function') return undefined;
+            const parseMaybeNumber = (raw) =>
+              typeof raw === 'string' && raw.trim() !== '' && Number.isFinite(Number(raw))
+                ? Number(raw)
+                : undefined;
+            return {
+              stage: node.getAttribute('data-extjs-debug-stage') || undefined,
+              rootCount: parseMaybeNumber(node.getAttribute('data-extjs-debug-root-count')),
+              ownedRootCount: parseMaybeNumber(
+                node.getAttribute('data-extjs-debug-owned-root-count')
+              ),
+              markerCount: parseMaybeNumber(
+                node.getAttribute('data-extjs-debug-marker-count')
+              ),
+              lastRemoval:
+                node.getAttribute('data-extjs-debug-last-removal') || undefined,
+              lastRemovalSource:
+                node.getAttribute('data-extjs-debug-last-removal-source') ||
+                undefined,
+              lastRemovalKey:
+                node.getAttribute('data-extjs-debug-last-removal-key') ||
+                undefined,
+              lastRemovedNodeTag:
+                node.getAttribute('data-extjs-debug-last-removed-node-tag') ||
+                undefined,
+              lastRemovedNodeId:
+                node.getAttribute('data-extjs-debug-last-removed-node-id') ||
+                undefined,
+              lastRemovedNodeClass:
+                node.getAttribute('data-extjs-debug-last-removed-node-class') ||
+                undefined,
+              lastRemovedNodeDirect:
+                node.getAttribute('data-extjs-debug-last-removed-node-direct') ||
+                undefined,
+              lastRemovalReadyState:
+                node.getAttribute('data-extjs-debug-last-removal-ready-state') ||
+                undefined,
+              lastRemovalUrl:
+                node.getAttribute('data-extjs-debug-last-removal-url') ||
+                undefined,
+              lastRemovalParentTag:
+                node.getAttribute('data-extjs-debug-last-removal-parent-tag') ||
+                undefined,
+              executionCount: parseMaybeNumber(
+                node.getAttribute('data-extjs-debug-execution-count')
+              ),
+              lastExecutionStage:
+                node.getAttribute('data-extjs-debug-last-execution-stage') ||
+                undefined,
+              lastExecutionKey:
+                node.getAttribute('data-extjs-debug-last-execution-key') ||
+                undefined,
+              existingRootCountBeforeCleanup: parseMaybeNumber(
+                node.getAttribute(
+                  'data-extjs-debug-existing-root-count-before-cleanup'
+                )
+              )
+            };
+          } catch (error) {
+            return undefined;
+          }
+        })();
+        const markers = Array.from(
+          document.querySelectorAll('[data-extjs-reinject-marker="true"]')
+        )
+          .slice(0, 10)
+          .map(normalize);
+        const registry = (typeof globalThis === 'object' && globalThis && globalThis.__EXTENSIONJS_DEV_REINJECT__)
+          ? globalThis.__EXTENSIONJS_DEV_REINJECT__
+          : {};
+        const registries = Object.entries(registry || {})
+          .slice(0, 20)
+          .map(([key, entry]) => ({
+            key,
+            generation: readRegistryGeneration(entry),
+            hasCleanup:
+              typeof entry === 'function' ||
+              !!(entry && typeof entry === 'object' && typeof entry.cleanup === 'function')
+          }));
+        const generations = roots
+          .concat(markers)
+          .map((entry) => entry.generation)
+          .concat(typeof page?.generation === 'number' ? [page.generation] : [])
+          .concat(registries.map((entry) => entry.generation))
+          .filter((value) => typeof value === 'number');
+        return {
+          rootCount: roots.length,
+          markerCount: markers.length,
+          registryCount: registries.length,
+          latestGeneration: generations.length ? Math.max(...generations) : 0,
+          debug,
+          page,
+          roots,
+          markers,
+          registries
+        };
       })()`);
                 if (payload && 'object' == typeof payload) return payload;
             }
@@ -9884,7 +12376,7 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     await client.connect(port);
                     this.client = client;
                     this.setupConsoleCapture();
-                    if (this.devOptions?.sourceConsole) await (0, logging.c)(client);
+                    if (this.devOptions?.sourceConsole) await (0, remote_firefox_logging.c)(client);
                     this.initialized = true;
                     if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
                         console.log(browsers_lib_messages.X6h());
@@ -9951,6 +12443,9 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                             const currentTitle = await this.client.evaluate(actorToUse, 'String(document.title)');
                             if ('string' == typeof currentTitle) meta.title = currentTitle;
                         } catch  {}
+                        try {
+                            await this.waitForContentScriptStyles(actorToUse);
+                        } catch  {}
                         const html = await (0, source_inspect.Lj)(this.client, descriptor, actorToUse) || '';
                         this.emitSourceOutput(html, 'post_injection', meta);
                         return;
@@ -9963,7 +12458,112 @@ Set background.noDynamicEntryWarning to true to disable this warning.
             }
             async waitForContentScriptInjection(consoleActor) {
                 if (!this.client) return;
-                await (0, source_inspect.NQ)(this.client, consoleActor);
+                return await (0, source_inspect.NQ)(this.client, consoleActor);
+            }
+            async hasVisibleShadowHostContentFirefox() {
+                if (!this.client || !this.currentConsoleActor) return false;
+                try {
+                    const v = await this.client.evaluate(this.currentConsoleActor, `(() => { try {
+          const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+          for (const h of hosts) {
+            const sr = h && h.shadowRoot;
+            if (sr && String(sr.innerHTML || '').trim().length > 0) return true;
+          }
+          return false;
+        } catch { return false } })()`);
+                    return Boolean(v);
+                } catch  {
+                    return false;
+                }
+            }
+            async shouldEmitFirefoxContentScriptInjected(injectionWaitOk) {
+                if (!injectionWaitOk || !this.client || !this.currentConsoleActor) return false;
+                const deadline = Date.now() + 2800;
+                while(Date.now() < deadline){
+                    const rootMeta = await this.getExtensionRootMeta();
+                    const shadow = await this.getShadowStyleSnapshot();
+                    if (rootMeta && rootMeta.rootCount >= 1) return true;
+                    if (shadow && 'number' == typeof shadow.count && Number(shadow.count) > 0) return true;
+                    await new Promise((r)=>setTimeout(r, 200));
+                }
+                return this.hasVisibleShadowHostContentFirefox();
+            }
+            async reopenTabAndResolveActors(urlToInspect) {
+                if (!this.client) return null;
+                try {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE || '1' === process.env.EXTENSION_DEBUG_FIREFOX_INSPECTION) console.log(`[RDP] source inspection reopening fresh tab for ${String(urlToInspect)}`);
+                    await this.client.addTab(urlToInspect);
+                    await wait(300);
+                    const { tabActor, consoleActor } = await this.selectActors(urlToInspect);
+                    this.currentTabActor = tabActor;
+                    const resolvedConsoleActor = await this.resolveConsoleActor(tabActor, urlToInspect);
+                    this.currentConsoleActor = resolvedConsoleActor || consoleActor;
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE || '1' === process.env.EXTENSION_DEBUG_FIREFOX_INSPECTION) console.log(`[RDP] reopened tabActor=${String(tabActor)} consoleActor=${String(this.currentConsoleActor || '')}`);
+                    return {
+                        tabActor,
+                        consoleActor: this.currentConsoleActor
+                    };
+                } catch  {
+                    return null;
+                }
+            }
+            async waitForContentScriptStyles(consoleActor) {
+                if (!this.client) return;
+                const deadline = Date.now() + 10000;
+                while(Date.now() < deadline){
+                    try {
+                        const hasStyles = await this.client.evaluate(consoleActor, `(() => { try {
+            const hosts = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]:not([data-extension-root="extension-js-devtools"])'));
+            if (!hosts.length) return false;
+            for (const host of hosts) {
+              const sr = host && host.shadowRoot;
+              if (!sr) continue;
+              const styles = Array.from(sr.querySelectorAll('style'));
+              if (styles.some((styleEl) => String(styleEl.outerHTML || '').includes('<style') && String(styleEl.textContent || '').trim().length > 0)) {
+                return true;
+              }
+              const childStyles = Array.from(sr.childNodes || []);
+              if (childStyles.some((node) => {
+                try {
+                  return (
+                    node &&
+                    node.nodeType === 1 &&
+                    String(node.nodeName || '').toLowerCase() === 'style' &&
+                    String(node.textContent || '').trim().length > 0
+                  );
+                } catch {
+                  return false;
+                }
+              })) {
+                return true;
+              }
+              const adoptedSheets = Array.from(sr.adoptedStyleSheets || []);
+              if (adoptedSheets.some((sheet) => {
+                try {
+                  return Array.from(sheet.cssRules || []).length > 0;
+                } catch {
+                  return false;
+                }
+              })) {
+                return true;
+              }
+              const styleSheets = Array.from(sr.styleSheets || []);
+              if (styleSheets.some((sheet) => {
+                try {
+                  return Array.from(sheet.cssRules || []).length > 0;
+                } catch {
+                  return false;
+                }
+              })) {
+                return true;
+              }
+            }
+            return false;
+          } catch { return false } })()`);
+                        if (hasStyles) return;
+                    } catch  {}
+                    await wait(200);
+                }
             }
             async handleFileChange() {
                 if (!this.client || !this.currentConsoleActor) return;
@@ -9977,6 +12577,9 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                         }
                         if (this.lastUrlToInspect) await this.ensureUrlAndReady(this.currentConsoleActor, this.lastUrlToInspect);
                         await this.waitForContentScriptInjection(this.currentConsoleActor);
+                        try {
+                            await this.waitForContentScriptStyles(this.currentConsoleActor);
+                        } catch  {}
                         let lastError = null;
                         for(let attempt = 0; attempt < 3; attempt++){
                             try {
@@ -10002,6 +12605,11 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     }
                 }, CHANGE_DEBOUNCE_MS);
             }
+            registerContentReloadSnapshotHook() {
+                globalThis.__EXTJS_ON_FIREFOX_CONTENT_RELOADED__ = async ()=>{
+                    await this.handleFileChange();
+                };
+            }
             apply(compiler) {
                 if (this.host.dryRun) return;
                 if ('development' !== compiler.options.mode) return;
@@ -10012,6 +12620,18 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                         if (!this.initialized) await this.initialize();
                         const urlToInspect = this.resolveUrlToInspect();
                         this.lastUrlToInspect = urlToInspect;
+                        const forceSourceReinspect = Boolean(this.host.__extjsForceSourceReinspect);
+                        if (forceSourceReinspect) {
+                            this.host.__extjsForceSourceReinspect = false;
+                            this.currentConsoleActor = null;
+                            this.currentTabActor = null;
+                        }
+                        if (this.devOptions?.watchSource && !forceSourceReinspect && this.isWatching && this.currentConsoleActor && this.currentTabActor) {
+                            if (globalThis.__EXTJS_PENDING_FIREFOX_CONTENT_RELOAD__) return void done();
+                            await this.handleFileChange();
+                            done();
+                            return;
+                        }
                         if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(browsers_lib_messages.rCC(urlToInspect));
                         const { tabActor, consoleActor } = await this.selectActors(urlToInspect);
                         this.currentTabActor = tabActor;
@@ -10025,15 +12645,61 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                         const resolvedConsoleActor = await this.resolveConsoleActor(tabActor, urlToInspect);
                         this.currentConsoleActor = resolvedConsoleActor || consoleActor;
                         if (this.currentConsoleActor) {
-                            await this.waitForContentScriptInjection(this.currentConsoleActor);
-                            emitActionEvent("content_script_injected", {
-                                url: urlToInspect
-                            });
+                            let injected = await this.waitForContentScriptInjection(this.currentConsoleActor);
+                            if ('true' === process.env.EXTENSION_AUTHOR_MODE || '1' === process.env.EXTENSION_DEBUG_FIREFOX_INSPECTION) console.log(`[RDP] initial content-script wait result=${String(Boolean(injected))} actor=${String(this.currentConsoleActor)}`);
+                            if (!injected) {
+                                const reopened = await this.reopenTabAndResolveActors(urlToInspect);
+                                if (reopened?.consoleActor) {
+                                    emitActionEvent('navigation_start', {
+                                        url: urlToInspect
+                                    });
+                                    await this.ensureNavigatedAndLoaded(urlToInspect, reopened.tabActor);
+                                    emitActionEvent('navigation_end', {
+                                        url: urlToInspect
+                                    });
+                                    injected = await this.waitForContentScriptInjection(reopened.consoleActor);
+                                    if ('true' === process.env.EXTENSION_AUTHOR_MODE || '1' === process.env.EXTENSION_DEBUG_FIREFOX_INSPECTION) console.log(`[RDP] fresh-tab content-script wait result=${String(Boolean(injected))} actor=${String(reopened.consoleActor)}`);
+                                }
+                            }
+                            try {
+                                const actorHref = this.currentConsoleActor ? await this.client?.evaluate(this.currentConsoleActor, 'String(location.href || "")') : void 0;
+                                fetch('http://127.0.0.1:7795/ingest/9eb8f923-a325-4455-a46c-a6e706558307', {
+                                    method: 'POST',
+                                    headers: {
+                                        'Content-Type': 'application/json',
+                                        'X-Debug-Session-Id': 'a87efc'
+                                    },
+                                    body: JSON.stringify({
+                                        sessionId: 'a87efc',
+                                        runId: process.env.EXTENSION_INSTANCE_ID || 'firefox-source-inspection',
+                                        hypothesisId: 'H4',
+                                        location: "firefox-source-inspection/index.ts:before-content-script-event",
+                                        message: "Firefox content-script event boundary",
+                                        data: {
+                                            urlToInspect,
+                                            currentTabActor: this.currentTabActor,
+                                            currentConsoleActor: this.currentConsoleActor,
+                                            injected,
+                                            actorHref
+                                        },
+                                        timestamp: Date.now()
+                                    })
+                                }).catch(()=>{});
+                            } catch  {}
+                            if (injected) {
+                                const emitOk = await this.shouldEmitFirefoxContentScriptInjected(injected);
+                                if (emitOk) emitActionEvent("content_script_injected", {
+                                    url: urlToInspect
+                                });
+                            }
+                            try {
+                                await this.waitForContentScriptStyles(this.currentConsoleActor);
+                            } catch  {}
                             await this.printHTML(this.currentConsoleActor);
                         }
                         if (this.devOptions?.watchSource) {
+                            this.registerContentReloadSnapshotHook();
                             this.isWatching = true;
-                            await this.handleFileChange();
                         }
                     } catch (error) {
                         if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.error(browsers_lib_messages.b82(error.message));
@@ -10102,8 +12768,6 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 run_firefox_define_property(this, "geckoBinary", void 0);
                 run_firefox_define_property(this, "port", void 0);
                 run_firefox_define_property(this, "instanceId", void 0);
-                run_firefox_define_property(this, "keepProfileChanges", void 0);
-                run_firefox_define_property(this, "copyFromProfile", void 0);
                 run_firefox_define_property(this, "source", void 0);
                 run_firefox_define_property(this, "watchSource", void 0);
                 run_firefox_define_property(this, "sourceFormat", void 0);
@@ -10128,38 +12792,8 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 run_firefox_define_property(this, "logger", void 0);
                 run_firefox_define_property(this, "firefoxCtx", void 0);
                 run_firefox_define_property(this, "rdpController", void 0);
-                this.extension = options.extension;
-                this.browser = options.browser;
-                this.startingUrl = options.startingUrl;
-                this.preferences = options.preferences;
-                this.profile = options.profile;
-                this.browserFlags = options.browserFlags;
-                this.excludeBrowserFlags = options.excludeBrowserFlags;
-                this.noOpen = options.noOpen;
+                Object.assign(this, (0, runtime_options.pA)(options));
                 this.geckoBinary = options.geckoBinary;
-                this.instanceId = options.instanceId;
-                this.port = options.port;
-                this.source = options.source;
-                this.watchSource = options.watchSource;
-                this.sourceFormat = options.sourceFormat;
-                this.sourceSummary = options.sourceSummary;
-                this.sourceMeta = options.sourceMeta;
-                this.sourceProbe = options.sourceProbe;
-                this.sourceTree = options.sourceTree;
-                this.sourceConsole = options.sourceConsole;
-                this.sourceDom = options.sourceDom;
-                this.sourceMaxBytes = options.sourceMaxBytes;
-                this.sourceRedact = options.sourceRedact;
-                this.sourceIncludeShadow = options.sourceIncludeShadow;
-                this.sourceDiff = options.sourceDiff;
-                this.logLevel = options.logLevel;
-                this.logContexts = options.logContexts;
-                this.logFormat = options.logFormat;
-                this.logTimestamps = options.logTimestamps;
-                this.logColor = options.logColor;
-                this.logUrl = options.logUrl;
-                this.logTab = options.logTab;
-                this.dryRun = options.dryRun;
             }
         }
         function plugin_browsers_define_property(obj, key, value) {
@@ -10224,39 +12858,9 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 plugin_browsers_define_property(this, "logUrl", void 0);
                 plugin_browsers_define_property(this, "logTab", void 0);
                 const normalized = normalizePluginOptions(options);
-                this.extension = normalized.extension;
-                this.browser = normalized.browser;
-                this.startingUrl = normalized.startingUrl;
-                this.preferences = normalized.preferences;
-                this.profile = normalized.profile;
-                this.browserFlags = normalized.browserFlags;
-                this.excludeBrowserFlags = normalized.excludeBrowserFlags;
-                this.noOpen = normalized.noOpen;
+                Object.assign(this, (0, runtime_options.pA)(normalized));
                 this.chromiumBinary = normalized.chromiumBinary;
                 this.geckoBinary = normalized.geckoBinary;
-                this.instanceId = normalized.instanceId;
-                this.port = normalized.port;
-                this.source = normalized.source;
-                this.watchSource = normalized.watchSource;
-                this.sourceFormat = normalized.sourceFormat;
-                this.sourceSummary = normalized.sourceSummary;
-                this.sourceMeta = normalized.sourceMeta;
-                this.sourceProbe = normalized.sourceProbe;
-                this.sourceTree = normalized.sourceTree;
-                this.sourceConsole = normalized.sourceConsole;
-                this.sourceDom = normalized.sourceDom;
-                this.sourceMaxBytes = normalized.sourceMaxBytes;
-                this.sourceRedact = normalized.sourceRedact;
-                this.sourceIncludeShadow = normalized.sourceIncludeShadow;
-                this.sourceDiff = normalized.sourceDiff;
-                this.logLevel = normalized.logLevel;
-                this.logContexts = normalized.logContexts;
-                this.logFormat = normalized.logFormat;
-                this.logTimestamps = normalized.logTimestamps;
-                this.logColor = normalized.logColor;
-                this.logUrl = normalized.logUrl;
-                this.logTab = normalized.logTab;
-                this.dryRun = normalized.dryRun;
                 if ('chromium-based' === this.browser && !this.chromiumBinary) {
                     console.error(browsers_lib_messages.nek());
                     process.exit(1);
@@ -10426,6 +13030,11 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                 watchSource: devOptions.watchSource,
                 sourceFormat: devOptions.sourceFormat,
                 sourceSummary: devOptions.sourceSummary,
+                sourceMeta: devOptions.sourceMeta,
+                sourceProbe: devOptions.sourceProbe,
+                sourceTree: devOptions.sourceTree,
+                sourceConsole: devOptions.sourceConsole,
+                sourceDom: devOptions.sourceDom,
                 sourceMaxBytes: devOptions.sourceMaxBytes,
                 sourceRedact: devOptions.sourceRedact,
                 sourceIncludeShadow: devOptions.sourceIncludeShadow,
@@ -10450,6 +13059,11 @@ Set background.noDynamicEntryWarning to true to disable this warning.
                     clean: devOptions.output.clean,
                     path: primaryExtensionOutputDir,
                     publicPath: '/',
+                    filename: 'development' === (devOptions.mode || 'development') ? (pathData)=>{
+                        const chunkName = pathData.chunk?.name;
+                        if ('string' == typeof chunkName && /^content_scripts\/content-\d+$/.test(chunkName)) return `${chunkName}.[fullhash:8].js`;
+                        return '[name].js';
+                    } : '[name].js',
                     hotUpdateChunkFilename: 'hot/[id].[fullhash].hot-update.js',
                     hotUpdateMainFilename: 'hot/[runtime].[fullhash].hot-update.json',
                     environment: {