@dimina-kit/devtools 0.4.0-dev.20260718095333 → 0.4.0-dev.20260728063215

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,9 +897,9 @@ function registerProjectFsIpc(ctx) {
 }
 
 // src/main/app/app.ts
-import { app as app15, BrowserWindow as BrowserWindow8, nativeImage, session as session4 } from "electron";
-import fs12 from "fs";
-import path24 from "path";
+import { app as app15, BrowserWindow as BrowserWindow9, nativeImage, session as session4 } from "electron";
+import fs13 from "fs";
+import path25 from "path";
 
 // src/main/utils/paths.ts
 import fs3 from "fs";
@@ -1074,13 +1079,268 @@ 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;
 function isAppQuitting() {
   return appIsQuitting;
 }
-function registerAppLifecycle() {
+function registerAppLifecycle(onBeforeQuit) {
   app4.on("window-all-closed", () => {
     globalShortcut2.unregisterAll();
     app4.quit();
@@ -1088,6 +1348,11 @@ function registerAppLifecycle() {
   app4.on("before-quit", () => {
     appIsQuitting = true;
     globalShortcut2.unregisterAll();
+    try {
+      onBeforeQuit?.();
+    } catch (err2) {
+      console.error("[lifecycle] onBeforeQuit handler threw:", err2);
+    }
   });
 }
 
@@ -1569,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 = {
@@ -1626,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,
@@ -1750,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) {
@@ -2211,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
@@ -2393,15 +2764,174 @@ var PrefetchCache = class {
       total -= e.size;
     }
   }
-};
-
-// src/main/services/network-forward/frontend-dispatch.ts
-var PROBE_DEVTOOLS_API = `(window.DevToolsAPI && typeof window.DevToolsAPI.dispatchMessage === 'function')`;
-var MAX_SINGLE_DISPATCH_CHARS = 1e6;
-var CHUNK_CHARS = 256 * 1024;
-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}})()`;
+};
+
+// src/main/services/network-forward/frontend-dispatch.ts
+var PROBE_DEVTOOLS_API = `(window.DevToolsAPI && typeof window.DevToolsAPI.dispatchMessage === 'function')`;
+var MAX_SINGLE_DISPATCH_CHARS = 1e6;
+var CHUNK_CHARS = 256 * 1024;
+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
@@ -2561,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;
@@ -2770,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) {
@@ -2807,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,
@@ -2835,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);
       }
@@ -2999,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();
@@ -3015,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),
@@ -3043,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';
@@ -3097,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;
@@ -3143,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;
@@ -3188,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);
@@ -3270,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;
@@ -3320,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") {
@@ -3331,7 +3949,7 @@ function installElementsForward(deps) {
         handleOutbound(r.batch);
       }).catch(() => {
       });
-    }, DRAIN_INTERVAL_MS);
+    }, DRAIN_INTERVAL_MS2);
   };
   devtoolsWc.on("dom-ready", onReady);
   onReady();
@@ -3551,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;
@@ -3589,6 +4208,13 @@ function createDevtoolsHost(ctx, reconciler, deps) {
       }
       unsubscribeNativeRenderEvents = null;
     }
+    if (unsubscribeNativeServiceHostReady) {
+      try {
+        unsubscribeNativeServiceHostReady();
+      } catch {
+      }
+      unsubscribeNativeServiceHostReady = null;
+    }
     closeNativeDevtoolsSource();
   }
   function injectOpenResourceHandler(serviceWc, devtoolsWc) {
@@ -3619,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));
@@ -3664,6 +4309,7 @@ function createDevtoolsHost(ctx, reconciler, deps) {
       devtoolsHostUsed = true;
       wireOpenInEditor(next, simulatorView.webContents);
       customizeDevtoolsTabs(simulatorView.webContents);
+      applyConsoleFilter(simulatorView.webContents);
       try {
         stopServiceConsole?.();
       } catch {
@@ -3689,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);
@@ -3698,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);
@@ -3721,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);
@@ -3752,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();
@@ -3783,6 +4438,7 @@ function createDevtoolsHost(ctx, reconciler, deps) {
     rebuildDevtoolsHostView();
     if (ctx.bridge?.isNativeHost()) {
       unsubscribeNativeRenderEvents = ctx.bridge.onRenderEvent(onNativeRenderEvent);
+      unsubscribeNativeServiceHostReady = ctx.bridge.onServiceHostReady(onNativeServiceHostReady);
       followNativeDevtoolsServiceHost();
     }
   }
@@ -3824,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";
@@ -4020,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 {
@@ -4068,8 +4724,8 @@ function createHostToolbarView(ctx, reconciler, deps) {
     hide() {
       hideHostToolbar();
     },
-    setPreloadPath(path25) {
-      hostToolbarPreloadOverride = path25;
+    setPreloadPath(path26) {
+      hostToolbarPreloadOverride = path26;
     },
     setHeightMode(mode) {
       if (mode !== "auto" && !(Number.isFinite(mode.fixed) && mode.fixed >= 0)) {
@@ -4122,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
@@ -4190,7 +4846,7 @@ function createOverlayPanelsView(ctx, reconciler, deps) {
   }
   async function showSettings() {
     if (!settingsView) {
-      settingsView = new WebContentsView5({
+      settingsView = new WebContentsView6({
         webPreferences: {
           nodeIntegration: false,
           contextIsolation: true,
@@ -4212,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,
@@ -4279,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) {
@@ -4608,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,
@@ -4847,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,
@@ -5535,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 {
     }
@@ -5867,7 +6527,7 @@ async function materializeTemplate(target, template, name) {
       `Template source missing on disk: ${template.source.path}`
     );
   }
-  fs7.cpSync(template.source.path, target, {
+  await fs7.promises.cp(template.source.path, target, {
     recursive: true,
     force: true
   });
@@ -6134,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";
 
@@ -6292,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;
@@ -6301,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,
@@ -6382,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 = [
@@ -6579,7 +7246,7 @@ var ServiceHostPool = class {
     }
   }
   createWindow(spec) {
-    return new BrowserWindow5({
+    return new BrowserWindow6({
       show: false,
       width: spec.size?.width,
       height: spec.size?.height,
@@ -6687,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}`;
@@ -6708,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();
@@ -6716,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()) {
@@ -6738,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);
@@ -6759,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);
@@ -6767,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);
@@ -6789,6 +7482,7 @@ function createConsoleForwarder(bridge, diagnostics) {
     },
     dispose() {
       sinks.clear();
+      buffer.length = 0;
       pendingBySession.clear();
       pendingGlobal.length = 0;
       readySessions.clear();
@@ -7462,6 +8156,9 @@ function installBridgeRouter(ctx) {
     pool: null,
     emitRenderEvent: () => {
     },
+    emitServiceHostReady: () => {
+    },
+    lastServiceHostReady: null,
     connections: ctx.connections,
     debugTap: createDebugTap({ enabled: resolveDebugTapEnabled() }),
     appLifecycle: createAppLifecycleController(),
@@ -7509,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) => {
@@ -7534,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;
@@ -7544,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;
@@ -8073,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);
@@ -10250,7 +10981,6 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
   });
   connectTarget("workbench").catch(() => {
   });
