@dimina-kit/devtools 0.4.0-dev.20260718143821 → 0.4.0-dev.20260728065133

package/dist/main/index.bundle.js

@@ -545,6 +545,11 @@ var AppChannel = {
 var AutomationChannel = {
   GetPort: "automation:port"
 };
+var InternalDevtoolsChannel = {
+  // Open (or focus, if already open) the internal debug DevTools, hosted in
+  // its own dedicated window (see internal-devtools-window/index.ts).
+  Open: "internal-devtools:open"
+};
 var SettingsChannel = {
   SetVisible: "settings:setVisible",
   ConfigChanged: "settings:configChanged",
@@ -892,7 +897,7 @@ function registerProjectFsIpc(ctx) {
 }
 
 // src/main/app/app.ts
-import { app as app15, BrowserWindow as BrowserWindow8, nativeImage, session as session4 } from "electron";
+import { app as app15, BrowserWindow as BrowserWindow9, nativeImage, session as session4 } from "electron";
 import fs13 from "fs";
 import path25 from "path";
 
@@ -1074,6 +1079,261 @@ function wireMainWindowEvents(win, state = {}) {
   return registry;
 }
 
+// src/main/windows/internal-devtools-window/index.ts
+import { BrowserWindow as BrowserWindow3, View as View2, WebContentsView as WebContentsView2 } from "electron";
+function createInternalDevtoolsWindow(target, opts) {
+  let win = null;
+  let hostView = null;
+  const hostChangedHandlers = /* @__PURE__ */ new Set();
+  let currentHost = null;
+  function notifyHostChanged(hostWc) {
+    if (hostWc === currentHost) return;
+    currentHost = hostWc;
+    for (const handler of [...hostChangedHandlers]) {
+      try {
+        handler(hostWc);
+      } catch (err2) {
+        console.warn("[internal-devtools-window] onHostChanged handler threw, other handlers still ran:", err2 instanceof Error ? err2.message : String(err2));
+      }
+    }
+  }
+  function resizeHostView(hostWindow, view) {
+    try {
+      const [width, height] = hostWindow.getContentSize();
+      view.setBounds({ x: 0, y: 0, width, height });
+    } catch {
+    }
+  }
+  function buildOnce() {
+    if (win) return;
+    const hostWindow = new BrowserWindow3({
+      width: 1e3,
+      height: 700,
+      title: "\u5168\u5C40\u8C03\u8BD5",
+      show: false
+    });
+    win = hostWindow;
+    const view = new WebContentsView2();
+    hostView = view;
+    const container = new View2();
+    container.addChildView(view);
+    hostWindow.contentView = container;
+    resizeHostView(hostWindow, view);
+    hostWindow.on("resize", () => resizeHostView(hostWindow, view));
+    hostWindow.on("close", (event) => {
+      if (opts?.isAppQuitting?.()) return;
+      event.preventDefault();
+      hostWindow.hide();
+      notifyHostChanged(null);
+    });
+    hostWindow.on("closed", () => {
+      if (win !== hostWindow) return;
+      win = null;
+      notifyHostChanged(null);
+    });
+    hostWindow.on("hide", () => notifyHostChanged(null));
+    hostWindow.on("show", () => notifyHostChanged(view.webContents));
+    if (!target.webContents.isDestroyed()) {
+      target.webContents.setDevToolsWebContents(view.webContents);
+      target.webContents.openDevTools({ mode: "detach", activate: false });
+    }
+  }
+  return {
+    open() {
+      buildOnce();
+      if (process.env.NODE_ENV === "test") {
+        win.showInactive();
+      } else {
+        win.show();
+        win.focus();
+      }
+      if (hostView) notifyHostChanged(hostView.webContents);
+    },
+    dispose() {
+      if (!win) return;
+      const hostWindow = win;
+      if (!hostWindow.isDestroyed()) hostWindow.destroy();
+      if (win === hostWindow) {
+        win = null;
+        notifyHostChanged(null);
+      }
+    },
+    onHostChanged(handler) {
+      hostChangedHandlers.add(handler);
+      if (currentHost) {
+        queueMicrotask(() => {
+          if (!hostChangedHandlers.has(handler)) return;
+          if (!currentHost) return;
+          try {
+            handler(currentHost);
+          } catch (err2) {
+            console.warn("[internal-devtools-window] onHostChanged catch-up handler threw:", err2 instanceof Error ? err2.message : String(err2));
+          }
+        });
+      }
+      return () => {
+        hostChangedHandlers.delete(handler);
+      };
+    }
+  };
+}
+
+// src/main/services/views/inject-when-ready.ts
+function isFrontendSettled(wc) {
+  try {
+    if (wc.isDestroyed()) return false;
+    const url = wc.getURL();
+    const mainFrameLoading = typeof wc.isLoadingMainFrame === "function" ? wc.isLoadingMainFrame() : wc.isLoading();
+    return !mainFrameLoading && url !== "" && url !== "about:blank";
+  } catch {
+    return false;
+  }
+}
+function createLoadDeferredInjector() {
+  const pending = /* @__PURE__ */ new WeakMap();
+  return function injectWhenReady(wc, kind, run) {
+    if (wc.isDestroyed()) return;
+    if (isFrontendSettled(wc)) {
+      run();
+      return;
+    }
+    let kinds = pending.get(wc);
+    if (!kinds) {
+      kinds = /* @__PURE__ */ new Map();
+      pending.set(wc, kinds);
+    }
+    const alreadyHooked = kinds.has(kind);
+    kinds.set(kind, run);
+    if (alreadyHooked) return;
+    wc.once("did-stop-loading", () => {
+      const runner = kinds.get(kind);
+      kinds.delete(kind);
+      if (!runner || wc.isDestroyed()) return;
+      runner();
+    });
+  };
+}
+
+// src/main/services/console-forward/open-gated-relay.ts
+var DEFAULT_INJECT_TIMEOUT_MS = 1e4;
+function createOpenGatedRelay(onHostChanged, subscribe, inject, opts) {
+  const injectTimeoutMs = opts?.injectTimeoutMs ?? DEFAULT_INJECT_TIMEOUT_MS;
+  const state = /* @__PURE__ */ new WeakMap();
+  let generationSeq = 0;
+  const inFlightTimers = /* @__PURE__ */ new Set();
+  let live = null;
+  function deliver(entry) {
+    if (state.has(entry)) return;
+    const generation = ++generationSeq;
+    state.set(entry, { phase: "pending", generation });
+    const timer = setTimeout(() => {
+      inFlightTimers.delete(timer);
+      const cur = state.get(entry);
+      if (cur && cur.phase === "pending" && cur.generation === generation) state.delete(entry);
+    }, injectTimeoutMs);
+    timer.unref?.();
+    inFlightTimers.add(timer);
+    const settle = (ok2) => {
+      clearTimeout(timer);
+      inFlightTimers.delete(timer);
+      const cur = state.get(entry);
+      if (!cur || cur.phase !== "pending" || cur.generation !== generation) return;
+      if (ok2) state.set(entry, { phase: "done", generation });
+      else state.delete(entry);
+    };
+    Promise.resolve().then(() => inject(entry)).then((ok2) => settle(ok2 === true), () => settle(false));
+  }
+  const unregister = onHostChanged((host) => {
+    live?.dispose();
+    live = host !== null ? subscribe(deliver, { replay: true }) : null;
+  });
+  return {
+    dispose: () => {
+      for (const timer of inFlightTimers) clearTimeout(timer);
+      inFlightTimers.clear();
+      live?.dispose();
+      live = null;
+      unregister();
+    }
+  };
+}
+
+// src/main/services/console-forward/cdp-inject.ts
+function injectViaCdp(broker, target, script, warnTag) {
+  const lease = broker.acquire(target);
+  if (!lease) return false;
+  return lease.send("Runtime.evaluate", { expression: script }).then(
+    (result) => {
+      if (result?.exceptionDetails) {
+        console.warn(`[${warnTag}] Runtime.evaluate reported an exception, will retry on next reopen`);
+        return false;
+      }
+      return true;
+    },
+    (err2) => {
+      console.warn(`[${warnTag}] injection failed, will retry on next reopen:`, err2 instanceof Error ? err2.message : String(err2));
+      return false;
+    }
+  );
+}
+
+// src/main/services/console-forward/global-console-mirror.ts
+var FORWARDABLE_LEVELS = /* @__PURE__ */ new Set(["log", "warn", "error", "info", "debug"]);
+function buildMirrorScript(entry) {
+  const method = FORWARDABLE_LEVELS.has(entry.level ?? "") ? entry.level : "log";
+  const tag = entry.source === "render" ? "[render]" : "[service]";
+  const argsJson = JSON.stringify(entry.args ?? []);
+  return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}](${JSON.stringify(tag)},...a)}catch(_){}})()`;
+}
+function createGlobalConsoleMirror(forwarder, target, onHostChanged, opts) {
+  function inject(entry) {
+    if (target.isDestroyed()) return false;
+    if (!isFrontendSettled(target)) return false;
+    let script;
+    try {
+      script = buildMirrorScript(entry);
+    } catch {
+      return false;
+    }
+    return injectViaCdp(opts.broker, target, script, "global-console-mirror");
+  }
+  return createOpenGatedRelay(
+    onHostChanged,
+    (sink, opts2) => forwarder.subscribe(sink, opts2),
+    inject
+  );
+}
+
+// src/main/services/console-forward/global-diagnostics-mirror.ts
+var DIAGNOSTIC_CONSOLE_CALL = {
+  error: "console.error",
+  warn: "console.warn",
+  info: "console.info"
+};
+function buildMirrorScript2(severity, message) {
+  const call = DIAGNOSTIC_CONSOLE_CALL[severity];
+  const argsJson = JSON.stringify([`[dimina-kit] ${message}`]);
+  return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});${call}(...a)}catch(_){}})()`;
+}
+function createGlobalDiagnosticsMirror(diagnostics, target, onHostChanged, opts) {
+  function inject(d) {
+    if (target.isDestroyed()) return false;
+    if (!isFrontendSettled(target)) return false;
+    let script;
+    try {
+      script = buildMirrorScript2(d.severity, d.message);
+    } catch {
+      return false;
+    }
+    return injectViaCdp(opts.broker, target, script, "global-diagnostics-mirror");
+  }
+  return createOpenGatedRelay(
+    onHostChanged,
+    (sink, opts2) => diagnostics.subscribe(sink, opts2),
+    inject
+  );
+}
+
 // src/main/app/lifecycle.ts
 import { app as app4, globalShortcut as globalShortcut2 } from "electron";
 var appIsQuitting = false;
