extension-develop 2.1.3 → 3.0.0-next.7

package/README.md

@@ -27,7 +27,6 @@ import {
   extensionBuild,
   extensionStart,
   extensionPreview,
-  cleanupCommand,
   type DevOptions,
   type BuildOptions,
   type StartOptions,
@@ -55,9 +54,6 @@ async function run() {
     browser: 'chrome',
     mode: 'production'
   } satisfies PreviewOptions)
-
-  // Cleanup orphaned browser instances
-  await cleanupCommand()
 }
 
 run()
@@ -72,7 +68,7 @@ run()
 - Zipping: distribution and/or source packages (respects `.gitignore`)
 - Auto-install of missing dependencies and package manager detection
 - Type generation for TS projects via `extension-env.d.ts`
-- User config via `extension.config.(js|mjs)` for commands, browser launch, and webpack config hooks
+- User config via `extension.config.(js|mjs)` for commands, browser launch, unified logger defaults, and webpack config hooks
 - Managed dependency guard to avoid conflicts
 
 ## Commands
@@ -91,24 +87,31 @@ Options accepted by each command. Values shown are typical types or enumerations
 
 ### Common (browser/runtime)
 
-| Option         | Type / Values                                      | Description                                 |
-| -------------- | -------------------------------------------------- | ------------------------------------------- |
-| browser        | chrome, edge, firefox, chromium-based, gecko-based | Target browser/runtime                      |
-| profile        | string or false                                    | Profile path or disable profile persistence |
-| startingUrl    | string                                             | Initial URL to open                         |
-| open           | boolean                                            | Focus/open the browser window               |
-| chromiumBinary | string                                             | Custom Chromium-based executable path       |
-| geckoBinary    | string                                             | Custom Gecko-based executable path          |
+| Option         | Type / Values                                      | Description                                                     |
+| -------------- | -------------------------------------------------- | --------------------------------------------------------------- |
+| browser        | chrome, edge, firefox, chromium-based, gecko-based | Target browser/runtime                                          |
+| profile        | string or false                                    | Profile path or disable profile persistence                     |
+| startingUrl    | string                                             | Initial URL to open                                             |
+| open           | boolean                                            | Focus/open the browser window (CLI: use `--no-open` to disable) |
+| chromiumBinary | string                                             | Custom Chromium-based executable path                           |
+| geckoBinary    | string                                             | Custom Gecko-based executable path                              |
 
 ### dev
 
-| Option      | Type / Values                 | Description                                   |
-| ----------- | ----------------------------- | --------------------------------------------- |
-| mode        | development, production, none | Build mode                                    |
-| polyfill    | boolean                       | Include `webextension-polyfill` when possible |
-| port        | number or string              | Dev server port                               |
-| source      | string                        | Inspect a source directory                    |
-| watchSource | boolean                       | Watch the source directory                    |
+| Option        | Type / Values                       | Description                                                                       |
+| ------------- | ----------------------------------- | --------------------------------------------------------------------------------- |
+| mode          | development, production, none       | Build mode                                                                        |
+| polyfill      | boolean                             | Include `webextension-polyfill` when possible                                     |
+| port          | number or string                    | Dev server port                                                                   |
+| source        | string                              | Inspect a source directory                                                        |
+| watchSource   | boolean                             | Watch the source directory                                                        |
+| logs          | off,error,warn,info,debug,trace,all | Unified logger verbosity (all shows everything)                                   |
+| logContext    | list or `all`                       | Comma-separated contexts (background,content,page,sidebar,popup,options,devtools) |
+| logFormat     | pretty,json                         | Pretty text or JSON output                                                        |
+| logTimestamps | boolean                             | Include timestamps in pretty output                                               |
+| logColor      | boolean                             | Colorize pretty output                                                            |
+| logUrl        | string or /regex/flags              | Filter by URL substring or JS-style regex literal                                 |
+| logTab        | number                              | Filter by tabId                                                                   |
 
 ### build
 
@@ -141,13 +144,22 @@ Options accepted by each command. Values shown are typical types or enumerations
   - Other HTTP(S) URLs: treated as zip archives and extracted locally.
 - Monorepos: The nearest `manifest.json` is resolved recursively; the nearest valid `package.json` is then located and validated.
 