-  const server = buildServer();
   const transports = /* @__PURE__ */ new Map();
   const httpServer = createServer(async (req, res) => {
     const url = new URL(req.url ?? "/", `http://localhost`);
@@ -10258,7 +10988,14 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
       const transport = new SSEServerTransport("/message", res);
       transports.set(transport.sessionId, transport);
       res.on("close", () => transports.delete(transport.sessionId));
-      await server.connect(transport);
+      try {
+        await buildServer().connect(transport);
+      } catch (err2) {
+        transports.delete(transport.sessionId);
+        if (!res.headersSent) res.writeHead(500).end("MCP connect failed");
+        else res.end();
+        console.error("[MCP] SSE connect failed:", err2);
+      }
     } else if (req.method === "POST" && url.pathname === "/message") {
       const sessionId = url.searchParams.get("sessionId") ?? "";
       const transport = transports.get(sessionId);
@@ -10607,13 +11344,13 @@ function createRenderInspector(options = {}) {
 import { toDisposable as toDisposable6 } from "@dimina-kit/electron-deck/main";
 
 // src/main/services/simulator-temp-files/store.ts
-function registerTempFile(store, path25, mime, bytes) {
+function registerTempFile(store, path26, mime, bytes) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-  store.delete(path25);
-  store.set(path25, { bytes: buf, mime });
+  store.delete(path26);
+  store.set(path26, { bytes: buf, mime });
 }
-function revokeTempFile(store, path25) {
-  store.delete(path25);
+function revokeTempFile(store, path26) {
+  store.delete(path26);
 }
 function revokeAllTempFiles(store) {
   store.clear();
@@ -11041,10 +11778,10 @@ function setupSimulatorTempFiles(simSession) {
   const store = /* @__PURE__ */ new Map();
   const pendingWaiters = /* @__PURE__ */ new Map();
   let disposed = false;
-  function drainWaiters(path25) {
-    const list = pendingWaiters.get(path25);
+  function drainWaiters(path26) {
+    const list = pendingWaiters.get(path26);
     if (!list) return;
-    pendingWaiters.delete(path25);
+    pendingWaiters.delete(path26);
     for (const fn of list) fn();
   }
   function drainAllWaiters() {
@@ -11057,15 +11794,15 @@ function setupSimulatorTempFiles(simSession) {
   const registry = new IpcRegistry(simulatorOnlyPolicy);
   registry.on("simulator:temp-file:write", (_event, payload) => {
     if (disposed) return;
-    const { path: path25, mime, bytes } = payload;
-    registerTempFile(store, path25, mime, bytes);
+    const { path: path26, mime, bytes } = payload;
+    registerTempFile(store, path26, mime, bytes);
     enforceStoreCap(store);
-    drainWaiters(path25);
+    drainWaiters(path26);
   });
   registry.on("simulator:temp-file:revoke", (_event, payload) => {
     if (disposed) return;
-    const { path: path25 } = payload;
-    revokeTempFile(store, path25);
+    const { path: path26 } = payload;
+    revokeTempFile(store, path26);
   });
   registry.on("simulator:temp-file:revoke-all", () => {
     if (disposed) return;
@@ -11619,8 +12356,9 @@ var UpdateManager = class {
       const currentVersion = this.getCurrentVersion();
       const info = await this.checker.checkForUpdates(currentVersion);
       if (info) {
+        const isSameUpdate = this.latestUpdate?.version === info.version && this.latestUpdate?.downloadUrl === info.downloadUrl;
         this.latestUpdate = info;
-        this.downloadedPath = null;
+        if (!isSameUpdate) this.downloadedPath = null;
         return { hasUpdate: true, info };
       }
       return { hasUpdate: false };
@@ -11644,11 +12382,17 @@ var UpdateManager = class {
       return { success: false, error: String(err2) };
     }
   }
-  install() {
-    if (this.downloadedPath) {
-      shell3.openPath(this.downloadedPath);
-      app13.quit();
+  async install() {
+    if (!this.downloadedPath) {
+      return { success: false, error: "No update downloaded" };
     }
+    const failure = await shell3.openPath(this.downloadedPath);
+    if (failure) {
+      console.warn("[UpdateManager] install failed:", failure);
+      return { success: false, error: failure };
+    }
+    app13.quit();
+    return { success: true };
   }
   /**
    * Tear down timers + IPC handlers. Returns a Promise so callers that need
@@ -11681,7 +12425,249 @@ var UpdateManager = class {
 };
 
 // src/main/services/update/github-release-checker.ts
+import fs12 from "fs";
+import path24 from "path";
+import https from "https";
 import { app as app14 } from "electron";
+function createGitHubReleaseChecker(opts) {
+  const releaseUrl = opts.includePrereleases ? `https://api.github.com/repos/${opts.owner}/${opts.repo}/releases` : `https://api.github.com/repos/${opts.owner}/${opts.repo}/releases/latest`;
+  const parseVersion = opts.parseVersion ?? schemeParser(opts.versionScheme ?? "semver");
+  return {
+    async checkForUpdates(currentVersion) {
+      const release = await fetchRelease(releaseUrl, opts);
+      if (!release) return null;
+      const latestVersion = parseVersion(release);
+      if (!latestVersion) return null;
+      if (compareSemver(latestVersion, stripV(currentVersion)) <= 0) return null;
+      const asset = (opts.pickAsset ?? defaultPickAsset)(release.assets, {
+        platform: process.platform,
+        arch: process.arch
+      });
+      if (!asset) return null;
+      return {
+        version: latestVersion,
+        downloadUrl: asset.browser_download_url,
+        releaseNotes: release.body,
+        mandatory: opts.mandatory
+      };
+    },
+    async downloadUpdate(info, onProgress) {
+      const tmpDir = path24.join(app14.getPath("temp"), `${opts.repo}-update`);
+      if (!fs12.existsSync(tmpDir)) fs12.mkdirSync(tmpDir, { recursive: true });
+      const fileName = path24.basename(new URL(info.downloadUrl).pathname);
+      const filePath = path24.join(tmpDir, fileName);
+      await downloadFile(info.downloadUrl, filePath, opts.token, onProgress);
+      return filePath;
+    }
+  };
+}
+function defaultPickAsset(assets, ctx) {
+  const candidates = platformMatchers(ctx.platform, ctx.arch);
+  for (const match of candidates) {
+    const hit = assets.find((a) => match(a.name));
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function platformMatchers(platform, arch) {
+  const lc = (s) => s.toLowerCase();
+  const archTags = archAliases(arch);
+  const hasArch = (name) => archTags.some((tag) => lc(name).includes(tag));
+  const endsWith = (name, ext) => lc(name).endsWith(ext);
+  switch (platform) {
+    case "darwin":
+      return [
+        (n) => endsWith(n, ".dmg") && hasArch(n),
+        (n) => endsWith(n, ".dmg"),
+        // mac builds are often universal / unarch-tagged
+        (n) => endsWith(n, ".zip") && (lc(n).includes("mac") || lc(n).includes("darwin"))
+      ];
+    case "win32":
+      return [
+        (n) => endsWith(n, ".exe") && hasArch(n),
+        (n) => endsWith(n, ".zip") && (lc(n).includes("win") || lc(n).includes("windows")) && hasArch(n),
+        (n) => endsWith(n, ".exe"),
+        (n) => endsWith(n, ".zip") && (lc(n).includes("win") || lc(n).includes("windows"))
+      ];
+    case "linux":
+      return [
+        (n) => endsWith(n, ".appimage") && hasArch(n),
+        (n) => endsWith(n, ".tar.gz") && lc(n).includes("linux") && hasArch(n),
+        (n) => endsWith(n, ".appimage"),
+        (n) => endsWith(n, ".tar.gz") && lc(n).includes("linux"),
+        (n) => endsWith(n, ".deb") && hasArch(n)
+      ];
+    default:
+      return [];
+  }
+}
+function archAliases(arch) {
+  switch (arch) {
+    case "x64":
+      return ["x64", "x86_64", "amd64"];
+    case "arm64":
+      return ["arm64", "aarch64"];
+    case "ia32":
+      return ["ia32", "x86", "i386"];
+    default:
+      return [arch];
+  }
+}
+var SEMVER_RE = /(\d+)\.(\d+)\.(\d+)(?:[-+]([0-9A-Za-z.-]+))?/;
+var TRAILING_NUMBER_RE = /-(\d+)$/;
+function schemeParser(scheme) {
+  if (scheme === "trailing-number") {
+    return (release) => {
+      const m = release.tag_name.match(TRAILING_NUMBER_RE);
+      return m ? m[1] : null;
+    };
+  }
+  return defaultParseVersion;
+}
+function defaultParseVersion(release) {
+  const fromTag = extractSemver(release.tag_name);
+  if (fromTag) return fromTag;
+  if (release.name) {
+    const fromName = extractSemver(release.name);
+    if (fromName) return fromName;
+  }
+  for (const asset of release.assets) {
+    const hit = extractSemver(asset.name);
+    if (hit) return hit;
+  }
+  return null;
+}
+function extractSemver(input) {
+  const m = input.match(SEMVER_RE);
+  if (!m) return null;
+  const [, major, minor, patch, pre] = m;
+  return pre ? `${major}.${minor}.${patch}-${pre}` : `${major}.${minor}.${patch}`;
+}
+function stripV(version) {
+  return version.replace(/^v/i, "");
+}
+function compareSemver(a, b) {
+  const [aCore, aPre] = splitPre(a);
+  const [bCore, bPre] = splitPre(b);
+  const [a1, a2, a3] = parseCore(aCore);
+  const [b1, b2, b3] = parseCore(bCore);
+  if (a1 !== b1) return a1 - b1;
+  if (a2 !== b2) return a2 - b2;
+  if (a3 !== b3) return a3 - b3;
+  if (!aPre && bPre) return 1;
+  if (aPre && !bPre) return -1;
+  if (!aPre && !bPre) return 0;
+  return aPre.localeCompare(bPre);
+}
+function splitPre(v) {
+  const i = v.indexOf("-");
+  return i < 0 ? [v, null] : [v.slice(0, i), v.slice(i + 1)];
+}
+function parseCore(core) {
+  const parts = core.split(".").map((s) => parseInt(s, 10) || 0);
+  return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+function ghHeaders(token) {
+  const headers = {
+    "User-Agent": "dimina-kit-updater",
+    "Accept": "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return headers;
+}
+async function fetchRelease(url, opts) {
+  const body = await httpGetText(url, { headers: ghHeaders(opts.token) });
+  if (!body) return null;
+  if (opts.includePrereleases) {
+    const list = JSON.parse(body);
+    const first = list.find((r) => !r.draft);
+    return first ?? null;
+  }
+  const release = JSON.parse(body);
+  return release.draft ? null : release;
+}
+function httpGetText(url, init) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { headers: init.headers }, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        resolve(httpGetText(res.headers.location, init));
+        return;
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        resolve(null);
+        return;
+      }
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => resolve(body));
+    });
+    req.on("error", reject);
+  });
+}
+function downloadFile(url, dest, token, onProgress) {
+  return new Promise((resolve, reject) => {
+    const headers = ghHeaders(token);
+    const cleanup = () => fs12.promises.unlink(dest).catch(() => {
+    });
+    const attempt = (target, redirectsLeft) => {
+      const req = https.get(target, { headers }, (res) => {
+        if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          res.resume();
+          if (redirectsLeft <= 0) {
+            reject(new Error("Too many redirects"));
+            return;
+          }
+          attempt(res.headers.location, redirectsLeft - 1);
+          return;
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          reject(new Error(`HTTP ${res.statusCode} while downloading update`));
+          return;
+        }
+        const total = parseInt(res.headers["content-length"] || "0", 10);
+        let received = 0;
+        const out = fs12.createWriteStream(dest);
+        res.on("data", (chunk) => {
+          received += chunk.length;
+          if (total > 0 && onProgress) {
+            onProgress(received / total * 100);
+          }
+        });
+        res.on("error", async (err2) => {
+          out.destroy();
+          await cleanup();
+          reject(err2);
+        });
+        res.pipe(out);
+        out.on("finish", async () => {
+          out.close();
+          if (total > 0 && received !== total) {
+            await cleanup();
+            reject(new Error(`Downloaded ${received} bytes, expected ${total} \u2014 update download was truncated`));
+            return;
+          }
+          resolve();
+        });
+        out.on("error", async (err2) => {
+          await cleanup();
+          reject(err2);
+        });
+      });
+      req.on("error", async (err2) => {
+        await cleanup();
+        reject(err2);
+      });
+    };
+    attempt(url, 5);
+  });
+}
 
 // src/main/app/app.ts
 import { toDisposable as toDisposable8 } from "@dimina-kit/electron-deck/main";
@@ -11752,7 +12738,7 @@ async function disposeContext(ctx) {
 function createConfiguredMainWindow(config, rendererDir2) {
   const mainWindow = createMainWindow({
     title: config.appName ?? "Dimina DevTools",
-    indexHtml: path24.join(rendererDir2, "entries/main/index.html"),
+    indexHtml: path25.join(rendererDir2, "entries/main/index.html"),
     width: config.window?.width,
     height: config.window?.height,
     minWidth: config.window?.minWidth,
@@ -11865,10 +12851,10 @@ function enableDevRendererAutoReload(rendererDir2) {
     });
   }
   let reloadTimer = null;
-  const watcher = fs12.watch(rendererDir2, { recursive: true }, () => {
+  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);
@@ -11895,7 +12881,7 @@ function runDevtoolsBootstrap(config = {}) {
   } catch {
   }
 }
-async function createDevtoolsRuntime(config = {}) {
+async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
   await app15.whenReady();
   applyTheme(loadWorkbenchSettings().theme);
   const rendererDir2 = config.rendererDir ?? rendererDir;
@@ -11904,10 +12890,33 @@ async function createDevtoolsRuntime(config = {}) {
   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);
@@ -11924,6 +12933,7 @@ async function createDevtoolsRuntime(config = {}) {
     registerSimulatorApi: (name, handler) => context.registry.add(toDisposable8(context.simulatorApis.register(name, handler))),
     dispose: () => disposeContext(context)
   };
+  onInstanceCreated?.(instance);
   instance.registerSimulatorApi("login", async () => {
     return "hello";
   });
@@ -12006,6 +13016,17 @@ async function createDevtoolsRuntime(config = {}) {
   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
     });
@@ -12014,6 +13035,12 @@ async function createDevtoolsRuntime(config = {}) {
     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,
@@ -12036,8 +13063,8 @@ async function createDevtoolsRuntime(config = {}) {
       bridge: context.bridge
     }));
   }
-  const bundleDir = config.editorViewConfig?.bundleDir ?? path24.join(devtoolsPackageRoot, "dist/vscode-workbench");
-  if (!fs12.existsSync(path24.join(bundleDir, "index.html"))) {
+  const bundleDir = config.editorViewConfig?.bundleDir ?? path25.join(devtoolsPackageRoot, "dist/vscode-workbench");
+  if (!fs13.existsSync(path25.join(bundleDir, "index.html"))) {
     console.warn(
       `[workbench] editor bundle not found at ${bundleDir} \u2014 skipping embedded editor assembly`
     );
@@ -12074,6 +13101,7 @@ async function createDevtoolsRuntime(config = {}) {
 // src/main/runtime/devtools-backend.ts
 function createDevtoolsBackend(config = {}) {
   let instance = null;
+  let assembling = null;
   return {
     // The backend builds the devtools main window itself (framework skips its own).
     // Its only construction-time needs are the host preload + `sandbox:false`
@@ -12095,15 +13123,33 @@ function createDevtoolsBackend(config = {}) {
     // Setup (post-whenReady): app lifecycle (window-all-closed → quit) + the
     // full devtools assembly.
     assemble: async () => {
-      registerAppLifecycle();
-      instance = await createDevtoolsRuntime(config);
+      registerAppLifecycle(() => instance?.context.views.disposeAll());
+      assembling = createDevtoolsRuntime(config, (created) => {
+        instance = created;
+        if (isAppQuitting()) instance.context.views.disposeAll();
+      }).then(() => {
+      });
+      await assembling;
     },
     // Dispose the devtools context during the framework's deterministic shutdown
     // (app.on('will-quit') → shutdown() → runShutdownCleanup(), awaited once).
     // Without this, the compile session (a child process, torn down by
     // closeProject) and the IPC registry would leak on exit. The framework awaits
     // this hook, so teardown is no longer a best-effort before-quit reach-around.
-    onShutdown: () => instance?.dispose()
+    //
+    // Waits for `assembling` first: `instance` can be non-null (published
+    // early, above) while `createDevtoolsRuntime`'s own async body — the
+    // host's `onSetup` and everything scheduled after it — is still running
+    // and still adding entries to `instance.context.registry`. Disposing
+    // that registry out from under an in-flight assembly throws instead of
+    // tearing down cleanly (`DisposableRegistry.add` rejects post-dispose).
+    // `.catch()` here: assembly failing is `assemble`'s problem to surface,
+    // not a reason to skip disposing whatever DID get constructed.
+    onShutdown: async () => {
+      await assembling?.catch(() => {
+      });
+      await instance?.dispose();
+    }
   };
 }
 
@@ -12113,7 +13159,18 @@ function launch(config = {}) {
 }
 
 // src/main/index.ts
-launch().catch((err2) => {
+var updateChecker = app16.isPackaged && !app16.getVersion().includes("-dev.") ? createGitHubReleaseChecker({
+  owner: "EchoTechFE",
+  repo: "dimina-kit",
+  parseVersion: (release) => {
+    for (const asset of release.assets) {
+      const match = /^dimina-devtools-(\d+\.\d+\.\d+)-/.exec(asset.name);
+      if (match) return match[1];
+    }
+    return null;
+  }
+}) : void 0;
+launch({ updateChecker }).catch((err2) => {
   console.error("[devtools] fatal: launch() failed during boot", err2);
   app16.exit(1);
 });