@@ -1574,7 +1834,7 @@ function createPlacementReconciler(ctx) {
 }
 
 // src/main/services/views/workbench-view.ts
-import { nativeTheme as nativeTheme3, WebContentsView as WebContentsView2 } from "electron";
+import { nativeTheme as nativeTheme3, WebContentsView as WebContentsView3 } from "electron";
 
 // src/shared/view-ids.ts
 var VIEW_ID = {
@@ -1631,7 +1891,7 @@ function createWorkbenchView(ctx, reconciler) {
   }
   async function attachWorkbench(url) {
     if (workbenchView) return;
-    const view = new WebContentsView2({
+    const view = new WebContentsView3({
       webPreferences: {
         nodeIntegration: false,
         contextIsolation: true,
@@ -1755,7 +2015,7 @@ function createWorkbenchView(ctx, reconciler) {
 }
 
 // src/main/services/views/native-simulator-devtools-host.ts
-import { WebContentsView as WebContentsView3 } from "electron";
+import { WebContentsView as WebContentsView4, webContents as electronWebContents } from "electron";
 
 // src/shared/open-in-editor-resource-path.ts
 function decodePathname(pathname) {
@@ -2216,40 +2476,146 @@ function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
   }catch(_){}})()`;
 }
 
-// src/main/services/views/inject-when-ready.ts
-function isFrontendSettled(wc) {
-  try {
-    if (wc.isDestroyed()) return false;
-    const url = wc.getURL();
-    const mainFrameLoading = typeof wc.isLoadingMainFrame === "function" ? wc.isLoadingMainFrame() : wc.isLoading();
-    return !mainFrameLoading && url !== "" && url !== "about:blank";
-  } catch {
-    return false;
-  }
+// src/main/services/views/console-filter.ts
+var DEFAULT_INTERNAL_LOG_FILTER = "-/^\\[service\\]/";
+function buildConsoleFilterScript(negativeFilter = DEFAULT_INTERNAL_LOG_FILTER) {
+  const keyJson = JSON.stringify("console.text-filter");
+  const markKeyJson = JSON.stringify("console.text-filter.dimina-default");
+  const valueJsonLiteral = JSON.stringify(JSON.stringify(negativeFilter));
+  return `(function(){try{
+    var IFH = globalThis.InspectorFrontendHost;
+    if (!IFH || typeof IFH.getPreferences !== 'function' || typeof IFH.setPreference !== 'function') return;
+    IFH.getPreferences(function(prefs){
+      try {
+        var KEY = ${keyJson};
+        var MARK_KEY = ${markKeyJson};
+        var VALUE = ${valueJsonLiteral};
+        var existing = prefs ? prefs[KEY] : undefined;
+        var mark = prefs ? prefs[MARK_KEY] : undefined;
+        var isUnset = existing === undefined || existing === null || existing === '' || existing === '""';
+        var isOurStaleDefault = !isUnset && mark !== undefined && mark !== null && existing === mark;
+        if (isUnset || isOurStaleDefault) {
+          IFH.setPreference(KEY, VALUE);
+          IFH.setPreference(MARK_KEY, VALUE);
+        }
+      } catch(_){}
+    });
+  }catch(_){}})()`;
 }
-function createLoadDeferredInjector() {
-  const pending = /* @__PURE__ */ new WeakMap();
-  return function injectWhenReady(wc, kind, run) {
-    if (wc.isDestroyed()) return;
-    if (isFrontendSettled(wc)) {
-      run();
-      return;
-    }
-    let kinds = pending.get(wc);
-    if (!kinds) {
-      kinds = /* @__PURE__ */ new Map();
-      pending.set(wc, kinds);
+var LIVE_FILTER_POLL_MAX_ATTEMPTS = 100;
+var LIVE_FILTER_POLL_INTERVAL_MS = 100;
+function buildLiveConsoleFilterScript(negativeFilter = DEFAULT_INTERNAL_LOG_FILTER) {
+  const filterJson = JSON.stringify(negativeFilter);
+  const maxAttempts = JSON.stringify(LIVE_FILTER_POLL_MAX_ATTEMPTS);
+  const intervalMs = JSON.stringify(LIVE_FILTER_POLL_INTERVAL_MS);
+  return `(function(){
+    var VALUE = ${filterJson};
+    var attempts = 0;
+    function bootstrapReady() {
+      try {
+        var eui = globalThis.EUI;
+        if (!eui || !eui.ShortcutRegistry || !eui.ShortcutRegistry.ShortcutRegistry) return false;
+        eui.ShortcutRegistry.ShortcutRegistry.instance();
+        return true;
+      } catch (_) { return false; }
+    }
+    function tryApply() {
+      attempts++;
+      var scheduleRetry = attempts < ${maxAttempts};
+      // In-realm bootstrap probe FIRST (defense in depth on top of the
+      // main-process whenFrontendBootstrapped gate): touching
+      // Console.ConsoleView.instance() before the front-end's own
+      // MainImpl bootstrap completes constructs IssuesManager early and
+      // permanently kills that bootstrap (ensureFirst conflict) \u2014 the probe
+      // throws BEFORE constructing anything, so a not-ready tick costs
+      // nothing and never touches ConsoleView.
+      if (!bootstrapReady()) {
+        if (scheduleRetry) { setTimeout(tryApply, ${intervalMs}); return; }
+        console.warn('[console-filter] gave up applying the live Console filter after ' + attempts + ' attempts \u2014 the front-end bootstrap never completed');
+        return;
+      }
+      try {
+        var ConsoleNS = globalThis.Console;
+        var view = ConsoleNS && ConsoleNS.ConsoleView ? ConsoleNS.ConsoleView.instance() : null;
+        var f = view ? view.filter : null;
+        if (!f || !f.textFilterUI || typeof f.textFilterUI.setValue !== 'function' || typeof f.textFilterUI.value !== 'function') {
+          if (scheduleRetry) { setTimeout(tryApply, ${intervalMs}); return; }
+          console.warn('[console-filter] gave up applying the live Console filter after ' + attempts + ' attempts \u2014 Console.ConsoleView never became usable');
+          return;
+        }
+        var current = f.textFilterUI.value();
+        var isUnset = current === undefined || current === null || current === '';
+        var isOurDefault = current === VALUE;
+        if (isUnset || isOurDefault) {
+          f.textFilterUI.setValue(VALUE);
+          if (typeof f.updateCurrentFilter === 'function') f.updateCurrentFilter();
+          if (typeof f.onFilterChanged === 'function') f.onFilterChanged();
+        }
+        // Either applied, or a real user customization was detected \u2014 both
+        // are terminal: nothing left for a later retry to accomplish.
+      } catch(_) {
+        if (scheduleRetry) setTimeout(tryApply, ${intervalMs});
+      }
     }
-    const alreadyHooked = kinds.has(kind);
-    kinds.set(kind, run);
-    if (alreadyHooked) return;
-    wc.once("did-stop-loading", () => {
-      const runner = kinds.get(kind);
-      kinds.delete(kind);
-      if (!runner || wc.isDestroyed()) return;
-      runner();
-    });
-  };
+    tryApply();
+  })()`;
+}
+
+// src/main/services/views/frontend-bootstrap-gate.ts
+var FRONTEND_BOOTSTRAP_PROBE_SCRIPT = `(() => {
+  try {
+    const eui = globalThis.EUI
+    if (!eui || !eui.ShortcutRegistry || !eui.ShortcutRegistry.ShortcutRegistry) return false
+    eui.ShortcutRegistry.ShortcutRegistry.instance()
+    return true
+  } catch (_) {
+    return false
+  }
+})()`;
+var DEFAULT_TIMEOUT_MS = 45e3;
+var DEFAULT_INTERVAL_MS = 150;
+function whenFrontendBootstrapped(wc, opts) {
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const intervalMs = opts?.intervalMs ?? DEFAULT_INTERVAL_MS;
+  return new Promise((resolve) => {
+    let timer = null;
+    let settled = false;
+    const finish = (ready) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      resolve(ready);
+    };
+    const deadline = setTimeout(() => {
+      console.warn(`[frontend-bootstrap-gate] front-end bootstrap probe never reported ready within ${timeoutMs}ms \u2014 bootstrap-gated injections stay skipped for this host`);
+      finish(false);
+    }, timeoutMs);
+    deadline.unref?.();
+    const attempt = () => {
+      if (wc.isDestroyed()) {
+        finish(false);
+        return;
+      }
+      Promise.resolve().then(() => wc.executeJavaScript(FRONTEND_BOOTSTRAP_PROBE_SCRIPT)).then((ready) => ready === true, () => false).then((ready) => {
+        if (settled) return;
+        if (wc.isDestroyed()) {
+          finish(false);
+          return;
+        }
+        if (ready) {
+          finish(true);
+          return;
+        }
+        timer = setTimeout(attempt, intervalMs);
+        timer.unref?.();
+      });
+    };
+    attempt();
+  });
 }
 
 // src/main/services/network-forward/index.ts
@@ -2408,6 +2774,165 @@ function buildChunkedDispatchScript(chunks, totalSize) {
   const arr = JSON.stringify(chunks);
   return `(()=>{try{if(!(window.DevToolsAPI&&typeof window.DevToolsAPI.dispatchMessageChunk==='function'))return false;const cs=JSON.parse(${JSON.stringify(arr)});for(let i=0;i<cs.length;i++){try{if(i===0){window.DevToolsAPI.dispatchMessageChunk(cs[i], ${totalSize})}else{window.DevToolsAPI.dispatchMessageChunk(cs[i])}}catch(_){}}return true;}catch(_){return false}})()`;
 }
+function buildSingleDispatchScript(message) {
+  return `(()=>{try{if(!${PROBE_DEVTOOLS_API})return false;window.DevToolsAPI.dispatchMessage(JSON.parse(${JSON.stringify(message)}));return true;}catch(_){return false}})()`;
+}
+function createFrontendReplyChannel(hostWc, isDisposed) {
+  function dispatchToFrontend(message) {
+    if (isDisposed() || hostWc.isDestroyed()) return;
+    if (!isFrontendSettled(hostWc)) return;
+    let json;
+    try {
+      json = JSON.stringify(message);
+    } catch {
+      return;
+    }
+    if (json.length > MAX_SINGLE_DISPATCH_CHARS) {
+      const chunks = [];
+      for (let i = 0; i < json.length; i += CHUNK_CHARS) chunks.push(json.slice(i, i + CHUNK_CHARS));
+      let script2;
+      try {
+        script2 = buildChunkedDispatchScript(chunks, json.length);
+      } catch {
+        return;
+      }
+      hostWc.executeJavaScript(script2, true).catch(() => {
+      });
+      return;
+    }
+    let script;
+    try {
+      script = buildSingleDispatchScript(json);
+    } catch {
+      return;
+    }
+    hostWc.executeJavaScript(script, true).catch(() => {
+    });
+  }
+  function replyResult(cmd, result) {
+    const msg = { id: cmd.id, result };
+    if (cmd.sessionId) msg.sessionId = cmd.sessionId;
+    dispatchToFrontend(msg);
+  }
+  function replyError(cmd, message) {
+    const msg = { id: cmd.id, error: { code: -32e3, message } };
+    if (cmd.sessionId) msg.sessionId = cmd.sessionId;
+    dispatchToFrontend(msg);
+  }
+  return { dispatchToFrontend, replyResult, replyError };
+}
+function drainOutboundBatch(batch, handle) {
+  if (!Array.isArray(batch)) return;
+  for (const raw of batch) {
+    if (!raw || typeof raw !== "object") continue;
+    const cmd = raw;
+    if (typeof cmd.method !== "string") continue;
+    handle(cmd);
+  }
+}
+function answerNetworkBodyCommand(cmd, provider, reply) {
+  const requestId = cmd.params?.requestId;
+  if (!provider || typeof requestId !== "string") {
+    reply.replyError(cmd, "No resource with given identifier found");
+    return;
+  }
+  const lookup = cmd.method === "Network.getRequestPostData" ? provider.getRequestPostData(requestId) : provider.getResponseBody(requestId);
+  lookup.then(
+    (result) => reply.replyResult(cmd, result),
+    (err2) => reply.replyError(cmd, err2 instanceof Error ? err2.message : String(err2))
+  );
+}
+
+// src/main/services/network-forward/user-facing.ts
+var USER_FACING_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "ws:", "wss:"]);
+function isUserFacingRequest(url, internalOrigins) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return true;
+  }
+  if (!USER_FACING_SCHEMES.has(parsed.protocol)) return false;
+  for (const baseUrl of internalOrigins ?? []) {
+    if (!baseUrl) continue;
+    try {
+      if (parsed.origin === new URL(baseUrl).origin) return false;
+    } catch {
+    }
+  }
+  return true;
+}
+
+// src/main/services/network-forward/global-body-gate.ts
+var NETWORK_BODY_METHODS = ["Network.getResponseBody", "Network.getRequestPostData"];
+var DRAIN_INTERVAL_MS = 150;
+function buildNetworkOnlyHookScript() {
+  const netMethods = JSON.stringify(NETWORK_BODY_METHODS);
+  const vprefix = JSON.stringify(VIRTUAL_REQUEST_ID_PREFIX);
+  return `(function(){try{
+    if (globalThis.__diminaGlobalNetworkHookInstalled) return 'already';
+    var OUT = (globalThis.__diminaGlobalNetworkOutbound = globalThis.__diminaGlobalNetworkOutbound || []);
+    var NET_METHODS = ${netMethods};
+    var VPREFIX = ${vprefix};
+    function isNetworkBody(m){
+      if (!m || !m.method) return false;
+      if (NET_METHODS.indexOf(m.method) < 0) return false;
+      return !!(m.params && typeof m.params.requestId === 'string' && m.params.requestId.indexOf(VPREFIX) === 0);
+    }
+    var IFH = globalThis.InspectorFrontendHost;
+    if (IFH && typeof IFH.sendMessageToBackend === 'function' && !IFH.__diminaGlobalNetworkWrapped){
+      var origSend = IFH.sendMessageToBackend.bind(IFH);
+      IFH.sendMessageToBackend = function(message){
+        try {
+          var m = (typeof message === 'string') ? JSON.parse(message) : message;
+          if (isNetworkBody(m)){
+            OUT.push({ id: (m && typeof m.id === 'number') ? m.id : null,
+              method: m.method, params: m.params || {},
+              sessionId: (m && m.sessionId) ? m.sessionId : null });
+            return;
+          }
+        } catch(_){ /* fall through to original on any parse hiccup */ }
+        return origSend(message);
+      };
+      IFH.__diminaGlobalNetworkWrapped = true;
+      globalThis.__diminaGlobalNetworkHookInstalled = true;
+      return 'installed';
+    }
+    return 'partial';
+  }catch(e){ return 'error:' + (e && e.message); }})()`;
+}
+function buildReconcileScript() {
+  return `(function(){var status; try { status = ${buildNetworkOnlyHookScript()}; } catch(e){ status = 'error:'+(e&&e.message); }var batch = []; try { if (globalThis.__diminaGlobalNetworkOutbound) batch = globalThis.__diminaGlobalNetworkOutbound.splice(0); } catch(_){}return { status: status, batch: batch };})()`;
+}
+function installGlobalNetworkBodyGate(hostWc, bodies) {
+  let disposed = false;
+  let reconcileTimer = null;
+  const reply = createFrontendReplyChannel(hostWc, () => disposed);
+  function handleOutbound(batch) {
+    drainOutboundBatch(batch, (cmd) => answerNetworkBodyCommand(cmd, bodies, reply));
+  }
+  reconcileTimer = setInterval(() => {
+    if (disposed || hostWc.isDestroyed()) {
+      stop();
+      return;
+    }
+    if (!isFrontendSettled(hostWc)) return;
+    hostWc.executeJavaScript(buildReconcileScript()).then((res) => {
+      if (disposed) return;
+      const r = res ?? {};
+      handleOutbound(r.batch);
+    }).catch(() => {
+    });
+  }, DRAIN_INTERVAL_MS);
+  function stop() {
+    disposed = true;
+    if (reconcileTimer) {
+      clearInterval(reconcileTimer);
+      reconcileTimer = null;
+    }
+  }
+  return stop;
+}
 
 // src/main/services/network-forward/index.ts
 var VIRTUAL_REQUEST_ID_PREFIX = "dimina:sim:";
@@ -2566,6 +3091,122 @@ function createNetworkForwarder(bridge) {
   const broker = bridge.broker ?? createCdpSessionBroker({ connections: bridge.connections });
   let devtoolsWc = null;
   let devtoolsHostDisposable = null;
+  let globalDevtoolsWc = null;
+  let globalDevtoolsHostDisposable = null;
+  let globalBodyGateStop = null;
+  const MAX_GLOBAL_PENDING_QUEUE = 2e3;
+  let globalPendingQueue = [];
+  let globalPendingOverflowWarned = false;
+  let globalFlushTimer = null;
+  const GLOBAL_FLUSH_POLL_MAX_MS = 6e4;
+  function clearGlobalPending() {
+    globalPendingQueue = [];
+    globalPendingOverflowWarned = false;
+    if (globalFlushTimer) {
+      clearTimeout(globalFlushTimer);
+      globalFlushTimer = null;
+    }
+  }
+  function scheduleGlobalFlush(startedAt = Date.now()) {
+    if (globalFlushTimer) return;
+    if (Date.now() - startedAt >= GLOBAL_FLUSH_POLL_MAX_MS) return;
+    globalFlushTimer = setTimeout(() => {
+      globalFlushTimer = null;
+      if (globalPendingQueue.length === 0) return;
+      if (!globalDevtoolsWc || globalDevtoolsWc.isDestroyed()) {
+        clearGlobalPending();
+        return;
+      }
+      if (!isFrontendSettled(globalDevtoolsWc)) {
+        scheduleGlobalFlush(startedAt);
+        return;
+      }
+      flushGlobalPending();
+    }, READY_RETRY_MS);
+    globalFlushTimer.unref?.();
+  }
+  function flushGlobalPending() {
+    if (globalPendingQueue.length === 0) return;
+    const target = globalDevtoolsWc;
+    if (!target || target.isDestroyed()) {
+      clearGlobalPending();
+      return;
+    }
+    while (globalPendingQueue.length > 0) {
+      const { batch, chunked, remaining } = packDispatchBatch(globalPendingQueue, MAX_SINGLE_DISPATCH_CHARS, MAX_BATCH_CHARS);
+      globalPendingQueue = remaining;
+      for (const msg of chunked) dispatchChunked(target, msg);
+      if (batch.length > 0) {
+        target.executeJavaScript(buildDispatchScript(batch), true).catch(() => {
+        });
+      }
+    }
+    globalPendingOverflowWarned = false;
+  }
+  function enqueueGlobalPending(json) {
+    if (globalPendingQueue.length >= MAX_GLOBAL_PENDING_QUEUE) {
+      globalPendingQueue.shift();
+      if (!globalPendingOverflowWarned) {
+        globalPendingOverflowWarned = true;
+        console.warn(`[network-forward] global mirror queue overflow (cap ${MAX_GLOBAL_PENDING_QUEUE}): dropping oldest events while the debug window front-end is still loading`);
+      }
+    }
+    globalPendingQueue.push(json);
+    scheduleGlobalFlush();
+  }
+  function applyGlobalDevtoolsHost(host) {
+    globalDevtoolsHostDisposable?.dispose();
+    globalDevtoolsHostDisposable = null;
+    globalBodyGateStop?.();
+    globalBodyGateStop = null;
+    clearGlobalPending();
+    globalDevtoolsWc = host && !host.isDestroyed() ? host : null;
+    if (!globalDevtoolsWc) return;
+    const target = globalDevtoolsWc;
+    const onHostDestroyed = () => {
+      if (globalDevtoolsWc === target) globalDevtoolsWc = null;
+      globalBodyGateStop?.();
+      globalBodyGateStop = null;
+      clearGlobalPending();
+    };
+    const reg = bridge.connections;
+    if (reg && typeof target.once === "function") {
+      const owned = reg.acquire(target).own(onHostDestroyed);
+      globalDevtoolsHostDisposable = toDisposable3(() => owned.dispose());
+    } else {
+      if (typeof target.once === "function") target.once("destroyed", onHostDestroyed);
+      globalDevtoolsHostDisposable = toDisposable3(() => {
+        try {
+          target.removeListener?.("destroyed", onHostDestroyed);
+        } catch {
+        }
+      });
+    }
+    globalBodyGateStop = installGlobalNetworkBodyGate(target, {
+      getResponseBody: (requestId) => bodyCache.lookup(requestId),
+      getRequestPostData: (requestId) => postDataCache.lookup(requestId)
+    });
+  }
+  function dispatchToGlobal(method, params) {
+    if (!globalDevtoolsWc || globalDevtoolsWc.isDestroyed()) return;
+    let json;
+    try {
+      json = JSON.stringify({ method, params });
+    } catch {
+      return;
+    }
+    if (!isFrontendSettled(globalDevtoolsWc)) {
+      enqueueGlobalPending(json);
+      return;
+    }
+    flushGlobalPending();
+    if (json.length > MAX_SINGLE_DISPATCH_CHARS) {
+      dispatchChunked(globalDevtoolsWc, json);
+      return;
+    }
+    globalDevtoolsWc.executeJavaScript(buildDispatchScript([json]), true).catch(() => {
+    });
+  }
   let sink = "idle";
   let probeConsoleBuffer = [];
   let readyTimeoutTimer = null;
@@ -2775,10 +3416,12 @@ function createNetworkForwarder(bridge) {
   function wireNetworkCapture(wc, source, attach, epoch) {
     const ns = new RequestIdNamespace(epoch);
     const pending = /* @__PURE__ */ new Map();
+    const userFacingByRawId = /* @__PURE__ */ new Map();
     const postDataWanted = /* @__PURE__ */ new Set();
     const prefetchBodies = (rawId, encodedDataLength) => {
-      if (sink === "degraded") return;
-      if (sink === "idle" && !resolveDevtoolsWc()) return;
+      const userSinkUsable = sink !== "degraded" && !(sink === "idle" && !resolveDevtoolsWc());
+      const globalUsable = globalDevtoolsWc !== null && !globalDevtoolsWc.isDestroyed();
+      if (!userSinkUsable && !globalUsable) return;
       const virtualId = ns.resolve(rawId);
       const knownOversized = typeof encodedDataLength === "number" && encodedDataLength > DEFAULT_PER_ENTRY_MAX_CHARS;
       if (!knownOversized) {
@@ -2812,20 +3455,25 @@ function createNetworkForwarder(bridge) {
       const req = pending.get(p.requestId);
       if (req) req.status = p.response?.status ?? 0;
     }
+    function retirePending(rawId) {
+      userFacingByRawId.delete(rawId);
+      const req = pending.get(rawId);
+      if (!req) return void 0;
+      pending.delete(rawId);
+      return req;
+    }
     function onLoadingFinished(params) {
       const p = params;
       if (typeof p?.requestId === "string") prefetchBodies(p.requestId, p.encodedDataLength);
-      const req = pending.get(p.requestId);
+      const req = retirePending(p?.requestId);
       if (!req) return;
-      pending.delete(p.requestId);
       maybeFallback({ source, url: req.url, method: req.method, status: req.status });
     }
     function onLoadingFailed(params) {
       const p = params;
       postDataWanted.delete(p?.requestId);
-      const req = pending.get(p.requestId);
+      const req = retirePending(p?.requestId);
       if (!req) return;
-      pending.delete(p.requestId);
       maybeFallback({
         source,
         url: req.url,
@@ -2840,10 +3488,29 @@ function createNetworkForwarder(bridge) {
       "Network.loadingFinished": onLoadingFinished,
       "Network.loadingFailed": onLoadingFailed
     };
+    function resolveUserFacing(method, params, rawId) {
+      if (method === "Network.requestWillBeSent") {
+        const url = params?.request?.url;
+        const verdict = typeof url === "string" ? isUserFacingRequest(url, [bridge.getResourceServerBaseUrl?.(), bridge.getSimulatorServerBaseUrl?.()]) : true;
+        if (rawId) {
+          if (userFacingByRawId.size >= MAX_PENDING) userFacingByRawId.clear();
+          userFacingByRawId.set(rawId, verdict);
+        }
+        return verdict;
+      }
+      if (rawId && userFacingByRawId.has(rawId)) return userFacingByRawId.get(rawId);
+      if (method === "Network.requestWillBeSentExtraInfo") return false;
+      return true;
+    }
     const onMessage = (_event, method, params) => {
       if (FORWARDED_METHODS.has(method)) {
         const rewritten = rewriteRequestId(method, params, ns);
-        enqueueNative(rewritten.method, rewritten.params);
+        dispatchToGlobal(rewritten.method, rewritten.params);
+        const rawId = params?.requestId;
+        const userFacing = resolveUserFacing(method, params, typeof rawId === "string" ? rawId : void 0);
+        if (userFacing) {
+          enqueueNative(rewritten.method, rewritten.params);
+        }
       } else if (REWRITE_REQUEST_ID_METHODS.has(method)) {
         rewriteRequestId(method, params, ns);
       }
@@ -3004,6 +3671,14 @@ function createNetworkForwarder(bridge) {
       readyRetryTimer = null;
     }
   });
+  registry.add(() => {
+    globalDevtoolsHostDisposable?.dispose();
+    globalDevtoolsHostDisposable = null;
+    globalBodyGateStop?.();
+    globalBodyGateStop = null;
+    globalDevtoolsWc = null;
+    clearGlobalPending();
+  });
   registry.add(() => {
     bodyCache.clear();
     postDataCache.clear();
@@ -3020,6 +3695,7 @@ function createNetworkForwarder(bridge) {
     detachSimulator,
     attachRenderGuest,
     setDevtoolsHost: (wc) => applyDevtoolsHost(wc),
+    setGlobalDevtoolsHost: (wc) => applyGlobalDevtoolsHost(wc),
     // report() has no observing debugger, so there's no live CDP event to push
     // natively — surface it via the console fallback line.
     report: (record) => forwardToConsole(record),
@@ -3048,13 +3724,13 @@ function routeByDomain(method) {
 function isRenderEventMethod(method) {
   return routeByDomain(method) === "render";
 }
-var NETWORK_BODY_METHODS = [
+var NETWORK_BODY_METHODS2 = [
   "Network.getResponseBody",
   "Network.getRequestPostData"
 ];
 function buildElementsHookScript() {
   const prefixes = JSON.stringify(RENDER_DOMAIN_PREFIXES);
-  const netMethods = JSON.stringify(NETWORK_BODY_METHODS);
+  const netMethods = JSON.stringify(NETWORK_BODY_METHODS2);
   const vprefix = JSON.stringify(VIRTUAL_REQUEST_ID_PREFIX);
   return `(function(){try{
     if (globalThis.__diminaElementsHookInstalled) return 'already';
@@ -3102,17 +3778,14 @@ function buildElementsHookScript() {
     return 'partial';
   }catch(e){ return 'error:' + (e && e.message); }})()`;
 }
-function buildReconcileScript() {
+function buildReconcileScript2() {
   return `(function(){var status; try { status = ${buildElementsHookScript()}; } catch(e){ status = 'error:'+(e&&e.message); }var batch = []; try { if (globalThis.__diminaElementsOutbound) batch = globalThis.__diminaElementsOutbound.splice(0); } catch(_){}return { status: status, batch: batch };})()`;
 }
-function buildDispatchScript2(message) {
-  return `(()=>{try{if(!${PROBE_DEVTOOLS_API})return false;window.DevToolsAPI.dispatchMessage(JSON.parse(${JSON.stringify(message)}));return true;}catch(_){return false}})()`;
-}
 function buildDocumentUpdatedScript() {
   const msg = JSON.stringify({ method: "DOM.documentUpdated", params: {} });
-  return buildDispatchScript2(msg);
+  return buildSingleDispatchScript(msg);
 }
-var DRAIN_INTERVAL_MS = 150;
+var DRAIN_INTERVAL_MS2 = 150;
 function installElementsForward(deps) {
   const { devtoolsWc, bridge } = deps;
   const ownsBroker = !deps.broker;
@@ -3148,39 +3821,7 @@ function installElementsForward(deps) {
       }
     }
   };
-  function dispatchToFrontend(message) {
-    if (disposed || devtoolsWc.isDestroyed()) return;
-    if (!isFrontendSettled(devtoolsWc)) return;
-    let json;
-    try {
-      json = JSON.stringify(message);
-    } catch {
-      return;
-    }
-    if (json.length > MAX_SINGLE_DISPATCH_CHARS) {
-      const chunks = [];
-      for (let i = 0; i < json.length; i += CHUNK_CHARS) {
-        chunks.push(json.slice(i, i + CHUNK_CHARS));
-      }
-      let script2;
-      try {
-        script2 = buildChunkedDispatchScript(chunks, json.length);
-      } catch {
-        return;
-      }
-      devtoolsWc.executeJavaScript(script2, true).catch(() => {
-      });
-      return;
-    }
-    let script;
-    try {
-      script = buildDispatchScript2(json);
-    } catch {
-      return;
-    }
-    devtoolsWc.executeJavaScript(script, true).catch(() => {
-    });
-  }
+  const { dispatchToFrontend, replyResult, replyError } = createFrontendReplyChannel(devtoolsWc, () => disposed);
   function pushDocumentUpdated() {
     if (disposed || devtoolsWc.isDestroyed()) return;
     if (!isFrontendSettled(devtoolsWc)) return;
@@ -3193,16 +3834,6 @@ function installElementsForward(deps) {
     devtoolsWc.executeJavaScript(script, true).catch(() => {
     });
   }
-  function replyResult(cmd, result) {
-    const msg = { id: cmd.id, result };
-    if (cmd.sessionId) msg.sessionId = cmd.sessionId;
-    dispatchToFrontend(msg);
-  }
-  function replyError(cmd, message) {
-    const msg = { id: cmd.id, error: { code: -32e3, message } };
-    if (cmd.sessionId) msg.sessionId = cmd.sessionId;
-    dispatchToFrontend(msg);
-  }
   function activeRenderWc() {
     try {
       const wc = bridge.getActiveRenderWc(deps.appId);
@@ -3275,34 +3906,16 @@ function installElementsForward(deps) {
     });
   }
   function answerNetworkCommand(cmd) {
-    const provider = deps.network;
-    const requestId = cmd.params?.requestId;
-    if (!provider || typeof requestId !== "string") {
-      replyError(cmd, "No resource with given identifier found");
-      return;
-    }
-    const lookup = cmd.method === "Network.getRequestPostData" ? provider.getRequestPostData(requestId) : provider.getResponseBody(requestId);
-    lookup.then(
-      (result) => {
-        if (!disposed) replyResult(cmd, result);
-      },
-      (err2) => {
-        if (!disposed) replyError(cmd, err2 instanceof Error ? err2.message : String(err2));
-      }
-    );
+    answerNetworkBodyCommand(cmd, deps.network, { replyResult, replyError });
   }
   function handleOutbound(batch) {
-    if (!Array.isArray(batch)) return;
-    for (const raw of batch) {
-      if (!raw || typeof raw !== "object") continue;
-      const cmd = raw;
-      if (typeof cmd.method !== "string") continue;
+    drainOutboundBatch(batch, (cmd) => {
       if (cmd.route === "network") {
         answerNetworkCommand(cmd);
-        continue;
+        return;
       }
       routeCommand(cmd);
-    }
+    });
   }
   const onRenderEvent = (event) => {
     if (disposed) return;
@@ -3325,7 +3938,7 @@ function installElementsForward(deps) {
         return;
       }
       if (!isFrontendSettled(devtoolsWc)) return;
-      devtoolsWc.executeJavaScript(buildReconcileScript()).then((res) => {
+      devtoolsWc.executeJavaScript(buildReconcileScript2()).then((res) => {
         if (disposed) return;
         const r = res ?? {};
         if (r.status === "installed") {
@@ -3336,7 +3949,7 @@ function installElementsForward(deps) {
         handleOutbound(r.batch);
       }).catch(() => {
       });
-    }, DRAIN_INTERVAL_MS);
+    }, DRAIN_INTERVAL_MS2);
   };
   devtoolsWc.on("dom-ready", onReady);
   onReady();
@@ -3556,6 +4169,7 @@ function createDevtoolsHost(ctx, reconciler, deps) {
   let nativeDevtoolsSourceWc = null;
   let devtoolsHostUsed = false;
   let unsubscribeNativeRenderEvents = null;
+  let unsubscribeNativeServiceHostReady = null;
   let stopElementsForward = null;
   let stopServiceConsole = null;
   let nativeDevtoolsRetryTimer = null;
@@ -3594,6 +4208,13 @@ function createDevtoolsHost(ctx, reconciler, deps) {
       }
       unsubscribeNativeRenderEvents = null;
     }
+    if (unsubscribeNativeServiceHostReady) {
+      try {
+        unsubscribeNativeServiceHostReady();
+      } catch {
+      }
+      unsubscribeNativeServiceHostReady = null;
+    }
     closeNativeDevtoolsSource();
   }
   function injectOpenResourceHandler(serviceWc, devtoolsWc) {
@@ -3624,6 +4245,25 @@ function createDevtoolsHost(ctx, reconciler, deps) {
     } catch {
     }
   }
+  function applyConsoleFilter(devtoolsWc) {
+    try {
+      if (devtoolsWc.isDestroyed()) return;
+      const inject = () => {
+        void whenFrontendBootstrapped(devtoolsWc).then((ready) => {
+          if (!ready || devtoolsWc.isDestroyed()) return;
+          try {
+            void devtoolsWc.executeJavaScript(buildConsoleFilterScript()).catch(() => {
+            });
+            void devtoolsWc.executeJavaScript(buildLiveConsoleFilterScript()).catch(() => {
+            });
+          } catch {
+          }
+        });
+      };
+      injectWhenReady(devtoolsWc, "console-filter", inject);
+    } catch {
+    }
+  }
   function wireOpenInEditor(serviceWc, devtoolsWc) {
     if (!devtoolsWc.isDestroyed()) {
       injectWhenReady(devtoolsWc, "open-in-editor", () => injectOpenResourceHandler(serviceWc, devtoolsWc));
@@ -3669,6 +4309,7 @@ function createDevtoolsHost(ctx, reconciler, deps) {
       devtoolsHostUsed = true;
       wireOpenInEditor(next, simulatorView.webContents);
       customizeDevtoolsTabs(simulatorView.webContents);
+      applyConsoleFilter(simulatorView.webContents);
       try {
         stopServiceConsole?.();
       } catch {
@@ -3694,8 +4335,10 @@ function createDevtoolsHost(ctx, reconciler, deps) {
     if (!wc || wc.isDestroyed()) return false;
     return pointNativeDevtoolsAtServiceWc(wc);
   }
-  function scheduleNativeDevtoolsFollow(appId, attempt = 0) {
-    if (attempt >= 20) return;
+  const NATIVE_DEVTOOLS_FALLBACK_POLL_MAX_MS = 6e4;
+  const NATIVE_DEVTOOLS_FALLBACK_POLL_INTERVAL_MS = 50;
+  function scheduleNativeDevtoolsFollow(appId, startedAt = Date.now()) {
+    if (Date.now() - startedAt >= NATIVE_DEVTOOLS_FALLBACK_POLL_MAX_MS) return;
     if (!ctx.bridge?.isNativeHost()) return;
     const token = nativeDevtoolsRetryToken;
     if (nativeDevtoolsRetryTimer) clearTimeout(nativeDevtoolsRetryTimer);
@@ -3703,14 +4346,27 @@ function createDevtoolsHost(ctx, reconciler, deps) {
       nativeDevtoolsRetryTimer = null;
       if (token !== nativeDevtoolsRetryToken) return;
       if (pointNativeDevtoolsAtActiveServiceHost(appId)) return;
-      scheduleNativeDevtoolsFollow(appId, attempt + 1);
-    }, 50);
+      scheduleNativeDevtoolsFollow(appId, startedAt);
+    }, NATIVE_DEVTOOLS_FALLBACK_POLL_INTERVAL_MS);
   }
   function followNativeDevtoolsServiceHost(appId) {
     clearNativeDevtoolsRetry();
     if (pointNativeDevtoolsAtActiveServiceHost(appId)) return;
     scheduleNativeDevtoolsFollow(appId);
   }
+  function onNativeServiceHostReady(event) {
+    if (!ctx.bridge?.isNativeHost()) return;
+    if (!simulatorView || simulatorView.webContents.isDestroyed()) return;
+    const wc = electronWebContents.fromId(event.serviceWcId);
+    if (!wc || wc.isDestroyed()) return;
+    const current = ctx.bridge.getServiceWc(event.appId);
+    if (current && current.id !== event.serviceWcId) return;
+    if (pointNativeDevtoolsAtServiceWc(wc)) {
+      clearNativeDevtoolsRetry();
+      return;
+    }
+    scheduleNativeDevtoolsFollow(event.appId);
+  }
   function onNativeRenderEvent(event) {
     if (event.kind !== "activePage" && event.kind !== "domReady") return;
     followNativeDevtoolsServiceHost(event.appId);
@@ -3726,7 +4382,7 @@ function createDevtoolsHost(ctx, reconciler, deps) {
       }
       simulatorView = null;
     }
-    simulatorView = new WebContentsView3();
+    simulatorView = new WebContentsView4();
     const devtoolsWc = simulatorView.webContents;
     raiseExecuteJavaScriptListenerCeiling(devtoolsWc);
     ctx.networkForward?.setDevtoolsHost(devtoolsWc);
@@ -3757,27 +4413,21 @@ function createDevtoolsHost(ctx, reconciler, deps) {
       });
     }
     injectWhenReady(devtoolsWc, "console-default", () => {
-      devtoolsWc.executeJavaScript(`
-        (function() {
-          try { localStorage.setItem('panel-selectedTab', '"console"') } catch {}
-          let tries = 0
-          const timer = setInterval(() => {
-            tries++
+      void whenFrontendBootstrapped(devtoolsWc).then((ready) => {
+        if (!ready || devtoolsWc.isDestroyed()) return;
+        devtoolsWc.executeJavaScript(`
+          (function() {
             try {
-              const UI = globalThis.UI
-              const vm = UI && UI.ViewManager && typeof UI.ViewManager.instance === 'function'
-                ? UI.ViewManager.instance()
+              var EUI = globalThis.EUI
+              var vm = EUI && EUI.ViewManager && EUI.ViewManager.ViewManager
+                && typeof EUI.ViewManager.ViewManager.instance === 'function'
+                ? EUI.ViewManager.ViewManager.instance()
                 : null
-              if (vm && typeof vm.showView === 'function') {
-                vm.showView('console')
-                clearInterval(timer)
-                return
-              }
-            } catch {}
-            if (tries > 80) clearInterval(timer)
-          }, 50)
-        })()
-      `).catch(() => {
+              if (vm && typeof vm.showView === 'function') void vm.showView('console')
+            } catch (_) {}
+          })()
+        `).catch(() => {
+        });
       });
     });
     reconciler.reconcileNow();
@@ -3788,6 +4438,7 @@ function createDevtoolsHost(ctx, reconciler, deps) {
     rebuildDevtoolsHostView();
     if (ctx.bridge?.isNativeHost()) {
       unsubscribeNativeRenderEvents = ctx.bridge.onRenderEvent(onNativeRenderEvent);
+      unsubscribeNativeServiceHostReady = ctx.bridge.onServiceHostReady(onNativeServiceHostReady);
       followNativeDevtoolsServiceHost();
     }
   }
@@ -3829,7 +4480,7 @@ function createDevtoolsHost(ctx, reconciler, deps) {
 }
 
 // src/main/services/views/host-toolbar-view.ts
-import { WebContentsView as WebContentsView4 } from "electron";
+import { WebContentsView as WebContentsView5 } from "electron";
 
 // src/main/services/views/host-toolbar-session-runtime.ts
 import { session } from "electron";
@@ -4025,7 +4676,7 @@ function createHostToolbarView(ctx, reconciler, deps) {
     if (hostToolbarPreloadOverride !== null) {
       webPreferences.preload = hostToolbarPreloadOverride;
     }
-    const view = new WebContentsView4({ webPreferences });
+    const view = new WebContentsView5({ webPreferences });
     hostToolbarView = view;
     hostToolbarPort.attach(view.webContents);
     try {
@@ -4127,7 +4778,7 @@ function createHostToolbarView(ctx, reconciler, deps) {
 }
 
 // src/main/services/views/overlay-panels-view.ts
-import { WebContentsView as WebContentsView5 } from "electron";
+import { WebContentsView as WebContentsView6 } from "electron";
 import path8 from "path";
 
 // src/main/services/layout/index.ts
@@ -4195,7 +4846,7 @@ function createOverlayPanelsView(ctx, reconciler, deps) {
   }
   async function showSettings() {
     if (!settingsView) {
-      settingsView = new WebContentsView5({
+      settingsView = new WebContentsView6({
         webPreferences: {
           nodeIntegration: false,
           contextIsolation: true,
@@ -4217,7 +4868,7 @@ function createOverlayPanelsView(ctx, reconciler, deps) {
   }
   function showPopover(data) {
     hidePopover();
-    const popover = new WebContentsView5({
+    const popover = new WebContentsView6({
       webPreferences: {
         nodeIntegration: false,
         contextIsolation: true,
@@ -4284,7 +4935,7 @@ function createOverlayPanelsView(ctx, reconciler, deps) {
 }
 
 // src/main/services/views/native-simulator-view.ts
-import { ipcMain as ipcMain2, nativeTheme as nativeTheme4, shell as shell2, WebContentsView as WebContentsView6, webContents as webContents2 } from "electron";
+import { ipcMain as ipcMain2, nativeTheme as nativeTheme4, shell as shell2, WebContentsView as WebContentsView7, webContents as webContents2 } from "electron";
 
 // src/main/services/simulator/custom-apis.ts
 async function handleCustomApiBridgeRequest(apis, req) {
@@ -4613,7 +5264,7 @@ function createNativeSimulatorView(ctx, reconciler, deps) {
     const route = parseRoute(simulatorUrl);
     const partition = miniappPartition(route?.appId, ctx.workspace?.getProjectPath());
     configureMiniappSession(partition);
-    const view = new WebContentsView6({
+    const view = new WebContentsView7({
       webPreferences: {
         nodeIntegration: false,
         contextIsolation: false,
@@ -4852,10 +5503,10 @@ function createWindowService(mainWindow) {
 }
 
 // src/main/windows/settings-window/create.ts
-import { BrowserWindow as BrowserWindow3 } from "electron";
+import { BrowserWindow as BrowserWindow4 } from "electron";
 import path9 from "path";
 async function createSettingsWindow(parent, rendererDir2) {
-  const win = new BrowserWindow3({
+  const win = new BrowserWindow4({
     width: 420,
     height: 560,
     minWidth: 380,
@@ -5540,7 +6191,11 @@ function setupCompileWorkerStandby(ctx, deps = {}) {
       ctx.diagnostics?.report({
         severity: EVENT_SEVERITY[ev.type] ?? "info",
         code: "compile-standby",
-        message: detail
+        message: detail,
+        // Devtools-tooling-only state, unrelated to the inspected mini-program
+        // — must never reach the right-panel (user-facing) Console panel; see
+        // console-forward/index.ts's audience gate and global-diagnostics-mirror.ts.
+        audience: "internal"
       });
     } catch {
     }
@@ -6139,6 +6794,13 @@ var settingsModule = {
   setup: (ctx) => registerSettingsIpc(ctx)
 };
 
+// src/main/ipc/internal-devtools.ts
+function registerInternalDevtoolsIpc(ctx) {
+  return new IpcRegistry(ctx.senderPolicy).handle(InternalDevtoolsChannel.Open, () => {
+    ctx.internalDevtoolsWindow?.open();
+  });
+}
+
 // src/main/ipc/simulator-module.ts
 import { DisposableRegistry as DisposableRegistry5 } from "@dimina-kit/electron-deck/main";
 
@@ -6297,7 +6959,7 @@ function setCorsHeaders(res) {
 }
 
 // src/main/windows/service-host-window/create.ts
-import { app as app10, BrowserWindow as BrowserWindow4 } from "electron";
+import { app as app10, BrowserWindow as BrowserWindow5 } from "electron";
 import path16 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var SERVICE_HOST_PARTITION = SHARED_MINIAPP_PARTITION;
@@ -6306,7 +6968,7 @@ var serviceHostHtmlPath = path16.join(devtoolsPackageRoot, "dist/service-host/se
 function constructServiceHostWindow(opts = {}) {
   const partition = opts.partition ?? SERVICE_HOST_PARTITION;
   configureMiniappSession(partition);
-  return new BrowserWindow4({
+  return new BrowserWindow5({
     width: 980,
     height: 720,
     show: false,
@@ -6387,7 +7049,7 @@ function createServiceHostWindow(opts) {
 }
 
 // src/main/services/service-host-pool/pool.ts
-import { BrowserWindow as BrowserWindow5 } from "electron";
+import { BrowserWindow as BrowserWindow6 } from "electron";
 var BLANK_URL = "about:blank";
 var HARD_MAX_POOL_SIZE = 4;
 var RESET_STORAGES = [
@@ -6584,7 +7246,7 @@ var ServiceHostPool = class {
     }
   }
   createWindow(spec) {
-    return new BrowserWindow5({
+    return new BrowserWindow6({
       show: false,
       width: spec.size?.width,
       height: spec.size?.height,
@@ -6692,20 +7354,32 @@ var ServiceHostPool = class {
 
 // src/main/services/console-forward/index.ts
 import { DisposableRegistry as DisposableRegistry3, toDisposable as toDisposable4 } from "@dimina-kit/electron-deck/main";
-var FORWARDABLE_LEVELS = /* @__PURE__ */ new Set(["log", "warn", "error", "info", "debug"]);
+
+// src/main/services/console-forward/internal-log.ts
+var SERVICE_PREFIX = "[service]";
+var RENDER_PREFIX = "[system]";
+function isInternalLogMessage(entry) {
+  const first = entry.args?.[0];
+  if (typeof first !== "string") return false;
+  if (first === RENDER_PREFIX) return true;
+  return first === SERVICE_PREFIX || first.startsWith(`${SERVICE_PREFIX} `);
+}
+
+// src/main/services/console-forward/index.ts
+var FORWARDABLE_LEVELS2 = /* @__PURE__ */ new Set(["log", "warn", "error", "info", "debug"]);
 function buildForwardScript2(level, args) {
-  const method = FORWARDABLE_LEVELS.has(level) ? level : "log";
+  const method = FORWARDABLE_LEVELS2.has(level) ? level : "log";
   const argsJson = JSON.stringify(args ?? []);
   return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}]('[\u89C6\u56FE]',...a)}catch(_){}})()
 //# sourceURL=${RENDER_FORWARD_SOURCE_URL}`;
 }
-var DIAGNOSTIC_CONSOLE_CALL = {
+var DIAGNOSTIC_CONSOLE_CALL2 = {
   error: "console.error",
   warn: "console.warn",
   info: "console.info"
 };
 function buildDiagnosticScript(severity, message) {
-  const call = DIAGNOSTIC_CONSOLE_CALL[severity];
+  const call = DIAGNOSTIC_CONSOLE_CALL2[severity];
   const argsJson = JSON.stringify([`[dimina-kit] ${message}`]);
   return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});${call}(...a)}catch(_){}})()
 //# sourceURL=${RENDER_FORWARD_SOURCE_URL}`;
@@ -6713,6 +7387,8 @@ function buildDiagnosticScript(severity, message) {
 function createConsoleForwarder(bridge, diagnostics) {
   const sinks = /* @__PURE__ */ new Set();
   const registry = new DisposableRegistry3();
+  const CONSOLE_BUFFER_CAP = 200;
+  const buffer = [];
   const pendingBySession = /* @__PURE__ */ new Map();
   const pendingGlobal = [];
   const readySessions = /* @__PURE__ */ new Set();
@@ -6721,6 +7397,7 @@ function createConsoleForwarder(bridge, diagnostics) {
     });
   }
   function handleDiagnostic(d) {
+    if (d.audience === "internal") return;
     if (d.appSessionId) {
       const wc2 = readySessions.has(d.appSessionId) && bridge.getServiceWcForBridge ? bridge.getServiceWcForBridge(d.appSessionId) : null;
       if (wc2 && !wc2.isDestroyed()) {
@@ -6743,6 +7420,7 @@ function createConsoleForwarder(bridge, diagnostics) {
     registry.add(diagnostics.subscribe(handleDiagnostic, { replay: true }));
   }
   function forwardRenderToServiceHost(entry) {
+    if (isInternalLogMessage(entry)) return;
     let wc = null;
     if (entry.bridgeId && bridge.getServiceWcForBridge) {
       wc = bridge.getServiceWcForBridge(entry.bridgeId);
@@ -6764,6 +7442,8 @@ function createConsoleForwarder(bridge, diagnostics) {
     // (render only — see loop-safety invariant in the module header).
     emit(raw) {
       const entry = raw ?? {};
+      buffer.push(entry);
+      if (buffer.length > CONSOLE_BUFFER_CAP) buffer.shift();
       for (const sink of sinks) {
         try {
           sink(entry);
@@ -6772,7 +7452,15 @@ function createConsoleForwarder(bridge, diagnostics) {
       }
       if (entry.source === "render") forwardRenderToServiceHost(entry);
     },
-    subscribe(sink) {
+    subscribe(sink, opts) {
+      if (opts?.replay) {
+        for (const entry of buffer) {
+          try {
+            sink(entry);
+          } catch {
+          }
+        }
+      }
       sinks.add(sink);
       return registry.add(toDisposable4(() => {
         sinks.delete(sink);
@@ -6794,6 +7482,7 @@ function createConsoleForwarder(bridge, diagnostics) {
     },
     dispose() {
       sinks.clear();
+      buffer.length = 0;
       pendingBySession.clear();
       pendingGlobal.length = 0;
       readySessions.clear();
@@ -7467,6 +8156,9 @@ function installBridgeRouter(ctx) {
     pool: null,
     emitRenderEvent: () => {
     },
+    emitServiceHostReady: () => {
+    },
+    lastServiceHostReady: null,
     connections: ctx.connections,
     debugTap: createDebugTap({ enabled: resolveDebugTapEnabled() }),
     appLifecycle: createAppLifecycleController(),
@@ -7514,6 +8206,18 @@ function installBridgeRouter(ctx) {
     }
   };
   state.emitRenderEvent = emitRenderEvent;
+  const serviceHostReadyListeners = /* @__PURE__ */ new Set();
+  const emitServiceHostReady = (event) => {
+    state.lastServiceHostReady = event;
+    for (const listener of serviceHostReadyListeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.warn("[bridge-router] service-host-ready listener threw:", error);
+      }
+    }
+  };
+  state.emitServiceHostReady = emitServiceHostReady;
   const bridgeHandle = {
     isNativeHost: () => true,
     resolveRenderWc: (bridgeId) => {
@@ -7539,6 +8243,10 @@ function installBridgeRouter(ctx) {
       const ap = resolveCurrentApp(state, ctx, appId);
       return ap?.pageStack ?? null;
     },
+    getResourceBaseUrl: (appId) => {
+      const ap = resolveCurrentApp(state, ctx, appId);
+      return ap?.resourceBaseUrl ?? null;
+    },
     getActiveRenderWc: (appId) => {
       const ap = resolveCurrentApp(state, ctx, appId);
       if (!ap) return null;
@@ -7549,6 +8257,23 @@ function installBridgeRouter(ctx) {
       renderEventListeners.add(listener);
       return () => renderEventListeners.delete(listener);
     },
+    onServiceHostReady: (listener) => {
+      serviceHostReadyListeners.add(listener);
+      const candidate = state.lastServiceHostReady;
+      if (candidate) {
+        queueMicrotask(() => {
+          if (!serviceHostReadyListeners.has(listener)) return;
+          const ap = state.appSessions.get(candidate.appSessionId);
+          if (!ap || ap.serviceWc.isDestroyed() || ap.serviceWc.id !== candidate.serviceWcId) return;
+          try {
+            listener(candidate);
+          } catch (error) {
+            console.warn("[bridge-router] service-host-ready catch-up listener threw:", error);
+          }
+        });
+      }
+      return () => serviceHostReadyListeners.delete(listener);
+    },
     getDevice: () => currentDevice,
     setDevice: (device) => {
       currentDevice = device;
@@ -8078,6 +8803,7 @@ function handleNavCallback(state, sender, payload) {
 async function bootServiceHost(state, ap, ctx) {
   if (state.appSessions.get(ap.appSessionId) !== ap) return;
   ctx.consoleForwarder?.notifyServiceHostReady?.(ap.appSessionId);
+  state.emitServiceHostReady({ appId: ap.appId, appSessionId: ap.appSessionId, serviceWcId: ap.serviceWc.id });
   ap.logicInjected = await injectLogicBundle(ap);
   if (!ap.logicInjected) {
     const reason = reportLogicLoadFailure(ap, ctx);
@@ -12128,7 +12854,7 @@ function enableDevRendererAutoReload(rendererDir2) {
   const watcher = fs13.watch(rendererDir2, { recursive: true }, () => {
     if (reloadTimer) clearTimeout(reloadTimer);
     reloadTimer = setTimeout(() => {
-      for (const win of BrowserWindow8.getAllWindows()) {
+      for (const win of BrowserWindow9.getAllWindows()) {
         win.webContents.reload();
       }
     }, 300);
@@ -12164,10 +12890,33 @@ async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
   context.connections.acquire(mainWindow.webContents);
   context.registry.add(registerAppIpc(context));
   context.registry.add(registerProjectFsIpc(context));
+  context.internalDevtoolsWindow = createInternalDevtoolsWindow(mainWindow, { isAppQuitting });
+  context.registry.add(toDisposable8(() => context.internalDevtoolsWindow?.dispose()));
+  context.registry.add(registerInternalDevtoolsIpc(context));
   context.registry.add(setupSimulatorSessionPolicy());
   context.registry.add(installThemeBackgroundSync());
   if (!config.adapter) context.registry.add(setupCompileWorkerStandby(context));
   registerBuiltinModules(config, context);
+  if (context.consoleForwarder && context.internalDevtoolsWindow) {
+    const consoleMirror = createGlobalConsoleMirror(
+      context.consoleForwarder,
+      mainWindow.webContents,
+      context.internalDevtoolsWindow.onHostChanged,
+      // CDP transport (never executeJavaScript) — see the mirror's inject()
+      // doc for the setDevToolsWebContents + external-CDP double-attach hang.
+      { broker: context.cdpSessionBroker }
+    );
+    context.registry.add(toDisposable8(() => consoleMirror.dispose()));
+  }
+  if (context.diagnostics && context.internalDevtoolsWindow) {
+    const diagnosticsMirror = createGlobalDiagnosticsMirror(
+      context.diagnostics,
+      mainWindow.webContents,
+      context.internalDevtoolsWindow.onHostChanged,
+      { broker: context.cdpSessionBroker }
+    );
+    context.registry.add(toDisposable8(() => diagnosticsMirror.dispose()));
+  }
   const simSession = session4.fromPartition(SHARED_MINIAPP_PARTITION);
   context.registry.add(setupSimulatorTempFiles(simSession));
   installMenu(config, mainWindow, context);
@@ -12267,6 +13016,17 @@ async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
   if (context.bridge?.isNativeHost()) {
     const networkForward = createNetworkForwarder({
       getServiceWc: (appId) => context.bridge?.getServiceWc(appId) ?? null,
+      getResourceServerBaseUrl: () => context.bridge?.getResourceBaseUrl?.() ?? null,
+      // The simulator shell's own static-asset server (serves simulator.html
+      // + its JS/CSS, independent from the resource server above — see
+      // NetworkForwarderBridge.getSimulatorServerBaseUrl's doc). Host is
+      // always 'localhost' — see shared/simulator-route.ts's
+      // buildSimulatorUrlFromSpec default. Absent (null port) when no
+      // project is open.
+      getSimulatorServerBaseUrl: () => {
+        const port = context.workspace?.getSession()?.port;
+        return typeof port === "number" ? `http://localhost:${port}/` : null;
+      },
       connections: context.connections,
       broker: context.cdpSessionBroker
     });
@@ -12275,6 +13035,12 @@ async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
     context.registry.add(() => {
       context.networkForward = void 0;
     });
+    context.registry.add(toDisposable8(
+      context.internalDevtoolsWindow?.onHostChanged((hostWc) => {
+        context.networkForward?.setGlobalDevtoolsHost(hostWc);
+      }) ?? (() => {
+      })
+    ));
     context.registry.add(setupSimulatorWxml(mainWindow.webContents, {
       senderPolicy: context.senderPolicy,
       bridge: context.bridge,