+### Root semantics (manifest vs package.json)
+
+- `manifest.json` may live in any subdirectory of your project.
+- The project root for build/dev is the directory containing the nearest valid `package.json` (i.e., webpack `context`).
+- Special folders and root-relative paths are anchored at the package root:
+  - `public/`, `pages/`, `scripts/`, and URLs starting with `/` resolve relative to the package root (e.g., `/logo.png` → `<packageRoot>/public/logo.png`).
+- Web-only mode: if no `package.json` is found, the manifest directory is used as a fallback project root.
+
 ## User config
 
 - Provide `extension.config.js` or `extension.config.mjs` in your project root.
 - Supported sections:
-  - config(config: Configuration): mutate the assembled Rspack config.
-  - commands.dev | .build | .start | .preview: per-command options (browser, profile, binaries, flags, preferences, packaging).
-  - browser.chrome | .firefox | .edge | .chromium-based | .gecko-based: launch flags, excluded flags, preferences, binaries, and profile reuse.
+  - config(config: Configuration): mutate the assembled Rspack config. Supports a function or a plain object. When an object is provided, it is deep‑merged on top of the assembled config.
+  - commands.dev | .build | .start | .preview: per‑command options (browser, profile, binaries, flags, preferences, unified logger defaults, packaging). These defaults are applied for all respective commands.
+  - browser.chrome | .firefox | .edge | .chromium-based | .gecko-based: launch flags, excluded flags, preferences, binaries, and profile reuse (persistProfile).
+- Precedence when composing options: browser._ → commands._ → CLI flags. CLI flags always win over config defaults.
 - When detected, a one‑time notice is printed to indicate config is active.
 
 ### Environment variables in `extension.config.*`
@@ -172,7 +184,24 @@ export default {
         process.env.EXTENSION_PUBLIC_START_URL || 'https://example.com'
     }
   },
+  commands: {
+    dev: {
+      // Unified logger defaults for `extension dev`
+      logLevel: 'off',
+      // omit or set to undefined to include all
+      logContexts: ['background', 'content'],
+      logFormat: 'pretty',
+      logTimestamps: true,
+      logColor: true,
+      // Optional filters
+      logUrl: '/example\\.com/i',
+      logTab: 123
+    }
+  },
+  // Either a function
   config: (config) => config
+  // Or a plain object to merge
+  // config: { resolve: { alias: { react: 'preact/compat' } } }
 }
 ```
 
@@ -212,7 +241,6 @@ dist/
 | plugin-static-assets | core  | - Emits images, fonts, and misc files to `assets/`<br/>- Inlines small SVGs (≤2KB), emits larger ones<br/>- Content hashing in production; stable names in development<br/>- Respects existing custom SVG rules |
 | plugin-compatibility | core  | - Cross‑browser helpers<br/>- Normalizes browser‑specific manifest fields<br/>- Optional `webextension-polyfill` for Chromium                                                                                   |
 | plugin-compilation   | core  | - Loads env and templating (`EXTENSION_PUBLIC_*`)<br/>- Optional `dist/<browser>` cleaning<br/>- Compact, de‑duplicated compilation summary                                                                     |
-| plugin-reload        | core  | - Dev‑time live reload/HMR orchestration<br/>- Per‑instance WebSocket server<br/>- Manifest dev overrides<br/>- Full recompiles on HTML entry changes                                                           |
 
 ## Notes and compatibility
 
@@ -222,7 +250,7 @@ dist/
 ## Related files in this folder
 
 - `webpack/webpack-config.ts`: Assembles the plugin stack and shared configuration.
-- `webpack/dev-server.ts`: Local development server wiring and reload orchestration.
+- `dev-server/`: Local development server wiring and reload orchestration.
 - `webpack/webpack-types.ts`: Common types for the plugin stack.
 
 ## License

package/dist/930.js

@@ -0,0 +1,44 @@
+"use strict";
+exports.ids = [
+    "930"
+];
+exports.modules = {
+    "./webpack/webpack-lib/zip.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            downloadAndExtractZip: ()=>downloadAndExtractZip
+        });
+        var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("path");
+        var adm_zip__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("adm-zip");
+        var adm_zip__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/ __webpack_require__.n(adm_zip__WEBPACK_IMPORTED_MODULE_1__);
+        var _messages__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./webpack/webpack-lib/messages.ts");
+        async function downloadAndExtractZip(url, targetPath) {
+            const urlNoSearchParams = url.split('?')[0];
+            try {
+                console.log(_messages__WEBPACK_IMPORTED_MODULE_2__.cq(urlNoSearchParams));
+                const res = await fetch(url, {
+                    redirect: 'follow'
+                });
+                if (!res.ok || !res.body) throw new Error(`HTTP ${res.status} ${res.statusText}`);
+                const contentType = String(res.headers.get('content-type') || '');
+                const isZipExt = '.zip' === path__WEBPACK_IMPORTED_MODULE_0__.extname(urlNoSearchParams).toLowerCase();
+                const isZipType = /zip|octet-stream/i.test(contentType);
+                if (!isZipExt && !isZipType) throw new Error(`${_messages__WEBPACK_IMPORTED_MODULE_2__.wX(urlNoSearchParams, contentType)}`);
+                const extname = path__WEBPACK_IMPORTED_MODULE_0__.extname(urlNoSearchParams);
+                const basename = path__WEBPACK_IMPORTED_MODULE_0__.basename(urlNoSearchParams, extname);
+                const destinationPath = path__WEBPACK_IMPORTED_MODULE_0__.join(targetPath, basename);
+                console.log(_messages__WEBPACK_IMPORTED_MODULE_2__.WF(destinationPath));
+                const arrayBuffer = await res.arrayBuffer();
+                const zipBuffer = Buffer.from(arrayBuffer);
+                const zip = new (adm_zip__WEBPACK_IMPORTED_MODULE_1___default())(zipBuffer);
+                zip.extractAllTo(destinationPath, true);
+                console.log(_messages__WEBPACK_IMPORTED_MODULE_2__.aP());
+                return destinationPath;
+            } catch (error) {
+                console.error(_messages__WEBPACK_IMPORTED_MODULE_2__.QC(error));
+                const err = new Error(`${_messages__WEBPACK_IMPORTED_MODULE_2__.QC(error)}`);
+                err.code = 'EZIP';
+                throw err;
+            }
+        }
+    }
+};

package/dist/add-centralized-logger-script-background.js

@@ -0,0 +1,220 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>logger_background
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_schema_utils_namespaceObject = require("schema-utils");
+function filterKeysForThisBrowser(manifest, browser) {
+    const CHROMIUM_BASED_BROWSERS = [
+        'chrome',
+        'edge'
+    ];
+    const GECKO_BASED_BROWSERS = [
+        'firefox'
+    ];
+    const isChromiumTarget = CHROMIUM_BASED_BROWSERS.includes(browser) || String(browser).includes('chromium');
+    const isGeckoTarget = GECKO_BASED_BROWSERS.includes(browser) || String(browser).includes('gecko');
+    const chromiumPrefixes = new Set([
+        'chromium',
+        'chrome',
+        'edge'
+    ]);
+    const geckoPrefixes = new Set([
+        'gecko',
+        'firefox'
+    ]);
+    const patchedManifest = JSON.parse(JSON.stringify(manifest), function(key, value) {
+        const indexOfColon = key.indexOf(':');
+        if (-1 === indexOfColon) return value;
+        const prefix = key.substring(0, indexOfColon);
+        if (prefix === browser || isChromiumTarget && chromiumPrefixes.has(prefix) || isGeckoTarget && geckoPrefixes.has(prefix)) this[key.substring(indexOfColon + 1)] = value;
+    });
+    return patchedManifest;
+}
+const schema = {
+    type: 'object',
+    properties: {
+        test: {
+            type: 'string'
+        },
+        manifestPath: {
+            type: 'string'
+        },
+        mode: {
+            type: 'string'
+        },
+        browser: {
+            type: 'string'
+        }
+    }
+};
+function logger_background(source) {
+    const options = this.getOptions();
+    const manifestPath = options.manifestPath;
+    const projectPath = external_path_default().dirname(manifestPath);
+    const rawManifest = JSON.parse(external_fs_default().readFileSync(manifestPath, 'utf-8'));
+    const browser = options.browser || 'chrome';
+    const manifest = filterKeysForThisBrowser(rawManifest, browser);
+    (0, external_schema_utils_namespaceObject.validate)(schema, options, {
+        name: "scripts:add-centralized-logger-script-background",
+        baseDataPath: 'options'
+    });
+    const resourceAbsPath = external_path_default().normalize(this.resourcePath);
+    const loggerBootstrap = `
+/* centralized background logger bootstrap */
+(function() {
+  var loggerPort;
+  var buffer = [];
+  function tryConnect() {
+    if (!(typeof chrome !== "undefined" && chrome.runtime && chrome.runtime.connect)) return;
+    var targetId = (function(){
+      if (typeof self !== 'undefined' && (self).__EXT_LOGGER_ID__) return String((self).__EXT_LOGGER_ID__);
+      try {
+        var u = new URL(typeof location !== 'undefined' ? String(location.href) : '');
+        var v = u.searchParams.get('loggerId');
+        if (v) return v;
+      } catch {}
+      return '';
+    })();
+    if (!loggerPort && targetId) {
+      try {
+        loggerPort = chrome.runtime.connect(targetId, { name: 'logger' });
+        flush();
+        attachDisconnect();
+      } catch (e) {}
+    }
+    // intentionally avoid local self-connection to prevent loops; only external connection should be used
+    if (!loggerPort && chrome.management && typeof chrome.management.getAll === 'function') {
+      chrome.management.getAll(function(list){
+        var found = (list||[]).find(function(it){ return it && typeof it.name === 'string' && it.name.toLowerCase().includes('centralized-logger'); });
+        if (found && found.id && !loggerPort) {
+          try {
+            loggerPort = chrome.runtime.connect(found.id, { name: 'logger' });
+            flush();
+            attachDisconnect();
+          } catch (e) {}
+        }
+      });
+    } else {
+      attachDisconnect();
+    }
+  }
+  function flush(){
+    if (!loggerPort || !loggerPort.postMessage) return;
+    var q = buffer; buffer = [];
+    for (var i=0;i<q.length;i++) {
+      try { loggerPort.postMessage(q[i]); } catch (e) {}
+    }
+  }
+  function attachDisconnect(){
+    if (loggerPort && loggerPort.onDisconnect && loggerPort.onDisconnect.addListener) {
+      loggerPort.onDisconnect.addListener(function(){ loggerPort = null; });
+    }
+  }
+
+  if (typeof chrome !== "undefined" && chrome.runtime && chrome.runtime.connect) {
+    tryConnect();
+
+    // Bridge: forward any internal ports named 'logger' (e.g., from content/UI) to centralized logger
+    if (chrome.runtime && chrome.runtime.onConnect && chrome.runtime.onConnect.addListener) {
+      chrome.runtime.onConnect.addListener(function(port) {
+        if (!port || port.name !== 'logger') return;
+        port.onMessage.addListener(function(msg){
+          if (!loggerPort) { tryConnect(); }
+          if (loggerPort && loggerPort.postMessage) { loggerPort.postMessage(msg); }
+          else { buffer.push(msg); }
+        });
+      });
+    }
+  }
+
+  function safePost(msg) {
+    try {
+      if (!loggerPort) { tryConnect(); }
+      if (loggerPort && loggerPort.postMessage) { loggerPort.postMessage(msg); }
+      else { buffer.push(msg); }
+    } catch (e) {}
+  }
+
+  if (typeof self !== "undefined" && self.addEventListener) {
+    self.addEventListener('error', function(e) {
+      safePost({ type: 'log', level: 'error', context: 'background', messageParts: [ String(e && e.message || ''), String(e && e.filename || ''), e && e.lineno, e && e.colno ] });
+    });
+
+    self.addEventListener('unhandledrejection', function(e) {
+      var reason = '';
+      if (e && typeof e.reason !== "undefined") {
+        try { reason = typeof e.reason === "string" ? e.reason : JSON.stringify(e.reason); } catch (_) { reason = String(e.reason); }
+      }
+      safePost({ type: 'log', level: 'error', context: 'background', messageParts: ['Unhandled Rejection', reason] });
+    });
+  }
+
+  ['log','info','warn','error','debug'].forEach(function(lvl) {
+    if (typeof console !== "undefined" && typeof console[lvl] === "function") {
+      var orig = console[lvl].bind(console);
+      console[lvl] = function() {
+        var args = Array.prototype.slice.call(arguments);
+        safePost({ type: 'log', level: String(lvl), context: 'background', messageParts: args });
+        orig.apply(console, args);
+      };
+    }
+  });
+})();
+  `;
+    if (manifest.background) {
+        if (manifest.background.scripts) for (const bgScript of manifest.background.scripts){
+            const absoluteUrl = external_path_default().resolve(projectPath, bgScript);
+            if (resourceAbsPath === external_path_default().normalize(absoluteUrl)) return `${loggerBootstrap}${source}`;
+        }
+        if (manifest.background.service_worker) {
+            const swPath = manifest.background.service_worker;
+            const absoluteSwPath = external_path_default().resolve(projectPath, swPath);
+            if (resourceAbsPath === external_path_default().normalize(absoluteSwPath)) return `${loggerBootstrap}${source}`;
+        }
+    }
+    return source;
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/add-centralized-logger-script-content.js

@@ -0,0 +1,172 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>logger_script
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_schema_utils_namespaceObject = require("schema-utils");
+function filterKeysForThisBrowser(manifest, browser) {
+    const CHROMIUM_BASED_BROWSERS = [
+        'chrome',
+        'edge'
+    ];
+    const GECKO_BASED_BROWSERS = [
+        'firefox'
+    ];
+    const isChromiumTarget = CHROMIUM_BASED_BROWSERS.includes(browser) || String(browser).includes('chromium');
+    const isGeckoTarget = GECKO_BASED_BROWSERS.includes(browser) || String(browser).includes('gecko');
+    const chromiumPrefixes = new Set([
+        'chromium',
+        'chrome',
+        'edge'
+    ]);
+    const geckoPrefixes = new Set([
+        'gecko',
+        'firefox'
+    ]);
+    const patchedManifest = JSON.parse(JSON.stringify(manifest), function(key, value) {
+        const indexOfColon = key.indexOf(':');
+        if (-1 === indexOfColon) return value;
+        const prefix = key.substring(0, indexOfColon);
+        if (prefix === browser || isChromiumTarget && chromiumPrefixes.has(prefix) || isGeckoTarget && geckoPrefixes.has(prefix)) this[key.substring(indexOfColon + 1)] = value;
+    });
+    return patchedManifest;
+}
+const schema = {
+    type: 'object',
+    properties: {
+        test: {
+            type: 'string'
+        },
+        manifestPath: {
+            type: 'string'
+        },
+        mode: {
+            type: 'string'
+        },
+        browser: {
+            type: 'string'
+        }
+    }
+};
+function logger_script(source) {
+    const options = this.getOptions();
+    const manifestPath = options.manifestPath;
+    const projectPath = external_path_default().dirname(manifestPath);
+    const rawManifest = JSON.parse(external_fs_default().readFileSync(manifestPath, 'utf-8'));
+    const browser = options.browser || 'chrome';
+    const manifest = filterKeysForThisBrowser(rawManifest, browser);
+    (0, external_schema_utils_namespaceObject.validate)(schema, options, {
+        name: "scripts:add-centralized-logger-script-content",
+        baseDataPath: 'options'
+    });
+    const resourceAbsPath = external_path_default().normalize(this.resourcePath);
+    const pageScriptName = 'content-logger.page.js';
+    const pageScriptContent = '(function(){\n  function post(msg){ try { window.postMessage(msg, "*") } catch (_) {} }\n  window.addEventListener("error", function(e){\n    post({ __reactLogger: true, type: "log", level: "error",\n      messageParts: [ String(e && e.message || ""), String(e && e.filename || ""), e && e.lineno, e && e.colno ],\n      url: String(location && location.href || "") })\n  })\n  window.addEventListener("unhandledrejection", function(e){\n    var reason; try { reason = typeof e.reason === "string" ? e.reason : JSON.stringify(e.reason) } catch (_) { reason = String(e.reason) }\n    post({ __reactLogger: true, type: "log", level: "error", messageParts: ["Unhandled Rejection", reason], url: String(location && location.href || "") })\n  })\n  ["log","info","warn","error","debug","trace"].forEach(function(level){\n    try {\n      var original = console[level] && console[level].bind ? console[level].bind(console) : console[level]\n      console[level] = function(){ var args = [].slice.call(arguments); post({ __reactLogger: true, type: "log", level: level, messageParts: args, url: String(location && location.href || "") }); try { return original && original.apply ? original.apply(console, args) : void 0 } catch (_) {} }\n    } catch (_) {}\n  })\n  try {\n    var oc = console.clear && console.clear.bind ? console.clear.bind(console) : console.clear; if (oc) console.clear = function(){ try { post({ __reactLogger: true, type: "log", level: "info", messageParts: ["console.clear"], url: String(location && location.href || ""), meta: { kind: "clear" } }) } catch (_) {} try { return oc.apply(console, arguments) } catch (_) {} }\n  } catch (_) {}\n  ;["group","groupCollapsed","groupEnd"].forEach(function(k){ try { var og = console[k] && console[k].bind ? console[k].bind(console) : console[k]; if (!og) return; console[k] = function(){ var args = [].slice.call(arguments); try { post({ __reactLogger: true, type: "log", level: "log", messageParts: args, url: String(location && location.href || ""), meta: { kind: k } }) } catch (_) {} try { return og.apply(console, args) } catch (_) {} } } catch (_) {} })\n  ;["time","timeLog","timeEnd","count","countReset","table"].forEach(function(k){ try { var oo = console[k] && console[k].bind ? console[k].bind(console) : console[k]; if (!oo) return; console[k] = function(){ var args = [].slice.call(arguments); try { post({ __reactLogger: true, type: "log", level: "log", messageParts: args, url: String(location && location.href || ""), meta: { kind: k } }) } catch (_) {} try { return oo.apply(console, args) } catch (_) {} } } catch (_) {} })\n})()';
+    this.emitFile(pageScriptName, pageScriptContent);
+    const loggerBootstrap = `
+/* centralized content logger bootstrap */
+(function() {
+  var contextLabel = 'content'
+  var port
+  if (typeof chrome !== 'undefined' && chrome.runtime && chrome.runtime.connect) {
+    var targetId = (function(){
+      if (typeof window !== 'undefined' && (window).__EXT_LOGGER_ID__) return String((window).__EXT_LOGGER_ID__)
+      try { var u = new URL(typeof location !== 'undefined' ? String(location.href) : ''); var v = u.searchParams.get('loggerId'); if (v) return v } catch {}
+      return ''
+    })()
+
+    if (targetId) { try { port = chrome.runtime.connect(targetId, { name: 'logger' }) } catch (_) {} }
+    if (!port) { try { port = chrome.runtime.connect({ name: 'logger' }) } catch (_) {} }
+
+    if (!port && chrome.management && typeof chrome.management.getAll === 'function') {
+      chrome.management.getAll(function(list){
+        var found = (list||[]).find(function(it){ return it && typeof it.name === 'string' && it.name.toLowerCase().includes('centralized-logger') })
+        if (found && found.id) { try { port = chrome.runtime.connect(found.id, { name: 'logger' }) } catch (_) {} }
+      })
+    }
+  }
+
+  function safePost(msg) { if (port && port.postMessage) { port.postMessage(msg) } }
+
+  window.addEventListener('message', function(event){
+    try {
+      var data = (event && event.data) || {}
+      if (!data || data.__reactLogger !== true || data.type !== 'log') return
+      var parts = Array.isArray(data.messageParts) ? data.messageParts : [data.messageParts]
+      var meta = (typeof data.meta === 'object' && data.meta) ? data.meta : undefined
+      safePost({ type: 'log', level: String(data.level || 'log'), context: 'page', messageParts: parts, url: data.url, meta: meta })
+    } catch (_) {}
+  })
+
+  var el = document.createElement('script')
+  try { el.src = chrome.runtime.getURL('${pageScriptName}') } catch (_) {}
+  (document.documentElement || document.head || document.body).appendChild(el)
+
+  ;['log','info','warn','error','debug','trace'].forEach(function(level) {
+    if (typeof console !== 'undefined' && typeof console[level] === 'function') {
+      var original = console[level].bind(console)
+      console[level] = function() {
+        var args = Array.prototype.slice.call(arguments)
+        try { safePost({ type:'log', level:String(level), context: contextLabel, messageParts: args }) } catch (_) {}
+        original.apply(console, args)
+      }
+    }
+  })
+})()
+`;
+    const declaredContentJsAbsPaths = [];
+    const contentScripts = Array.isArray(manifest.content_scripts) ? manifest.content_scripts : [];
+    for (const cs of contentScripts){
+        const jsList = Array.isArray(null == cs ? void 0 : cs.js) ? cs.js : [];
+        for (const js of jsList){
+            const abs = external_path_default().resolve(projectPath, js);
+            declaredContentJsAbsPaths.push(abs);
+        }
+    }
+    const isDeclaredContentScript = declaredContentJsAbsPaths.some((abs)=>resourceAbsPath === external_path_default().normalize(abs));
+    if (isDeclaredContentScript) return `${loggerBootstrap}${source}`;
+    return source;
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});