@dimina-kit/devtools 0.4.0-dev.20260701155140 → 0.4.0-dev.20260702164903

package/dist/main/index.bundle.js

@@ -130,7 +130,7 @@ function describeMaxListenersWarning(warning) {
     stack: warning.stack
   };
 }
-function installMaxListenersWarningDiagnostic(log3 = (r) => console.warn("[max-listeners]", r)) {
+function installMaxListenersWarningDiagnostic(log3 = (r) => console.warn("[max-listeners]", JSON.stringify(r))) {
   const onWarning = (warning) => {
     const report = describeMaxListenersWarning(warning);
     if (report) log3(report);
@@ -345,6 +345,12 @@ var SimulatorChannel = {
   // window — the authoritative `wx.getSystemInfoSync()` source — so the
   // mini-app sees the selected device without a relaunch.
   SetDeviceInfo: "simulator:set-device-info",
+  // Ask main to soft-reload the LIVE simulator WCV after a watcher rebuild:
+  // main forwards a SIMULATOR_EVENTS.RELAUNCH into the shell (which boots a
+  // new app session and swaps when ready) instead of destroying the view.
+  // Resolves false when there is no live+ready shell — the renderer then falls
+  // back to the hard AttachNative rebuild.
+  SoftReload: "simulator:soft-reload",
   Detach: "simulator:detach",
   Console: "simulator:console",
   // Main → renderer push of the visible top-of-stack page route whenever the
@@ -847,7 +853,7 @@ 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 path22 from "path";
+import path23 from "path";
 
 // src/main/utils/paths.ts
 import fs3 from "fs";
@@ -1134,10 +1140,341 @@ function createRendererNotifier(ctx) {
   };
 }
 
-// src/main/services/views/view-manager.ts
-import { ipcMain as ipcMain2, nativeTheme as nativeTheme3, shell as shell2, WebContentsView as WebContentsView2, webContents } from "electron";
-import fs4 from "node:fs";
-import path7 from "path";
+// src/main/services/safe-area/index.ts
+function guestInsets(device, isTabPage2) {
+  const top = device?.safeAreaInsets.top ?? 0;
+  const bottom = isTabPage2 ? 0 : device?.safeAreaInsets.bottom ?? 0;
+  return { top, topMax: top, right: 0, rightMax: 0, bottom, bottomMax: bottom, left: 0, leftMax: 0 };
+}
+function createSafeAreaController(options = {}) {
+  const attached = /* @__PURE__ */ new Map();
+  function override(wc, device, isTabPage2) {
+    if (wc.isDestroyed()) return;
+    void wc.debugger.sendCommand("Emulation.setSafeAreaInsetsOverride", { insets: guestInsets(device, isTabPage2) }).catch((err) => {
+      console.warn("[safe-area] setSafeAreaInsetsOverride failed:", err instanceof Error ? err.message : err);
+    });
+  }
+  return {
+    applyToGuest: (wc, device, isTabPage2) => {
+      if (!wc || wc.isDestroyed() || attached.has(wc)) {
+        if (wc && !wc.isDestroyed() && attached.has(wc)) override(wc, device, isTabPage2);
+        return;
+      }
+      try {
+        wc.debugger.attach("1.3");
+      } catch (err) {
+        console.warn("[safe-area] debugger.attach failed; env(safe-area-inset-*) stays 0:", err instanceof Error ? err.message : err);
+        return;
+      }
+      attached.set(wc, isTabPage2);
+      if (options.connections) {
+        options.connections.acquire(wc).own(() => attached.delete(wc));
+      } else {
+        wc.once("destroyed", () => attached.delete(wc));
+      }
+      override(wc, device, isTabPage2);
+    },
+    reapplyAll: (device) => {
+      for (const [wc, isTabPage2] of attached) override(wc, device, isTabPage2);
+    },
+    dispose: () => {
+      for (const wc of attached.keys()) {
+        try {
+          if (!wc.isDestroyed()) wc.debugger.detach();
+        } catch {
+        }
+      }
+      attached.clear();
+    }
+  };
+}
+
+// src/main/services/views/placement-reconciler.ts
+import { reconcile, createInitialState } from "@dimina-kit/electron-deck/layout";
+
+// src/main/services/views/apply-view-ops.ts
+function applyViewOps(ops, target) {
+  for (const op of ops) {
+    switch (op.kind) {
+      case "detach":
+        target.detach(op.viewId);
+        break;
+      case "setVisible":
+        target.setVisible(op.viewId, op.visible);
+        break;
+      case "setBounds":
+        target.setBounds(op.viewId, op.bounds, op.extra);
+        break;
+      case "attach":
+        target.attach(op.viewId);
+        break;
+      case "reorder":
+        target.reorder(op.order);
+        break;
+    }
+  }
+}
+
+// src/main/services/views/placement-reconciler.ts
+function createPlacementReconciler(ctx) {
+  let placementState = createInitialState();
+  let epochCounter = 0;
+  let rendererGeneration = 0;
+  const baseDesired = /* @__PURE__ */ new Map();
+  const overlayDesired = /* @__PURE__ */ new Map();
+  const slots = /* @__PURE__ */ new Map();
+  function gateReadiness(v) {
+    const slot = slots.get(v.viewId);
+    if (slot?.gateHidden?.()) return { ...v, placement: { visible: false } };
+    return v;
+  }
+  const viewTarget = {
+    attach(viewId) {
+      if (ctx.windows.mainWindow.isDestroyed()) return;
+      const slot = slots.get(viewId);
+      if (!slot) return;
+      if (slot.beforeAttach?.()) return;
+      const view = slot.ensureView ? slot.ensureView() : slot.getView();
+      if (!view) return;
+      ctx.windows.mainWindow.contentView.addChildView(view);
+      slot.setAdded?.(true);
+    },
+    detach(viewId) {
+      const slot = slots.get(viewId);
+      const view = slot?.getView() ?? null;
+      if (view && !ctx.windows.mainWindow.isDestroyed()) {
+        try {
+          ctx.windows.mainWindow.contentView.removeChildView(view);
+        } catch {
+        }
+      }
+      slot?.setAdded?.(false);
+    },
+    setBounds(viewId, bounds, extra) {
+      const slot = slots.get(viewId);
+      const view = slot?.getView() ?? null;
+      if (!view || view.webContents.isDestroyed()) return;
+      if (slot?.applyBounds) {
+        slot.applyBounds(view, bounds, extra);
+        return;
+      }
+      view.setBounds(bounds);
+    },
+    setVisible(viewId, visible) {
+      const view = slots.get(viewId)?.getView() ?? null;
+      if (!view) return;
+      try {
+        view.setVisible(visible);
+      } catch {
+      }
+    },
+    reorder(order) {
+      if (order.length <= 1 || ctx.windows.mainWindow.isDestroyed()) return;
+      const cv = ctx.windows.mainWindow.contentView;
+      for (const viewId of order) {
+        const view = slots.get(viewId)?.getView() ?? null;
+        if (view) {
+          try {
+            cv.addChildView(view);
+          } catch {
+          }
+        }
+      }
+    }
+  };
+  function ensureLazyViews() {
+    for (const [viewId, slot] of slots) {
+      slot.ensureLazy?.(baseDesired.get(viewId));
+    }
+  }
+  function reconcileNow() {
+    ensureLazyViews();
+    const views = [];
+    for (const v of baseDesired.values()) views.push(gateReadiness(v));
+    for (const v of overlayDesired.values()) views.push(v);
+    const result = reconcile(placementState, {
+      generation: rendererGeneration,
+      epoch: ++epochCounter,
+      views
+    });
+    placementState = result.state;
+    applyViewOps(result.ops, viewTarget);
+  }
+  function setPlacementSnapshot(snapshot) {
+    rendererGeneration = snapshot.generation;
+    baseDesired.clear();
+    for (const v of snapshot.views) baseDesired.set(v.viewId, v);
+    reconcileNow();
+  }
+  return {
+    registerView: (viewId, slot) => {
+      slots.set(viewId, slot);
+    },
+    reconcileNow,
+    setPlacementSnapshot,
+    forgetActual: (viewId) => {
+      placementState.actual.delete(viewId);
+    },
+    setBaseDesired: (viewId, desired) => {
+      baseDesired.set(viewId, desired);
+    },
+    deleteBaseDesired: (viewId) => {
+      baseDesired.delete(viewId);
+    },
+    setOverlayDesired: (viewId, desired) => {
+      overlayDesired.set(viewId, desired);
+    },
+    deleteOverlayDesired: (viewId) => {
+      overlayDesired.delete(viewId);
+    },
+    hasOverlayDesired: (viewId) => overlayDesired.has(viewId)
+  };
+}
+
+// src/main/services/views/workbench-view.ts
+import { nativeTheme as nativeTheme3, WebContentsView as WebContentsView2 } from "electron";
+
+// src/shared/view-ids.ts
+var VIEW_ID = {
+  simulator: "simulator",
+  simulatorDevtools: "simulator-devtools",
+  workbench: "workbench",
+  hostToolbar: "host-toolbar",
+  settings: "settings",
+  popover: "popover"
+};
+var VIEW_LAYER = {
+  base: 0,
+  hostToolbar: 5,
+  settings: 10,
+  popover: 20
+};
+
+// src/main/services/views/destroy-child-view.ts
+function destroyChildView(mainWindow, view) {
+  if (!view) return;
+  if (!mainWindow.isDestroyed()) {
+    try {
+      mainWindow.contentView.removeChildView(view);
+    } catch {
+    }
+  }
+  try {
+    if (!view.webContents.isDestroyed()) {
+      view.webContents.close();
+    }
+  } catch {
+  }
+}
+
+// src/main/services/views/workbench-view.ts
+function createWorkbenchView(ctx, reconciler) {
+  let workbenchView = null;
+  let workbenchThemeSyncBound = false;
+  let workbenchUrl = null;
+  function workbenchThemeScheme() {
+    return nativeTheme3.shouldUseDarkColors ? "dark" : "light";
+  }
+  function pushWorkbenchTheme() {
+    if (!workbenchView || workbenchView.webContents.isDestroyed()) return;
+    const wc = workbenchView.webContents;
+    if (typeof wc.executeJavaScript !== "function") return;
+    const script = `window.__WB_SET_THEME && window.__WB_SET_THEME(${JSON.stringify(workbenchThemeScheme())})`;
+    wc.executeJavaScript(script, true).catch(() => {
+    });
+  }
+  async function attachWorkbench(url) {
+    if (workbenchView) return;
+    const view = new WebContentsView2({
+      webPreferences: {
+        nodeIntegration: false,
+        contextIsolation: true,
+        sandbox: false
+      }
+    });
+    workbenchView = view;
+    if (!workbenchThemeSyncBound) {
+      nativeTheme3.on("updated", pushWorkbenchTheme);
+      workbenchThemeSyncBound = true;
+    }
+    try {
+      view.webContents.setWindowOpenHandler(({ url: target }) => handleWindowOpenExternal(target));
+    } catch {
+    }
+    ctx.windows.mainWindow.contentView.addChildView(view);
+    const loadUrl = `${url}index.html?theme=${workbenchThemeScheme()}`;
+    await view.webContents.loadURL(loadUrl).catch((err) => {
+      console.error("[workbench] attachWorkbench \u2014 loadURL failed", err);
+    });
+  }
+  function setWorkbenchSource(url) {
+    workbenchUrl = url;
+  }
+  function detachWorkbench() {
+    if (workbenchThemeSyncBound) {
+      nativeTheme3.removeListener("updated", pushWorkbenchTheme);
+      workbenchThemeSyncBound = false;
+    }
+    destroyChildView(ctx.windows.mainWindow, workbenchView);
+    workbenchView = null;
+    reconciler.deleteBaseDesired(VIEW_ID.workbench);
+    reconciler.reconcileNow();
+  }
+  function workspaceUriFor(rel) {
+    const encoded = rel.split("/").map(encodeURIComponent).join("/");
+    return `file:///workspace/${encoded}`;
+  }
+  function tryRevealInWorkbench(uri, zeroLine, zeroCol) {
+    if (!workbenchView || workbenchView.webContents.isDestroyed()) {
+      return Promise.resolve(false);
+    }
+    const script = `(async () => {
+      try {
+        const P = window.__WB_PROBE; if (!P) return false
+        const vscode = P.vscode
+        const uri = vscode.Uri.parse(${JSON.stringify(uri)})
+        const doc = await vscode.workspace.openTextDocument(uri)
+        const pos = new vscode.Position(${zeroLine}, ${zeroCol})
+        await vscode.window.showTextDocument(doc, { selection: new vscode.Range(pos, pos) })
+        return true
+      } catch (e) { return false }
+    })()`;
+    return workbenchView.webContents.executeJavaScript(script, true).then((ok) => ok === true).catch(() => false);
+  }
+  function openFileInWorkbench(relPath, line, column) {
+    if (!workbenchView || workbenchView.webContents.isDestroyed()) return false;
+    const uri = workspaceUriFor(relPath.replace(/^\/+/, ""));
+    const zeroLine = Math.max(0, Math.floor(line) - 1);
+    const zeroCol = Math.max(0, Math.floor(column) - 1);
+    void (async () => {
+      for (let attempt = 0; attempt < 10; attempt++) {
+        if (!workbenchView || workbenchView.webContents.isDestroyed()) return;
+        if (await tryRevealInWorkbench(uri, zeroLine, zeroCol)) return;
+        await new Promise((resolve) => setTimeout(resolve, 150));
+      }
+      console.error("[workbench] openFileInWorkbench: workbench never became ready for", uri);
+    })();
+    return true;
+  }
+  reconciler.registerView(VIEW_ID.workbench, {
+    getView: () => workbenchView,
+    gateHidden: () => !workbenchView && !workbenchUrl,
+    beforeAttach: () => {
+      if (!workbenchView && workbenchUrl) {
+        void attachWorkbench(workbenchUrl);
+        return true;
+      }
+      return false;
+    },
+    ensureLazy: (desired) => {
+      if (desired?.placement.visible && !workbenchView && workbenchUrl) void attachWorkbench(workbenchUrl);
+    }
+  });
+  return { attachWorkbench, setWorkbenchSource, detachWorkbench, openFileInWorkbench };
+}
+
+// src/main/services/views/native-simulator-devtools-host.ts
+import { WebContentsView as WebContentsView3 } from "electron";
 
 // src/shared/open-in-editor.ts
 var OPEN_IN_EDITOR_SCHEME = "dimina-open-in-editor";
@@ -1508,56 +1845,7 @@ function buildDevtoolsProjectSourceLinksScript(context) {
         }, 50)
       } catch (_) {}
     })()
-  `;
-}
-
-// src/main/services/safe-area/index.ts
-function guestInsets(device, isTabPage2) {
-  const top = device?.safeAreaInsets.top ?? 0;
-  const bottom = isTabPage2 ? 0 : device?.safeAreaInsets.bottom ?? 0;
-  return { top, topMax: top, right: 0, rightMax: 0, bottom, bottomMax: bottom, left: 0, leftMax: 0 };
-}
-function createSafeAreaController(options = {}) {
-  const attached = /* @__PURE__ */ new Map();
-  function override(wc, device, isTabPage2) {
-    if (wc.isDestroyed()) return;
-    void wc.debugger.sendCommand("Emulation.setSafeAreaInsetsOverride", { insets: guestInsets(device, isTabPage2) }).catch((err) => {
-      console.warn("[safe-area] setSafeAreaInsetsOverride failed:", err instanceof Error ? err.message : err);
-    });
-  }
-  return {
-    applyToGuest: (wc, device, isTabPage2) => {
-      if (!wc || wc.isDestroyed() || attached.has(wc)) {
-        if (wc && !wc.isDestroyed() && attached.has(wc)) override(wc, device, isTabPage2);
-        return;
-      }
-      try {
-        wc.debugger.attach("1.3");
-      } catch (err) {
-        console.warn("[safe-area] debugger.attach failed; env(safe-area-inset-*) stays 0:", err instanceof Error ? err.message : err);
-        return;
-      }
-      attached.set(wc, isTabPage2);
-      if (options.connections) {
-        options.connections.acquire(wc).own(() => attached.delete(wc));
-      } else {
-        wc.once("destroyed", () => attached.delete(wc));
-      }
-      override(wc, device, isTabPage2);
-    },
-    reapplyAll: (device) => {
-      for (const [wc, isTabPage2] of attached) override(wc, device, isTabPage2);
-    },
-    dispose: () => {
-      for (const wc of attached.keys()) {
-        try {
-          if (!wc.isDestroyed()) wc.debugger.detach();
-        } catch {
-        }
-      }
-      attached.clear();
-    }
-  };
+  `;
 }
 
 // src/main/services/views/devtools-tabs.ts
@@ -1629,6 +1917,44 @@ function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
 
 // src/main/services/elements-forward/index.ts
 import { webContents as electronWebContents } from "electron";
+
+// 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/elements-forward/index.ts
 var RENDER_DOMAIN_PREFIXES = [
   "DOM.",
   "CSS.",
@@ -1745,6 +2071,7 @@ function installElementsForward(deps) {
   }
   function dispatchToFrontend(message) {
     if (disposed || devtoolsWc.isDestroyed()) return;
+    if (!isFrontendSettled(devtoolsWc)) return;
     let json;
     try {
       json = JSON.stringify(message);
@@ -1777,6 +2104,7 @@ function installElementsForward(deps) {
   }
   function pushDocumentUpdated() {
     if (disposed || devtoolsWc.isDestroyed()) return;
+    if (!isFrontendSettled(devtoolsWc)) return;
     let script;
     try {
       script = buildDocumentUpdatedScript();
@@ -1949,6 +2277,7 @@ function installElementsForward(deps) {
         stop();
         return;
       }
+      if (!isFrontendSettled(devtoolsWc)) return;
       devtoolsWc.executeJavaScript(buildReconcileScript()).then((res) => {
         if (disposed) return;
         const r = res ?? {};
@@ -2058,429 +2387,84 @@ function installServiceConsoleForward(deps) {
       }
     }
   }
-  async function resolveArg(ro) {
-    if (!needsDeepFetch(ro)) return remoteObjectToValue(ro);
-    try {
-      const res = await serviceWc.debugger.sendCommand("Runtime.callFunctionOn", {
-        objectId: ro.objectId,
-        functionDeclaration: "function () { return this }",
-        returnByValue: true
-      });
-      if (res && res.result && "value" in res.result) return res.result.value;
-    } catch {
-    }
-    return remoteObjectToValue(ro);
-  }
-  async function handleConsoleApi(params) {
-    if (disposed) return;
-    if (isRenderForwardEvent(params, RENDER_FORWARD_SOURCE_URL)) return;
-    const level = mapConsoleApiType(params.type);
-    const rawArgs = Array.isArray(params.args) ? params.args : [];
-    let args;
-    try {
-      args = await Promise.all(rawArgs.map((a) => resolveArg(a)));
-    } catch {
-      args = rawArgs.map((a) => remoteObjectToValue(a));
-    }
-    if (disposed) return;
-    emit({ source: "service", level, args, ts: Date.now() });
-  }
-  const onMessage = (_event, method, params) => {
-    if (disposed) return;
-    if (method !== "Runtime.consoleAPICalled") return;
-    const p = params;
-    tail = tail.then(() => handleConsoleApi(p)).catch(() => {
-    });
-  };
-  function stop() {
-    if (disposed) return;
-    disposed = true;
-    try {
-      closedSub?.dispose();
-    } catch {
-    }
-    try {
-      serviceWc.debugger.removeListener("message", onMessage);
-    } catch {
-    }
-    if (selfAttached) {
-      try {
-        if (!serviceWc.isDestroyed() && serviceWc.debugger.isAttached()) serviceWc.debugger.detach();
-      } catch {
-      }
-      selfAttached = false;
-    }
-  }
-  if (!usableDebugger()) {
-    disposed = true;
-    return { stop() {
-    } };
-  }
-  try {
-    serviceWc.debugger.on("message", onMessage);
-  } catch {
-    stop();
-    return { stop() {
-    } };
-  }
-  serviceWc.debugger.sendCommand("Runtime.enable").catch(() => {
-  });
-  try {
-    if (connections) closedSub = connections.acquire(serviceWc).on("closed", stop);
-    else serviceWc.once("destroyed", stop);
-  } catch {
-  }
-  return { stop };
-}
-
-// src/main/services/layout/index.ts
-function computeNativeSimulatorViewParams(rect, zoomPercent) {
-  const zoomFactor = zoomPercent / 100;
-  return {
-    bounds: {
-      x: Math.round(rect.x),
-      y: Math.round(rect.y),
-      width: Math.max(0, Math.round(rect.width)),
-      height: Math.max(0, Math.round(rect.height))
-    },
-    zoomFactor
-  };
-}
-function computeSettingsBounds(contentWidth, contentHeight, headerHeight) {
-  return {
-    x: 0,
-    y: headerHeight,
-    width: Math.max(1, contentWidth),
-    height: Math.max(1, contentHeight - headerHeight)
-  };
-}
-function computePopoverBounds(contentWidth, contentHeight, headerHeight) {
-  return {
-    x: 0,
-    y: headerHeight,
-    width: Math.max(1, contentWidth),
-    height: contentHeight - headerHeight
-  };
-}
-
-// src/main/services/simulator/custom-apis.ts
-async function handleCustomApiBridgeRequest(apis, req) {
-  try {
-    const result = req.op === "list" ? apis.list() : await apis.invoke(req.name, req.params);
-    return { id: req.id, result };
-  } catch (err) {
-    return { id: req.id, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-function createSimulatorApiRegistry() {
-  const handlers2 = /* @__PURE__ */ new Map();
-  return {
-    register(name, handler) {
-      handlers2.set(name, handler);
-      return () => {
-        if (handlers2.get(name) === handler) handlers2.delete(name);
-      };
-    },
-    list() {
-      return Array.from(handlers2.keys());
-    },
-    has(name) {
-      return handlers2.has(name);
-    },
-    async invoke(name, params) {
-      const handler = handlers2.get(name);
-      if (!handler) throw new Error(`Simulator API "${name}" is not registered`);
-      return await handler(params);
-    },
-    clear() {
-      handlers2.clear();
-    }
-  };
-}
-
-// src/main/services/views/miniapp-partition.ts
-import * as electron from "electron";
-var SHARED_MINIAPP_PARTITION = "persist:simulator";
-var PARTITION_PREFIX = "persist:miniapp-";
-function miniappPartitionKey(appId, projectPath) {
-  const safe = appId.replace(/[^A-Za-z0-9_-]/g, "");
-  const base = safe === appId && safe.length > 0 ? safe : safe.length > 0 ? `${safe}-${djb2(appId).toString(36)}` : djb2(appId).toString(36);
-  if (!projectPath) return base;
-  return `${base}-p${djb2(projectPath).toString(36)}`;
-}
-function miniappPartition(appId, projectPath) {
-  if (!appId) return SHARED_MINIAPP_PARTITION;
-  return `${PARTITION_PREFIX}${miniappPartitionKey(appId, projectPath)}`;
-}
-function djb2(input) {
-  let h = 5381;
-  for (let i = 0; i < input.length; i++) {
-    h = (h << 5) + h + input.charCodeAt(i) >>> 0;
-  }
-  return h;
-}
-var configurators = /* @__PURE__ */ new Set();
-var configuredPartitions = /* @__PURE__ */ new Set();
-function registerMiniappSessionConfigurator(fn) {
-  configurators.add(fn);
-  for (const partition of configuredPartitions) {
-    try {
-      fn(electron.session.fromPartition(partition), partition);
-    } catch (err) {
-      console.warn("[miniapp-partition] configurator failed for", partition, err);
-    }
-  }
-  return () => {
-    configurators.delete(fn);
-  };
-}
-function configureMiniappSession(partition) {
-  const alreadyConfigured = configuredPartitions.has(partition);
-  configuredPartitions.add(partition);
-  if (configurators.size === 0) return null;
-  const sess = electron.session.fromPartition(partition);
-  if (alreadyConfigured) return sess;
-  for (const fn of configurators) {
-    try {
-      fn(sess, partition);
-    } catch (err) {
-      console.warn("[miniapp-partition] configurator failed for", partition, err);
-    }
-  }
-  return sess;
-}
-
-// src/main/services/views/host-toolbar-session-runtime.ts
-import { session as session2 } from "electron";
-var refCount = 0;
-var registrationId = null;
-function acquireHostToolbarSessionRuntime() {
-  if (refCount === 0) {
-    registrationId = session2.defaultSession.registerPreloadScript({
-      type: "frame",
-      filePath: hostToolbarRuntimePreloadPath
-    });
-  }
-  refCount++;
-}
-function releaseHostToolbarSessionRuntime() {
-  if (refCount === 0) return;
-  refCount--;
-  if (refCount === 0 && registrationId !== null) {
-    session2.defaultSession.unregisterPreloadScript(registrationId);
-    registrationId = null;
-  }
-}
-
-// src/main/services/views/host-toolbar-port-channel.ts
-import { MessageChannelMain } from "electron";
-function createHostToolbarPortChannel(opts) {
-  let activePort = null;
-  let activeWc = null;
-  let state = "absent";
-  let generation = 0;
-  const handlers2 = [];
-  const readyHandlers = [];
-  function dispatch(data) {
-    if (typeof data !== "object" || data === null) return;
-    const { channel, payload } = data;
-    if (typeof channel !== "string") return;
-    for (const entry of [...handlers2]) {
-      if (entry.channel === channel) entry.handler(payload);
-    }
-  }
-  function dropActivePort(close, next) {
-    const port = activePort;
-    activePort = null;
-    activeWc = null;
-    if (state !== "disposed") state = next;
-    if (close && port) {
-      try {
-        port.close();
-      } catch {
-      }
-    }
-  }
-  function invokeReadyHandler(handler) {
+  async function resolveArg(ro) {
+    if (!needsDeepFetch(ro)) return remoteObjectToValue(ro);
     try {
-      handler();
-    } catch (err) {
-      console.error("[host-toolbar] onReady handler threw:", err);
+      const res = await serviceWc.debugger.sendCommand("Runtime.callFunctionOn", {
+        objectId: ro.objectId,
+        functionDeclaration: "function () { return this }",
+        returnByValue: true
+      });
+      if (res && res.result && "value" in res.result) return res.result.value;
+    } catch {
     }
+    return remoteObjectToValue(ro);
   }
-  function fireReadyHandlers() {
-    for (const entry of [...readyHandlers]) {
-      if (readyHandlers.includes(entry)) invokeReadyHandler(entry.handler);
+  async function handleConsoleApi(params) {
+    if (disposed) return;
+    if (isRenderForwardEvent(params, RENDER_FORWARD_SOURCE_URL)) return;
+    const level = mapConsoleApiType(params.type);
+    const rawArgs = Array.isArray(params.args) ? params.args : [];
+    let args;
+    try {
+      args = await Promise.all(rawArgs.map((a) => resolveArg(a)));
+    } catch {
+      args = rawArgs.map((a) => remoteObjectToValue(a));
     }
+    if (disposed) return;
+    emit({ source: "service", level, args, ts: Date.now() });
   }
-  function handshake(wc) {
-    if (state === "disposed") return;
-    if (!opts.isCurrent(wc)) return;
-    dropActivePort(true, "awaitingHandshake");
-    const { port1, port2 } = new MessageChannelMain();
-    port1.on("message", (event) => {
-      dispatch(event.data);
-    });
-    port1.on("close", () => {
-      if (activePort === port1) dropActivePort(false, "absent");
+  const onMessage = (_event, method, params) => {
+    if (disposed) return;
+    if (method !== "Runtime.consoleAPICalled") return;
+    const p = params;
+    tail = tail.then(() => handleConsoleApi(p)).catch(() => {
     });
-    wc.postMessage(ViewChannel.HostToolbarPort, null, [port2]);
-    port1.start();
-    activePort = port1;
-    activeWc = wc;
-    state = "ready";
-    generation++;
-    fireReadyHandlers();
-  }
-  return {
-    attach(wc) {
-      wc.on("did-finish-load", () => handshake(wc));
-      wc.on(
-        "did-start-navigation",
-        (details, _url, isInPlace, isMainFramePositional) => {
-          if (activeWc !== wc) return;
-          const isSameDocument = typeof details?.isSameDocument === "boolean" ? details.isSameDocument : isInPlace;
-          const isMainFrame = typeof details?.isMainFrame === "boolean" ? details.isMainFrame : isMainFramePositional;
-          if (isSameDocument || !isMainFrame) return;
-          dropActivePort(true, "awaitingHandshake");
-        }
-      );
-      wc.on("destroyed", () => {
-        if (activeWc === wc) dropActivePort(true, "absent");
-      });
-    },
-    invalidate() {
-      dropActivePort(true, "awaitingHandshake");
-    },
-    onMessage(channel, handler) {
-      if (typeof channel !== "string" || channel === "") {
-        throw new TypeError(
-          "hostToolbar.onMessage: channel must be a non-empty string"
-        );
-      }
-      const entry = { channel, handler };
-      handlers2.push(entry);
-      return {
-        dispose() {
-          const i = handlers2.indexOf(entry);
-          if (i >= 0) handlers2.splice(i, 1);
-        }
-      };
-    },
-    onReady(handler) {
-      if (state === "disposed") {
-        return { dispose() {
-        } };
-      }
-      const entry = { handler };
-      readyHandlers.push(entry);
-      if (state === "ready") {
-        const scheduledGeneration = generation;
-        queueMicrotask(() => {
-          if (state !== "ready" || generation !== scheduledGeneration || !activePort) return;
-          if (!readyHandlers.includes(entry)) return;
-          invokeReadyHandler(entry.handler);
-        });
+  };
+  function stop() {
+    if (disposed) return;
+    disposed = true;
+    try {
+      closedSub?.dispose();
+    } catch {
+    }
+    try {
+      serviceWc.debugger.removeListener("message", onMessage);
+    } catch {
+    }
+    if (selfAttached) {
+      try {
+        if (!serviceWc.isDestroyed() && serviceWc.debugger.isAttached()) serviceWc.debugger.detach();
+      } catch {
       }
-      return {
-        dispose() {
-          const i = readyHandlers.indexOf(entry);
-          if (i >= 0) readyHandlers.splice(i, 1);
-        }
-      };
-    },
-    send(channel, payload) {
-      if (!activePort) return false;
-      activePort.postMessage({ channel, payload });
-      return true;
-    },
-    dispose() {
-      dropActivePort(true, "absent");
-      state = "disposed";
-      handlers2.length = 0;
-      readyHandlers.length = 0;
+      selfAttached = false;
     }
-  };
-}
-
-// src/shared/simulator-route.ts
-function decodePageSpec(value) {
-  const qIdx = value.indexOf("?");
-  if (qIdx < 0) return { pagePath: value, query: {} };
-  const pagePath = value.slice(0, qIdx);
-  const query = {};
-  for (const pair of value.slice(qIdx + 1).split("&")) {
-    if (!pair) continue;
-    const eqIdx = pair.indexOf("=");
-    const k = eqIdx >= 0 ? pair.slice(0, eqIdx) : pair;
-    const v = eqIdx >= 0 ? pair.slice(eqIdx + 1) : "";
-    if (k) query[decodeURIComponent(k)] = decodeURIComponent(v);
   }
-  return { pagePath, query };
-}
-function parseLocationRoute(search) {
-  const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
-  const appId = params.get("appId");
-  const entryRaw = params.get("entry");
-  if (!appId || !entryRaw) return null;
-  const entry = decodePageSpec(entryRaw);
-  const pageRaw = params.get("page");
-  const current = pageRaw && pageRaw !== entryRaw ? decodePageSpec(pageRaw) : entry;
-  return { appId, entry, current };
-}
-function parseRoute(url) {
-  if (!url) return null;
+  if (!usableDebugger()) {
+    disposed = true;
+    return { stop() {
+    } };
+  }
   try {
-    const u = new URL(url);
-    return parseLocationRoute(u.search);
+    serviceWc.debugger.on("message", onMessage);
   } catch {
-    return null;
+    stop();
+    return { stop() {
+    } };
   }
-}
-
-// src/main/services/views/view-manager.ts
-import { reconcile, createInitialState } from "@dimina-kit/electron-deck/layout";
-
-// src/main/services/views/apply-view-ops.ts
-function applyViewOps(ops, target) {
-  for (const op of ops) {
-    switch (op.kind) {
-      case "detach":
-        target.detach(op.viewId);
-        break;
-      case "setVisible":
-        target.setVisible(op.viewId, op.visible);
-        break;
-      case "setBounds":
-        target.setBounds(op.viewId, op.bounds, op.extra);
-        break;
-      case "attach":
-        target.attach(op.viewId);
-        break;
-      case "reorder":
-        target.reorder(op.order);
-        break;
-    }
+  serviceWc.debugger.sendCommand("Runtime.enable").catch(() => {
+  });
+  try {
+    if (connections) closedSub = connections.acquire(serviceWc).on("closed", stop);
+    else serviceWc.once("destroyed", stop);
+  } catch {
   }
+  return { stop };
 }
 
-// src/shared/view-ids.ts
-var VIEW_ID = {
-  simulator: "simulator",
-  simulatorDevtools: "simulator-devtools",
-  workbench: "workbench",
-  hostToolbar: "host-toolbar",
-  settings: "settings",
-  popover: "popover"
-};
-var VIEW_LAYER = {
-  base: 0,
-  hostToolbar: 5,
-  settings: 10,
-  popover: 20
-};
-
-// src/main/services/views/view-manager.ts
+// src/main/services/views/resolve-project-editor-target.ts
+import fs4 from "node:fs";
+import path7 from "path";
 function resolveProjectEditorTarget(serviceHostUrl, activeProjectRoot, req, isFile = (absolutePath) => fs4.statSync(absolutePath).isFile()) {
   const sourceContext = projectSourceContextFromServiceHostUrl(
     serviceHostUrl,
@@ -2503,6 +2487,8 @@ function resolveProjectEditorTarget(serviceHostUrl, activeProjectRoot, req, isFi
     column: typeof req.column === "number" ? req.column + 1 : void 0
   };
 }
+
+// src/main/services/views/native-simulator-devtools-host.ts
 var DEVTOOLS_HOST_EXEC_JS_MAX_LISTENERS = 50;
 function raiseExecuteJavaScriptListenerCeiling(wc) {
   try {
@@ -2512,279 +2498,440 @@ function raiseExecuteJavaScriptListenerCeiling(wc) {
   } catch {
   }
 }
-function createViewManager(ctx) {
-  const safeArea = createSafeAreaController({ connections: ctx.connections });
+function createDevtoolsHost(ctx, reconciler, deps) {
   let simulatorView = null;
   let simulatorViewAdded = false;
-  let nativeSimulatorView = null;
-  let nativeSimulatorViewAdded = false;
-  let nativeSimulatorProjectPath = null;
-  let settleNativeSimulatorReady = null;
-  let nativeCustomApiBridgeHandler = null;
-  let currentZoomFactor = 1;
-  let settingsView = null;
-  let popoverView = null;
-  let simulatorWebContentsId = null;
   let nativeDevtoolsSourceWc = null;
-  let unsubscribeNativeRenderEvents = null;
-  let stopElementsForward = null;
-  let stopServiceConsole = null;
-  let nativeDevtoolsRetryTimer = null;
-  let nativeDevtoolsRetryToken = 0;
-  let workbenchView = null;
-  let workbenchThemeSyncBound = false;
-  let workbenchUrl = null;
-  let hostToolbarView = null;
-  let hostToolbarPreloadOverride = null;
-  let hostToolbarViewAdded = false;
-  let hostToolbarRuntimeAcquired = false;
-  let hostToolbarHeightMode = "auto";
-  let hostToolbarLastHeight = 0;
-  const hostToolbarPort = createHostToolbarPortChannel({
-    isCurrent: (wc) => liveHostToolbarWebContents() === wc
-  });
-  function destroyViewInternal(view) {
-    if (!view) return;
-    if (!ctx.windows.mainWindow.isDestroyed()) {
+  let devtoolsHostUsed = false;
+  let unsubscribeNativeRenderEvents = null;
+  let stopElementsForward = null;
+  let stopServiceConsole = null;
+  let nativeDevtoolsRetryTimer = null;
+  let nativeDevtoolsRetryToken = 0;
+  const injectWhenReady = createLoadDeferredInjector();
+  const openInEditorWiredWcIds = /* @__PURE__ */ new Set();
+  function clearNativeDevtoolsRetry() {
+    nativeDevtoolsRetryToken++;
+    if (nativeDevtoolsRetryTimer) {
+      clearTimeout(nativeDevtoolsRetryTimer);
+      nativeDevtoolsRetryTimer = null;
+    }
+  }
+  function closeNativeDevtoolsSource() {
+    const source = nativeDevtoolsSourceWc;
+    nativeDevtoolsSourceWc = null;
+    try {
+      stopServiceConsole?.();
+    } catch {
+    }
+    stopServiceConsole = null;
+    if (!source || source.isDestroyed()) return;
+    try {
+      if (source.isDevToolsOpened()) {
+        source.closeDevTools();
+      }
+    } catch {
+    }
+  }
+  function stopFollowingNativeServiceHost() {
+    clearNativeDevtoolsRetry();
+    if (unsubscribeNativeRenderEvents) {
       try {
-        ctx.windows.mainWindow.contentView.removeChildView(view);
+        unsubscribeNativeRenderEvents();
       } catch {
       }
+      unsubscribeNativeRenderEvents = null;
     }
+    closeNativeDevtoolsSource();
+  }
+  function injectOpenResourceHandler(serviceWc, devtoolsWc) {
+    if (serviceWc.isDestroyed() || devtoolsWc.isDestroyed()) return;
     try {
-      if (!view.webContents.isDestroyed()) {
-        view.webContents.close();
-      }
+      const sourceContext = projectSourceContextFromServiceHostUrl(
+        serviceWc.getURL(),
+        ctx.workspace?.getProjectPath?.()
+      );
+      if (!sourceContext) return;
+      devtoolsWc.executeJavaScript(buildDevtoolsProjectSourceLinksScript(sourceContext)).catch(() => {
+      });
     } catch {
     }
   }
-  let placementState = createInitialState();
-  let epochCounter = 0;
-  let rendererGeneration = 0;
-  const baseDesired = /* @__PURE__ */ new Map();
-  const overlayDesired = /* @__PURE__ */ new Map();
-  function gateReadiness(v) {
-    if (v.viewId === VIEW_ID.simulator && !nativeSimulatorView)
-      return { ...v, placement: { visible: false } };
-    if (v.viewId === VIEW_ID.simulatorDevtools && !simulatorView)
-      return { ...v, placement: { visible: false } };
-    if (v.viewId === VIEW_ID.workbench && !workbenchView && !workbenchUrl)
-      return { ...v, placement: { visible: false } };
-    return v;
-  }
-  function resolveView(viewId) {
-    switch (viewId) {
-      case VIEW_ID.simulator:
-        return nativeSimulatorView;
-      case VIEW_ID.simulatorDevtools:
-        return simulatorView;
-      case VIEW_ID.workbench:
-        return workbenchView;
-      case VIEW_ID.hostToolbar:
-        return hostToolbarView;
-      case VIEW_ID.settings:
-        return settingsView;
-      case VIEW_ID.popover:
-        return popoverView;
-      default:
-        return null;
+  function customizeDevtoolsTabs(devtoolsWc) {
+    try {
+      if (devtoolsWc.isDestroyed()) return;
+      const inject = () => {
+        if (devtoolsWc.isDestroyed()) return;
+        try {
+          void devtoolsWc.executeJavaScript(buildCustomizeTabsScript()).catch(() => {
+          });
+        } catch {
+        }
+      };
+      injectWhenReady(devtoolsWc, "customize-tabs", inject);
+    } catch {
     }
   }
-  function markAdded(viewId, added) {
-    switch (viewId) {
-      case VIEW_ID.simulator:
-        nativeSimulatorViewAdded = added;
-        break;
-      case VIEW_ID.simulatorDevtools:
-        simulatorViewAdded = added;
-        break;
-      case VIEW_ID.hostToolbar:
-        hostToolbarViewAdded = added;
-        break;
+  function wireOpenInEditor(serviceWc, devtoolsWc) {
+    if (!devtoolsWc.isDestroyed()) {
+      injectWhenReady(devtoolsWc, "open-in-editor", () => injectOpenResourceHandler(serviceWc, devtoolsWc));
     }
+    if (openInEditorWiredWcIds.has(serviceWc.id)) return;
+    openInEditorWiredWcIds.add(serviceWc.id);
+    const onOpenUrl = (_event, url) => {
+      const req = decodeOpenInEditorUrl(url);
+      if (!req) return;
+      const target = resolveProjectEditorTarget(
+        serviceWc.getURL(),
+        ctx.workspace?.getProjectPath?.(),
+        req
+      );
+      if (!target) return;
+      deps.openFileInWorkbench(target.path, target.line ?? 1, target.column ?? 1);
+      ctx.notify.editorOpenFile(target);
+    };
+    serviceWc.on("devtools-open-url", onOpenUrl);
+    const conn = ctx.connections.acquire(serviceWc);
+    conn.on("closed", () => {
+      openInEditorWiredWcIds.delete(serviceWc.id);
+      try {
+        serviceWc.removeListener("devtools-open-url", onOpenUrl);
+      } catch {
+      }
+    });
   }
-  function applyNativeSimulatorBounds(view, bounds, zoom) {
-    const p = computeNativeSimulatorViewParams(bounds, zoom);
-    currentZoomFactor = p.zoomFactor;
-    view.setBounds(p.bounds);
-    const simWc = view.webContents;
-    if (!simWc.isDestroyed()) simWc.setZoomFactor(p.zoomFactor);
+  function pointNativeDevtoolsAtServiceWc(next) {
+    if (!simulatorView || simulatorView.webContents.isDestroyed()) return true;
+    if (nativeDevtoolsSourceWc?.id === next.id && !nativeDevtoolsSourceWc.isDestroyed()) {
+      return true;
+    }
+    closeNativeDevtoolsSource();
+    nativeDevtoolsSourceWc = next;
+    if (devtoolsHostUsed) {
+      rebuildDevtoolsHostView();
+    }
+    if (!simulatorView || simulatorView.webContents.isDestroyed()) return true;
     try {
-      for (const wc of webContents.getAllWebContents()) {
-        if (wc.isDestroyed()) continue;
-        if (wc.hostWebContents === simWc) wc.setZoomFactor(p.zoomFactor);
+      next.setDevToolsWebContents(simulatorView.webContents);
+      next.openDevTools({ mode: "detach", activate: false });
+      devtoolsHostUsed = true;
+      wireOpenInEditor(next, simulatorView.webContents);
+      customizeDevtoolsTabs(simulatorView.webContents);
+      try {
+        stopServiceConsole?.();
+      } catch {
       }
-    } catch {
+      stopServiceConsole = installServiceConsoleForward({
+        serviceWc: next,
+        connections: ctx.connections,
+        emit: (entry) => ctx.consoleForwarder?.emit(entry)
+      }).stop;
+      return true;
+    } catch (err) {
+      console.warn("[devtools-host] point-at-service-wc failed; retry will rebuild:", err);
+      if (nativeDevtoolsSourceWc?.id === next.id) {
+        nativeDevtoolsSourceWc = null;
+      }
+      return false;
     }
   }
-  const viewTarget = {
-    attach(viewId) {
-      if (ctx.windows.mainWindow.isDestroyed()) return;
-      if (viewId === VIEW_ID.workbench && !workbenchView && workbenchUrl) {
-        void attachWorkbench(workbenchUrl);
-        return;
+  function pointNativeDevtoolsAtActiveServiceHost(appId) {
+    if (!ctx.bridge?.isNativeHost()) return true;
+    if (!simulatorView || simulatorView.webContents.isDestroyed()) return true;
+    const wc = ctx.bridge.getServiceWc(appId);
+    if (!wc || wc.isDestroyed()) return false;
+    return pointNativeDevtoolsAtServiceWc(wc);
+  }
+  function scheduleNativeDevtoolsFollow(appId, attempt = 0) {
+    if (attempt >= 20) return;
+    if (!ctx.bridge?.isNativeHost()) return;
+    const token = nativeDevtoolsRetryToken;
+    if (nativeDevtoolsRetryTimer) clearTimeout(nativeDevtoolsRetryTimer);
+    nativeDevtoolsRetryTimer = setTimeout(() => {
+      nativeDevtoolsRetryTimer = null;
+      if (token !== nativeDevtoolsRetryToken) return;
+      if (pointNativeDevtoolsAtActiveServiceHost(appId)) return;
+      scheduleNativeDevtoolsFollow(appId, attempt + 1);
+    }, 50);
+  }
+  function followNativeDevtoolsServiceHost(appId) {
+    clearNativeDevtoolsRetry();
+    if (pointNativeDevtoolsAtActiveServiceHost(appId)) return;
+    scheduleNativeDevtoolsFollow(appId);
+  }
+  function onNativeRenderEvent(event) {
+    if (event.kind !== "activePage" && event.kind !== "domReady") return;
+    followNativeDevtoolsServiceHost(event.appId);
+  }
+  function rebuildDevtoolsHostView() {
+    if (simulatorView) {
+      removeSimulatorDevtoolsView();
+      try {
+        if (!simulatorView.webContents.isDestroyed()) {
+          simulatorView.webContents.close();
+        }
+      } catch {
       }
-      if (viewId === VIEW_ID.hostToolbar) {
-        const view2 = ensureHostToolbarView();
-        ctx.windows.mainWindow.contentView.addChildView(view2);
-        hostToolbarViewAdded = true;
-        return;
+      simulatorView = null;
+    }
+    simulatorView = new WebContentsView3();
+    const devtoolsWc = simulatorView.webContents;
+    raiseExecuteJavaScriptListenerCeiling(devtoolsWc);
+    ctx.networkForward?.setDevtoolsHost(devtoolsWc);
+    if (ctx.bridge) {
+      try {
+        stopElementsForward?.();
+      } catch {
       }
-      const view = resolveView(viewId);
-      if (!view) return;
-      ctx.windows.mainWindow.contentView.addChildView(view);
-      markAdded(viewId, true);
-    },
-    detach(viewId) {
-      const view = resolveView(viewId);
-      if (view && !ctx.windows.mainWindow.isDestroyed()) {
+      const thisForward = installElementsForward({ devtoolsWc, bridge: ctx.bridge, connections: ctx.connections });
+      stopElementsForward = thisForward;
+      devtoolsWc.once("destroyed", () => {
         try {
-          ctx.windows.mainWindow.contentView.removeChildView(view);
+          thisForward();
         } catch {
         }
-      }
-      markAdded(viewId, false);
-    },
-    setBounds(viewId, bounds, extra) {
-      const view = resolveView(viewId);
-      if (!view || view.webContents.isDestroyed()) return;
-      if (viewId === VIEW_ID.simulator) {
-        applyNativeSimulatorBounds(view, bounds, extra?.zoom ?? 1);
-        return;
-      }
-      view.setBounds(bounds);
-    },
-    setVisible(viewId, visible) {
-      const view = resolveView(viewId);
-      if (!view) return;
+        if (stopElementsForward === thisForward) stopElementsForward = null;
+      });
+    }
+    injectWhenReady(devtoolsWc, "console-default", () => {
+      devtoolsWc.executeJavaScript(`
+        (function() {
+          try { localStorage.setItem('panel-selectedTab', '"console"') } catch {}
+          let tries = 0
+          const timer = setInterval(() => {
+            tries++
+            try {
+              const UI = globalThis.UI
+              const vm = UI && UI.ViewManager && typeof UI.ViewManager.instance === 'function'
+                ? UI.ViewManager.instance()
+                : null
+              if (vm && typeof vm.showView === 'function') {
+                vm.showView('console')
+                clearInterval(timer)
+                return
+              }
+            } catch {}
+            if (tries > 80) clearInterval(timer)
+          }, 50)
+        })()
+      `).catch(() => {
+      });
+    });
+    reconciler.reconcileNow();
+    devtoolsHostUsed = false;
+  }
+  function attachNativeSimulatorDevtoolsHost() {
+    stopFollowingNativeServiceHost();
+    rebuildDevtoolsHostView();
+    if (ctx.bridge?.isNativeHost()) {
+      unsubscribeNativeRenderEvents = ctx.bridge.onRenderEvent(onNativeRenderEvent);
+      followNativeDevtoolsServiceHost();
+    }
+  }
+  function removeSimulatorDevtoolsView() {
+    if (simulatorView && simulatorViewAdded) {
       try {
-        view.setVisible(visible);
-      } catch {
+        ctx.windows.mainWindow.contentView.removeChildView(simulatorView);
+      } catch (e) {
+        console.error("[workbench] removeSimulatorDevtoolsView error", e);
       }
-    },
-    reorder(order) {
-      if (order.length <= 1 || ctx.windows.mainWindow.isDestroyed()) return;
-      const cv = ctx.windows.mainWindow.contentView;
-      for (const viewId of order) {
-        const view = resolveView(viewId);
-        if (view) {
-          try {
-            cv.addChildView(view);
-          } catch {
-          }
-        }
+      simulatorViewAdded = false;
+    }
+    reconciler.forgetActual(VIEW_ID.simulatorDevtools);
+  }
+  reconciler.registerView(VIEW_ID.simulatorDevtools, {
+    getView: () => simulatorView,
+    setAdded: (added) => {
+      simulatorViewAdded = added;
+    },
+    gateHidden: () => !simulatorView
+  });
+  return {
+    attach: attachNativeSimulatorDevtoolsHost,
+    followServiceHost: followNativeDevtoolsServiceHost,
+    stopFollowing: stopFollowingNativeServiceHost,
+    stopElementsForwarding: () => {
+      try {
+        stopElementsForward?.();
+      } catch {
       }
+      stopElementsForward = null;
+    },
+    destroyHostView: () => {
+      destroyChildView(ctx.windows.mainWindow, simulatorView);
+      simulatorView = null;
+      simulatorViewAdded = false;
     }
   };
-  function ensureLazyViews() {
-    const ht = baseDesired.get(VIEW_ID.hostToolbar);
-    if (ht?.placement.visible && !liveHostToolbarWebContents()) ensureHostToolbarView();
-    const wb = baseDesired.get(VIEW_ID.workbench);
-    if (wb?.placement.visible && !workbenchView && workbenchUrl) void attachWorkbench(workbenchUrl);
-  }
-  function reconcileNow() {
-    ensureLazyViews();
-    const views = [];
-    for (const v of baseDesired.values()) views.push(gateReadiness(v));
-    for (const v of overlayDesired.values()) views.push(v);
-    const result = reconcile(placementState, {
-      generation: rendererGeneration,
-      epoch: ++epochCounter,
-      views
+}
+
+// src/main/services/views/host-toolbar-view.ts
+import { WebContentsView as WebContentsView4 } from "electron";
+
+// src/main/services/views/host-toolbar-session-runtime.ts
+import { session } from "electron";
+var refCount = 0;
+var registrationId = null;
+function acquireHostToolbarSessionRuntime() {
+  if (refCount === 0) {
+    registrationId = session.defaultSession.registerPreloadScript({
+      type: "frame",
+      filePath: hostToolbarRuntimePreloadPath
     });
-    placementState = result.state;
-    applyViewOps(result.ops, viewTarget);
-  }
-  function setPlacementSnapshot(snapshot) {
-    rendererGeneration = snapshot.generation;
-    baseDesired.clear();
-    for (const v of snapshot.views) baseDesired.set(v.viewId, v);
-    reconcileNow();
   }
-  function workbenchThemeScheme() {
-    return nativeTheme3.shouldUseDarkColors ? "dark" : "light";
+  refCount++;
+}
+function releaseHostToolbarSessionRuntime() {
+  if (refCount === 0) return;
+  refCount--;
+  if (refCount === 0 && registrationId !== null) {
+    session.defaultSession.unregisterPreloadScript(registrationId);
+    registrationId = null;
   }
-  function pushWorkbenchTheme() {
-    if (!workbenchView || workbenchView.webContents.isDestroyed()) return;
-    const wc = workbenchView.webContents;
-    if (typeof wc.executeJavaScript !== "function") return;
-    const script = `window.__WB_SET_THEME && window.__WB_SET_THEME(${JSON.stringify(workbenchThemeScheme())})`;
-    wc.executeJavaScript(script, true).catch(() => {
-    });
+}
+
+// src/main/services/views/host-toolbar-port-channel.ts
+import { MessageChannelMain } from "electron";
+function createHostToolbarPortChannel(opts) {
+  let activePort = null;
+  let activeWc = null;
+  let state = "absent";
+  let generation = 0;
+  const handlers2 = [];
+  const readyHandlers = [];
+  function dispatch(data) {
+    if (typeof data !== "object" || data === null) return;
+    const { channel, payload } = data;
+    if (typeof channel !== "string") return;
+    for (const entry of [...handlers2]) {
+      if (entry.channel === channel) entry.handler(payload);
+    }
   }
-  async function attachWorkbench(url) {
-    if (workbenchView) return;
-    const view = new WebContentsView2({
-      webPreferences: {
-        nodeIntegration: false,
-        contextIsolation: true,
-        sandbox: false
+  function dropActivePort(close, next) {
+    const port = activePort;
+    activePort = null;
+    activeWc = null;
+    if (state !== "disposed") state = next;
+    if (close && port) {
+      try {
+        port.close();
+      } catch {
       }
-    });
-    workbenchView = view;
-    if (!workbenchThemeSyncBound) {
-      nativeTheme3.on("updated", pushWorkbenchTheme);
-      workbenchThemeSyncBound = true;
     }
+  }
+  function invokeReadyHandler(handler) {
     try {
-      view.webContents.setWindowOpenHandler(({ url: target }) => handleWindowOpenExternal(target));
-    } catch {
+      handler();
+    } catch (err) {
+      console.error("[host-toolbar] onReady handler threw:", err);
     }
-    ctx.windows.mainWindow.contentView.addChildView(view);
-    const loadUrl = `${url}index.html?theme=${workbenchThemeScheme()}`;
-    await view.webContents.loadURL(loadUrl).catch((err) => {
-      console.error("[workbench] attachWorkbench \u2014 loadURL failed", err);
-    });
-  }
-  function setWorkbenchSource(url) {
-    workbenchUrl = url;
   }
-  function detachWorkbench() {
-    if (workbenchThemeSyncBound) {
-      nativeTheme3.removeListener("updated", pushWorkbenchTheme);
-      workbenchThemeSyncBound = false;
+  function fireReadyHandlers() {
+    for (const entry of [...readyHandlers]) {
+      if (readyHandlers.includes(entry)) invokeReadyHandler(entry.handler);
     }
-    destroyViewInternal(workbenchView);
-    workbenchView = null;
-    baseDesired.delete(VIEW_ID.workbench);
-    reconcileNow();
-  }
-  function workspaceUriFor(rel) {
-    const encoded = rel.split("/").map(encodeURIComponent).join("/");
-    return `file:///workspace/${encoded}`;
   }
-  function tryRevealInWorkbench(uri, zeroLine, zeroCol) {
-    if (!workbenchView || workbenchView.webContents.isDestroyed()) {
-      return Promise.resolve(false);
-    }
-    const script = `(async () => {
-      try {
-        const P = window.__WB_PROBE; if (!P) return false
-        const vscode = P.vscode
-        const uri = vscode.Uri.parse(${JSON.stringify(uri)})
-        const doc = await vscode.workspace.openTextDocument(uri)
-        const pos = new vscode.Position(${zeroLine}, ${zeroCol})
-        await vscode.window.showTextDocument(doc, { selection: new vscode.Range(pos, pos) })
-        return true
-      } catch (e) { return false }
-    })()`;
-    return workbenchView.webContents.executeJavaScript(script, true).then((ok) => ok === true).catch(() => false);
+  function handshake(wc) {
+    if (state === "disposed") return;
+    if (!opts.isCurrent(wc)) return;
+    dropActivePort(true, "awaitingHandshake");
+    const { port1, port2 } = new MessageChannelMain();
+    port1.on("message", (event) => {
+      dispatch(event.data);
+    });
+    port1.on("close", () => {
+      if (activePort === port1) dropActivePort(false, "absent");
+    });
+    wc.postMessage(ViewChannel.HostToolbarPort, null, [port2]);
+    port1.start();
+    activePort = port1;
+    activeWc = wc;
+    state = "ready";
+    generation++;
+    fireReadyHandlers();
   }
-  function openFileInWorkbench(relPath, line, column) {
-    if (!workbenchView || workbenchView.webContents.isDestroyed()) return false;
-    const uri = workspaceUriFor(relPath.replace(/^\/+/, ""));
-    const zeroLine = Math.max(0, Math.floor(line) - 1);
-    const zeroCol = Math.max(0, Math.floor(column) - 1);
-    void (async () => {
-      for (let attempt = 0; attempt < 10; attempt++) {
-        if (!workbenchView || workbenchView.webContents.isDestroyed()) return;
-        if (await tryRevealInWorkbench(uri, zeroLine, zeroCol)) return;
-        await new Promise((resolve) => setTimeout(resolve, 150));
+  return {
+    attach(wc) {
+      wc.on("did-finish-load", () => handshake(wc));
+      wc.on(
+        "did-start-navigation",
+        (details, _url, isInPlace, isMainFramePositional) => {
+          if (activeWc !== wc) return;
+          const isSameDocument = typeof details?.isSameDocument === "boolean" ? details.isSameDocument : isInPlace;
+          const isMainFrame = typeof details?.isMainFrame === "boolean" ? details.isMainFrame : isMainFramePositional;
+          if (isSameDocument || !isMainFrame) return;
+          dropActivePort(true, "awaitingHandshake");
+        }
+      );
+      wc.on("destroyed", () => {
+        if (activeWc === wc) dropActivePort(true, "absent");
+      });
+    },
+    invalidate() {
+      dropActivePort(true, "awaitingHandshake");
+    },
+    onMessage(channel, handler) {
+      if (typeof channel !== "string" || channel === "") {
+        throw new TypeError(
+          "hostToolbar.onMessage: channel must be a non-empty string"
+        );
       }
-      console.error("[workbench] openFileInWorkbench: workbench never became ready for", uri);
-    })();
-    return true;
-  }
+      const entry = { channel, handler };
+      handlers2.push(entry);
+      return {
+        dispose() {
+          const i = handlers2.indexOf(entry);
+          if (i >= 0) handlers2.splice(i, 1);
+        }
+      };
+    },
+    onReady(handler) {
+      if (state === "disposed") {
+        return { dispose() {
+        } };
+      }
+      const entry = { handler };
+      readyHandlers.push(entry);
+      if (state === "ready") {
+        const scheduledGeneration = generation;
+        queueMicrotask(() => {
+          if (state !== "ready" || generation !== scheduledGeneration || !activePort) return;
+          if (!readyHandlers.includes(entry)) return;
+          invokeReadyHandler(entry.handler);
+        });
+      }
+      return {
+        dispose() {
+          const i = readyHandlers.indexOf(entry);
+          if (i >= 0) readyHandlers.splice(i, 1);
+        }
+      };
+    },
+    send(channel, payload) {
+      if (!activePort) return false;
+      activePort.postMessage({ channel, payload });
+      return true;
+    },
+    dispose() {
+      dropActivePort(true, "absent");
+      state = "disposed";
+      handlers2.length = 0;
+      readyHandlers.length = 0;
+    }
+  };
+}
+
+// src/main/services/views/host-toolbar-view.ts
+function createHostToolbarView(ctx, reconciler, deps) {
+  let hostToolbarView = null;
+  let hostToolbarPreloadOverride = null;
+  let hostToolbarViewAdded = false;
+  let hostToolbarRuntimeAcquired = false;
+  let hostToolbarHeightMode = "auto";
+  let hostToolbarLastHeight = 0;
+  const hostToolbarPort = createHostToolbarPortChannel({
+    isCurrent: (wc) => liveHostToolbarWebContents() === wc
+  });
   function liveHostToolbarWebContents() {
     const wc = hostToolbarView?.webContents;
     if (!wc || wc.isDestroyed()) return null;
@@ -2801,7 +2948,7 @@ function createViewManager(ctx) {
       }
       hostToolbarViewAdded = false;
     }
-    placementState.actual.delete(VIEW_ID.hostToolbar);
+    reconciler.forgetActual(VIEW_ID.hostToolbar);
     if (!hostToolbarRuntimeAcquired) {
       acquireHostToolbarSessionRuntime();
       hostToolbarRuntimeAcquired = true;
@@ -2815,7 +2962,7 @@ function createViewManager(ctx) {
     if (hostToolbarPreloadOverride !== null) {
       webPreferences.preload = hostToolbarPreloadOverride;
     }
-    const view = new WebContentsView2({ webPreferences });
+    const view = new WebContentsView4({ webPreferences });
     hostToolbarView = view;
     hostToolbarPort.attach(view.webContents);
     try {
@@ -2831,23 +2978,22 @@ function createViewManager(ctx) {
   function notifyHostToolbarHeight(height) {
     hostToolbarLastHeight = height;
     ctx.notify.hostToolbarHeightChanged(height);
-    if (overlayDesired.has(VIEW_ID.settings)) applySettingsBounds();
-    if (overlayDesired.has(VIEW_ID.popover)) applyPopoverBounds();
+    deps.reapplyPresentOverlays();
   }
   function setHostToolbarHeight(extent) {
     if (hostToolbarHeightMode !== "auto") return;
     notifyHostToolbarHeight(extent);
   }
   function hideHostToolbar() {
-    baseDesired.set(VIEW_ID.hostToolbar, {
+    reconciler.setBaseDesired(VIEW_ID.hostToolbar, {
       viewId: VIEW_ID.hostToolbar,
       placement: { visible: false },
       layer: VIEW_LAYER.hostToolbar
     });
-    reconcileNow();
+    reconciler.reconcileNow();
     notifyHostToolbarHeight(0);
   }
-  const hostToolbar = {
+  const control = {
     async loadURL(url) {
       const view = ensureHostToolbarView();
       hostToolbarPort.invalidate();
@@ -2864,8 +3010,8 @@ function createViewManager(ctx) {
     hide() {
       hideHostToolbar();
     },
-    setPreloadPath(path23) {
-      hostToolbarPreloadOverride = path23;
+    setPreloadPath(path24) {
+      hostToolbarPreloadOverride = path24;
     },
     setHeightMode(mode) {
       if (mode !== "auto" && !(Number.isFinite(mode.fixed) && mode.fixed >= 0)) {
@@ -2888,13 +3034,80 @@ function createViewManager(ctx) {
       return hostToolbarPort.send(channel, payload);
     }
   };
+  reconciler.registerView(VIEW_ID.hostToolbar, {
+    getView: () => hostToolbarView,
+    ensureView: () => ensureHostToolbarView(),
+    setAdded: (added) => {
+      hostToolbarViewAdded = added;
+    },
+    ensureLazy: (desired) => {
+      if (desired?.placement.visible && !liveHostToolbarWebContents()) ensureHostToolbarView();
+    }
+  });
+  function dispose() {
+    hostToolbarPort.dispose();
+    destroyChildView(ctx.windows.mainWindow, hostToolbarView);
+    hostToolbarView = null;
+    hostToolbarViewAdded = false;
+    if (hostToolbarRuntimeAcquired) {
+      releaseHostToolbarSessionRuntime();
+      hostToolbarRuntimeAcquired = false;
+    }
+  }
+  return {
+    control,
+    setHostToolbarHeight,
+    getHostToolbarHeight: () => hostToolbarLastHeight,
+    getHostToolbarWebContentsId: () => liveHostToolbarWebContents()?.id ?? null,
+    dispose
+  };
+}
+
+// src/main/services/views/overlay-panels-view.ts
+import { WebContentsView as WebContentsView5 } from "electron";
+import path8 from "path";
+
+// src/main/services/layout/index.ts
+function computeNativeSimulatorViewParams(rect, zoomPercent) {
+  const zoomFactor = zoomPercent / 100;
+  return {
+    bounds: {
+      x: Math.round(rect.x),
+      y: Math.round(rect.y),
+      width: Math.max(0, Math.round(rect.width)),
+      height: Math.max(0, Math.round(rect.height))
+    },
+    zoomFactor
+  };
+}
+function computeSettingsBounds(contentWidth, contentHeight, headerHeight) {
+  return {
+    x: 0,
+    y: headerHeight,
+    width: Math.max(1, contentWidth),
+    height: Math.max(1, contentHeight - headerHeight)
+  };
+}
+function computePopoverBounds(contentWidth, contentHeight, headerHeight) {
+  return {
+    x: 0,
+    y: headerHeight,
+    width: Math.max(1, contentWidth),
+    height: contentHeight - headerHeight
+  };
+}
+
+// src/main/services/views/overlay-panels-view.ts
+function createOverlayPanelsView(ctx, reconciler, deps) {
+  let settingsView = null;
+  let popoverView = null;
   function overlayHeaderHeight() {
-    return HEADER_H + hostToolbarLastHeight;
+    return HEADER_H + deps.getHostToolbarHeight();
   }
   function applySettingsBounds() {
     if (!settingsView || ctx.windows.mainWindow.isDestroyed()) return;
     const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-    overlayDesired.set(VIEW_ID.settings, {
+    reconciler.setOverlayDesired(VIEW_ID.settings, {
       viewId: VIEW_ID.settings,
       placement: {
         visible: true,
@@ -2902,12 +3115,12 @@ function createViewManager(ctx) {
       },
       layer: VIEW_LAYER.settings
     });
-    reconcileNow();
+    reconciler.reconcileNow();
   }
   function applyPopoverBounds() {
     if (!popoverView || ctx.windows.mainWindow.isDestroyed()) return;
     const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-    overlayDesired.set(VIEW_ID.popover, {
+    reconciler.setOverlayDesired(VIEW_ID.popover, {
       viewId: VIEW_ID.popover,
       placement: {
         visible: true,
@@ -2915,229 +3128,323 @@ function createViewManager(ctx) {
       },
       layer: VIEW_LAYER.popover
     });
-    reconcileNow();
+    reconciler.reconcileNow();
   }
-  function clearNativeDevtoolsRetry() {
-    nativeDevtoolsRetryToken++;
-    if (nativeDevtoolsRetryTimer) {
-      clearTimeout(nativeDevtoolsRetryTimer);
-      nativeDevtoolsRetryTimer = null;
+  async function showSettings() {
+    if (!settingsView) {
+      settingsView = new WebContentsView5({
+        webPreferences: {
+          nodeIntegration: false,
+          contextIsolation: true,
+          sandbox: false,
+          preload: mainPreloadPath
+        }
+      });
+      applyNavigationHardening(settingsView.webContents, ctx.rendererDir);
+      settingsView.setBackgroundColor("#00000000");
+      await settingsView.webContents.loadFile(
+        path8.join(ctx.rendererDir, "entries/settings/index.html")
+      );
     }
+    applySettingsBounds();
   }
-  function closeNativeDevtoolsSource() {
-    const source = nativeDevtoolsSourceWc;
-    nativeDevtoolsSourceWc = null;
-    try {
-      stopServiceConsole?.();
-    } catch {
-    }
-    stopServiceConsole = null;
-    if (!source || source.isDestroyed()) return;
-    try {
-      if (source.isDevToolsOpened()) {
-        source.closeDevTools();
-      }
-    } catch {
-    }
+  function hideSettings() {
+    reconciler.deleteOverlayDesired(VIEW_ID.settings);
+    reconciler.reconcileNow();
   }
-  function stopFollowingNativeServiceHost() {
-    clearNativeDevtoolsRetry();
-    if (unsubscribeNativeRenderEvents) {
-      try {
-        unsubscribeNativeRenderEvents();
-      } catch {
+  function showPopover(data) {
+    hidePopover();
+    const popover = new WebContentsView5({
+      webPreferences: {
+        nodeIntegration: false,
+        contextIsolation: true,
+        sandbox: false,
+        preload: mainPreloadPath
       }
-      unsubscribeNativeRenderEvents = null;
-    }
-    closeNativeDevtoolsSource();
+    });
+    applyNavigationHardening(popover.webContents, ctx.rendererDir);
+    popoverView = popover;
+    popover.setBackgroundColor("#00000000");
+    applyPopoverBounds();
+    popover.webContents.once("did-finish-load", () => {
+      ctx.notify.popoverInit(popover, data);
+    });
+    popover.webContents.loadFile(
+      path8.join(ctx.rendererDir, "entries/popover/index.html")
+    );
   }
-  const openInEditorWiredWcIds = /* @__PURE__ */ new Set();
-  function injectOpenResourceHandler(serviceWc, devtoolsWc) {
-    if (serviceWc.isDestroyed() || devtoolsWc.isDestroyed()) return;
-    try {
-      const sourceContext = projectSourceContextFromServiceHostUrl(
-        serviceWc.getURL(),
-        ctx.workspace?.getProjectPath?.()
-      );
-      if (!sourceContext) return;
-      devtoolsWc.executeJavaScript(buildDevtoolsProjectSourceLinksScript(sourceContext)).catch(() => {
-      });
-    } catch {
-    }
+  function hidePopover() {
+    if (!popoverView) return;
+    reconciler.deleteOverlayDesired(VIEW_ID.popover);
+    destroyChildView(ctx.windows.mainWindow, popoverView);
+    popoverView = null;
+    reconciler.reconcileNow();
+    ctx.notify.popoverClosed();
   }
-  function customizeDevtoolsTabs(devtoolsWc) {
-    try {
-      if (devtoolsWc.isDestroyed()) return;
-      const inject = () => {
-        if (devtoolsWc.isDestroyed()) return;
-        try {
-          void devtoolsWc.executeJavaScript(buildCustomizeTabsScript()).catch(() => {
-          });
-        } catch {
-        }
-      };
-      if (devtoolsWc.isLoading()) {
-        devtoolsWc.once("dom-ready", inject);
-      } else {
-        inject();
-      }
-    } catch {
-    }
+  function reapplyPresentOverlays() {
+    if (reconciler.hasOverlayDesired(VIEW_ID.settings)) applySettingsBounds();
+    if (reconciler.hasOverlayDesired(VIEW_ID.popover)) applyPopoverBounds();
   }
-  function wireOpenInEditor(serviceWc, devtoolsWc) {
-    if (!devtoolsWc.isDestroyed()) {
-      if (devtoolsWc.isLoading()) {
-        devtoolsWc.once("dom-ready", () => injectOpenResourceHandler(serviceWc, devtoolsWc));
-      } else {
-        injectOpenResourceHandler(serviceWc, devtoolsWc);
-      }
+  function applySettingsBoundsIfPresent() {
+    if (reconciler.hasOverlayDesired(VIEW_ID.settings)) applySettingsBounds();
+  }
+  function destroySettings() {
+    destroyChildView(ctx.windows.mainWindow, settingsView);
+    settingsView = null;
+  }
+  reconciler.registerView(VIEW_ID.settings, { getView: () => settingsView });
+  reconciler.registerView(VIEW_ID.popover, { getView: () => popoverView });
+  return {
+    showSettings,
+    hideSettings,
+    showPopover,
+    hidePopover,
+    reapplyPresentOverlays,
+    applySettingsBoundsIfPresent,
+    destroySettings,
+    getSettingsWebContents: () => {
+      if (!settingsView) return null;
+      if (settingsView.webContents.isDestroyed()) return null;
+      return settingsView.webContents;
+    },
+    getSettingsWebContentsId: () => {
+      if (!settingsView) return null;
+      if (settingsView.webContents.isDestroyed()) return null;
+      return settingsView.webContents.id;
+    },
+    getPopoverWebContentsId: () => {
+      if (!popoverView) return null;
+      if (popoverView.webContents.isDestroyed()) return null;
+      return popoverView.webContents.id;
     }
-    if (openInEditorWiredWcIds.has(serviceWc.id)) return;
-    openInEditorWiredWcIds.add(serviceWc.id);
-    const onOpenUrl = (_event, url) => {
-      const req = decodeOpenInEditorUrl(url);
-      if (!req) return;
-      const target = resolveProjectEditorTarget(
-        serviceWc.getURL(),
-        ctx.workspace?.getProjectPath?.(),
-        req
-      );
-      if (!target) return;
-      openFileInWorkbench(target.path, target.line ?? 1, target.column ?? 1);
-      ctx.notify.editorOpenFile(target);
-    };
-    serviceWc.on("devtools-open-url", onOpenUrl);
-    const conn = ctx.connections.acquire(serviceWc);
-    conn.on("closed", () => {
-      openInEditorWiredWcIds.delete(serviceWc.id);
-      try {
-        serviceWc.removeListener("devtools-open-url", onOpenUrl);
-      } catch {
-      }
-    });
+  };
+}
+
+// src/main/services/views/native-simulator-view.ts
+import { ipcMain as ipcMain2, nativeTheme as nativeTheme4, shell as shell2, WebContentsView as WebContentsView6, webContents } from "electron";
+
+// src/main/services/simulator/custom-apis.ts
+async function handleCustomApiBridgeRequest(apis, req) {
+  try {
+    const result = req.op === "list" ? apis.list() : await apis.invoke(req.name, req.params);
+    return { id: req.id, result };
+  } catch (err) {
+    return { id: req.id, error: err instanceof Error ? err.message : String(err) };
   }
-  function pointNativeDevtoolsAtServiceWc(next) {
-    if (!simulatorView || simulatorView.webContents.isDestroyed()) return true;
-    if (nativeDevtoolsSourceWc?.id === next.id && !nativeDevtoolsSourceWc.isDestroyed()) {
-      return true;
+}
+function createSimulatorApiRegistry() {
+  const handlers2 = /* @__PURE__ */ new Map();
+  return {
+    register(name, handler) {
+      handlers2.set(name, handler);
+      return () => {
+        if (handlers2.get(name) === handler) handlers2.delete(name);
+      };
+    },
+    list() {
+      return Array.from(handlers2.keys());
+    },
+    has(name) {
+      return handlers2.has(name);
+    },
+    async invoke(name, params) {
+      const handler = handlers2.get(name);
+      if (!handler) throw new Error(`Simulator API "${name}" is not registered`);
+      return await handler(params);
+    },
+    clear() {
+      handlers2.clear();
     }
-    closeNativeDevtoolsSource();
-    nativeDevtoolsSourceWc = next;
+  };
+}
+
+// src/main/services/views/miniapp-partition.ts
+import * as electron from "electron";
+var SHARED_MINIAPP_PARTITION = "persist:simulator";
+var PARTITION_PREFIX = "persist:miniapp-";
+function miniappPartitionKey(appId, projectPath) {
+  const safe = appId.replace(/[^A-Za-z0-9_-]/g, "");
+  const base = safe === appId && safe.length > 0 ? safe : safe.length > 0 ? `${safe}-${djb2(appId).toString(36)}` : djb2(appId).toString(36);
+  if (!projectPath) return base;
+  return `${base}-p${djb2(projectPath).toString(36)}`;
+}
+function miniappPartition(appId, projectPath) {
+  if (!appId) return SHARED_MINIAPP_PARTITION;
+  return `${PARTITION_PREFIX}${miniappPartitionKey(appId, projectPath)}`;
+}
+function djb2(input) {
+  let h = 5381;
+  for (let i = 0; i < input.length; i++) {
+    h = (h << 5) + h + input.charCodeAt(i) >>> 0;
+  }
+  return h;
+}
+var configurators = /* @__PURE__ */ new Set();
+var configuredPartitions = /* @__PURE__ */ new Set();
+function registerMiniappSessionConfigurator(fn) {
+  configurators.add(fn);
+  for (const partition of configuredPartitions) {
     try {
-      next.setDevToolsWebContents(simulatorView.webContents);
-      next.openDevTools({ mode: "detach", activate: false });
-      wireOpenInEditor(next, simulatorView.webContents);
-      customizeDevtoolsTabs(simulatorView.webContents);
-      try {
-        stopServiceConsole?.();
-      } catch {
-      }
-      stopServiceConsole = installServiceConsoleForward({
-        serviceWc: next,
-        connections: ctx.connections,
-        emit: (entry) => ctx.consoleForwarder?.emit(entry)
-      }).stop;
-      return true;
-    } catch {
-      if (nativeDevtoolsSourceWc?.id === next.id) {
-        nativeDevtoolsSourceWc = null;
-      }
-      return false;
+      fn(electron.session.fromPartition(partition), partition);
+    } catch (err) {
+      console.warn("[miniapp-partition] configurator failed for", partition, err);
     }
   }
-  function pointNativeDevtoolsAtActiveServiceHost(appId) {
-    if (!ctx.bridge?.isNativeHost()) return true;
-    if (!simulatorView || simulatorView.webContents.isDestroyed()) return true;
-    const wc = ctx.bridge.getServiceWc(appId);
-    if (!wc || wc.isDestroyed()) return false;
-    return pointNativeDevtoolsAtServiceWc(wc);
-  }
-  function scheduleNativeDevtoolsFollow(appId, attempt = 0) {
-    if (attempt >= 20) return;
-    if (!ctx.bridge?.isNativeHost()) return;
-    const token = nativeDevtoolsRetryToken;
-    if (nativeDevtoolsRetryTimer) clearTimeout(nativeDevtoolsRetryTimer);
-    nativeDevtoolsRetryTimer = setTimeout(() => {
-      nativeDevtoolsRetryTimer = null;
-      if (token !== nativeDevtoolsRetryToken) return;
-      if (pointNativeDevtoolsAtActiveServiceHost(appId)) return;
-      scheduleNativeDevtoolsFollow(appId, attempt + 1);
-    }, 50);
+  return () => {
+    configurators.delete(fn);
+  };
+}
+function configureMiniappSession(partition) {
+  const alreadyConfigured = configuredPartitions.has(partition);
+  configuredPartitions.add(partition);
+  if (configurators.size === 0) return null;
+  const sess = electron.session.fromPartition(partition);
+  if (alreadyConfigured) return sess;
+  for (const fn of configurators) {
+    try {
+      fn(sess, partition);
+    } catch (err) {
+      console.warn("[miniapp-partition] configurator failed for", partition, err);
+    }
   }
-  function followNativeDevtoolsServiceHost(appId) {
-    clearNativeDevtoolsRetry();
-    if (pointNativeDevtoolsAtActiveServiceHost(appId)) return;
-    scheduleNativeDevtoolsFollow(appId);
+  return sess;
+}
+
+// src/shared/simulator-route.ts
+function decodePageSpec(value) {
+  const qIdx = value.indexOf("?");
+  if (qIdx < 0) return { pagePath: value, query: {} };
+  const pagePath = value.slice(0, qIdx);
+  const query = {};
+  for (const pair of value.slice(qIdx + 1).split("&")) {
+    if (!pair) continue;
+    const eqIdx = pair.indexOf("=");
+    const k = eqIdx >= 0 ? pair.slice(0, eqIdx) : pair;
+    const v = eqIdx >= 0 ? pair.slice(eqIdx + 1) : "";
+    if (k) query[decodeURIComponent(k)] = decodeURIComponent(v);
   }
-  function onNativeRenderEvent(event) {
-    if (event.kind !== "activePage" && event.kind !== "domReady") return;
-    followNativeDevtoolsServiceHost(event.appId);
+  return { pagePath, query };
+}
+function parseLocationRoute(search) {
+  const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+  const appId = params.get("appId");
+  const entryRaw = params.get("entry");
+  if (!appId || !entryRaw) return null;
+  const entry = decodePageSpec(entryRaw);
+  const pageRaw = params.get("page");
+  const current = pageRaw && pageRaw !== entryRaw ? decodePageSpec(pageRaw) : entry;
+  return { appId, entry, current };
+}
+function parseRoute(url) {
+  if (!url) return null;
+  try {
+    const u = new URL(url);
+    return parseLocationRoute(u.search);
+  } catch {
+    return null;
   }
-  function attachNativeSimulatorDevtoolsHost() {
-    stopFollowingNativeServiceHost();
-    if (simulatorView) {
-      removeSimulatorDevtoolsView();
-      try {
-        if (!simulatorView.webContents.isDestroyed()) {
-          simulatorView.webContents.close();
-        }
-      } catch {
-      }
-      simulatorView = null;
-    }
-    simulatorView = new WebContentsView2();
-    const devtoolsWc = simulatorView.webContents;
-    raiseExecuteJavaScriptListenerCeiling(devtoolsWc);
-    ctx.networkForward?.setDevtoolsHost(devtoolsWc);
-    if (ctx.bridge) {
-      try {
-        stopElementsForward?.();
-      } catch {
+}
+
+// src/shared/bridge-channels.ts
+var BRIDGE_CHANNELS = {
+  SPAWN: "dmb:spawn",
+  DISPOSE: "dmb:dispose",
+  PAGE_OPEN: "dmb:page:open",
+  PAGE_CLOSE: "dmb:page:close",
+  PAGE_LIFECYCLE: "dmb:page:lifecycle",
+  NAV_CALLBACK: "dmb:nav:callback",
+  SERVICE_INVOKE: "dmb:service:invoke",
+  SERVICE_PUBLISH: "dmb:service:publish",
+  RENDER_INVOKE: "dmb:render:invoke",
+  RENDER_PUBLISH: "dmb:render:publish",
+  TO_SERVICE: "dmb:to-service",
+  TO_RENDER: "dmb:to-render",
+  SIMULATOR_API: "dmb:simulator-api",
+  /** simulator → main: ack of an API_CALL request (carries success/fail args). */
+  API_RESPONSE: "dmb:api:response",
+  /**
+   * simulator webview preload → main (sendSync): "is native-host mode on?".
+   * The guest preload can't read the launch `process.env`, so it asks main
+   * (which can) at install time. Reply is `e.returnValue = boolean`.
+   */
+  NATIVE_HOST_ENABLED: "dmb:native-host-enabled",
+  /**
+   * simulator (DeviceShell) → main: the visible top-of-stack page bridgeId.
+   * Main has no z-order concept — the active page lives only in DeviceShell's
+   * ShellState — so devtools panels / automation that must target "the current
+   * page's render webContents" resolve it through this signal. Fire-and-forget.
+   */
+  ACTIVE_PAGE: "dmb:active-page",
+  /**
+   * simulator (DeviceShell) → main: the FULL ordered page stack (bottom→top)
+   * whenever it changes. Main has no stack of its own (it only learns the
+   * active bridgeId via ACTIVE_PAGE), so automation's `App.getPageStack` needs
+   * this to report multi-page stacks. Fire-and-forget.
+   */
+  PAGE_STACK: "dmb:page-stack"
+};
+var SIMULATOR_EVENTS = {
+  DOM_READY: "simulator:dom-ready",
+  NAV_BAR: "simulator:navigation-bar",
+  NAV_ACTION: "simulator:nav-action",
+  TAB_ACTION: "simulator:tab-action",
+  /** main → simulator: invoke a wx.* API on the simulator-resident MiniApp. */
+  API_CALL: "simulator:api-call",
+  /**
+   * main → simulator: the renderer toolbar picked a different device. Carries a
+   * NativeDeviceInfo; DeviceShell resizes the bezel + re-renders status bar /
+   * notch. The race-free INITIAL device rides NativeHostConfig.device (read
+   * synchronously at preload bridge-install); this event covers live changes.
+   */
+  DEVICE_CHANGE: "simulator:device-change",
+  /**
+   * main → simulator: a watcher rebuild finished; boot a NEW app session for
+   * the carried url ({@link RelaunchPayload}) IN PLACE, keeping the live
+   * DeviceShell painted, and swap once the new session's root page reports
+   * DOM_READY (ready-then-swap soft reload). Main sends this only when the
+   * shell is live+ready; otherwise the renderer falls back to the hard
+   * attachNativeSimulator rebuild.
+   */
+  RELAUNCH: "simulator:relaunch"
+};
+function deviceInfoToHostEnv(d) {
+  return {
+    brand: d.brand,
+    model: d.model,
+    system: d.system,
+    platform: d.platform,
+    pixelRatio: d.pixelRatio,
+    screenWidth: d.screenWidth,
+    screenHeight: d.screenHeight,
+    windowWidth: d.screenWidth,
+    windowHeight: Math.max(0, d.screenHeight - d.statusBarHeight),
+    statusBarHeight: d.statusBarHeight
+  };
+}
+
+// src/main/services/views/native-simulator-view.ts
+function createNativeSimulatorView(ctx, reconciler, deps) {
+  const { safeArea, devtoolsHost, overlayPanels } = deps;
+  let nativeSimulatorView = null;
+  let nativeSimulatorViewAdded = false;
+  let nativeSimulatorProjectPath = null;
+  let settleNativeSimulatorReady = null;
+  let nativeSimulatorShellReady = false;
+  let nativeCustomApiBridgeHandler = null;
+  let currentZoomFactor = 1;
+  let simulatorWebContentsId = null;
+  function applyNativeSimulatorBounds(view, bounds, zoom) {
+    const p = computeNativeSimulatorViewParams(bounds, zoom);
+    currentZoomFactor = p.zoomFactor;
+    view.setBounds(p.bounds);
+    const simWc = view.webContents;
+    if (!simWc.isDestroyed()) simWc.setZoomFactor(p.zoomFactor);
+    try {
+      for (const wc of webContents.getAllWebContents()) {
+        if (wc.isDestroyed()) continue;
+        if (wc.hostWebContents === simWc) wc.setZoomFactor(p.zoomFactor);
       }
-      const thisForward = installElementsForward({ devtoolsWc, bridge: ctx.bridge, connections: ctx.connections });
-      stopElementsForward = thisForward;
-      devtoolsWc.once("destroyed", () => {
-        try {
-          thisForward();
-        } catch {
-        }
-        if (stopElementsForward === thisForward) stopElementsForward = null;
-      });
-    }
-    devtoolsWc.once("dom-ready", () => {
-      devtoolsWc.executeJavaScript(`
-        (function() {
-          try { localStorage.setItem('panel-selectedTab', '"console"') } catch {}
-          let tries = 0
-          const timer = setInterval(() => {
-            tries++
-            try {
-              const UI = globalThis.UI
-              const vm = UI && UI.ViewManager && typeof UI.ViewManager.instance === 'function'
-                ? UI.ViewManager.instance()
-                : null
-              if (vm && typeof vm.showView === 'function') {
-                vm.showView('console')
-                clearInterval(timer)
-                return
-              }
-            } catch {}
-            if (tries > 80) clearInterval(timer)
-          }, 50)
-        })()
-      `).catch(() => {
-      });
-    });
-    reconcileNow();
-    if (ctx.bridge?.isNativeHost()) {
-      unsubscribeNativeRenderEvents = ctx.bridge.onRenderEvent(onNativeRenderEvent);
-      followNativeDevtoolsServiceHost();
-    }
-  }
-  function detachNativeCustomApiBridge() {
-    if (nativeCustomApiBridgeHandler) {
-      ipcMain2.removeListener(SimulatorCustomApiBridgeChannel.Request, nativeCustomApiBridgeHandler);
-      nativeCustomApiBridgeHandler = null;
+    } catch {
     }
   }
   function tearDownNativeSimulatorView(label) {
@@ -3157,7 +3464,15 @@ function createViewManager(ctx) {
     }
     nativeSimulatorView = null;
     nativeSimulatorViewAdded = false;
-    reconcileNow();
+    nativeSimulatorShellReady = false;
+    reconciler.forgetActual(VIEW_ID.simulator);
+    reconciler.reconcileNow();
+  }
+  function detachNativeCustomApiBridge() {
+    if (nativeCustomApiBridgeHandler) {
+      ipcMain2.removeListener(SimulatorCustomApiBridgeChannel.Request, nativeCustomApiBridgeHandler);
+      nativeCustomApiBridgeHandler = null;
+    }
   }
   function attachNativeCustomApiBridge(simWc) {
     detachNativeCustomApiBridge();
@@ -3196,7 +3511,7 @@ function createViewManager(ctx) {
     const route = parseRoute(simulatorUrl);
     const partition = miniappPartition(route?.appId, ctx.workspace?.getProjectPath());
     configureMiniappSession(partition);
-    const view = new WebContentsView2({
+    const view = new WebContentsView6({
       webPreferences: {
         nodeIntegration: false,
         contextIsolation: false,
@@ -3216,8 +3531,8 @@ function createViewManager(ctx) {
       } catch {
       }
     };
-    nativeTheme3.on("updated", syncDeskBg);
-    ctx.connections.acquire(simWc).own(() => nativeTheme3.removeListener("updated", syncDeskBg));
+    nativeTheme4.on("updated", syncDeskBg);
+    ctx.connections.acquire(simWc).own(() => nativeTheme4.removeListener("updated", syncDeskBg));
     attachNativeCustomApiBridge(simWc);
     const pendingGuestIsTab = [];
     simWc.on("will-attach-webview", (_event, webPreferences, params) => {
@@ -3259,10 +3574,11 @@ function createViewManager(ctx) {
       });
       guestWc.once("did-finish-load", () => {
         if (nativeSimulatorView !== view || simWc.isDestroyed()) return;
+        nativeSimulatorShellReady = true;
         settleNativeSimulatorReady?.();
         settleNativeSimulatorReady = null;
       });
-      followNativeDevtoolsServiceHost();
+      devtoolsHost.followServiceHost();
     });
     simWc.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
     simWc.on("will-navigate", (e, url) => {
@@ -3286,155 +3602,109 @@ function createViewManager(ctx) {
     });
     simulatorWebContentsId = simWc.id;
     ctx.networkForward?.attachSimulator(simWc);
-    reconcileNow();
-    attachNativeSimulatorDevtoolsHost();
+    reconciler.reconcileNow();
+    devtoolsHost.attach();
     return ready;
   }
+  function softReloadNativeSimulator(simulatorUrl) {
+    if (!nativeSimulatorView || nativeSimulatorView.webContents.isDestroyed()) return false;
+    if (!nativeSimulatorShellReady) return false;
+    const payload = { url: simulatorUrl };
+    nativeSimulatorView.webContents.send(SIMULATOR_EVENTS.RELAUNCH, payload);
+    return true;
+  }
   function detachSimulator() {
     settleNativeSimulatorReady?.();
     settleNativeSimulatorReady = null;
-    stopFollowingNativeServiceHost();
+    devtoolsHost.stopFollowing();
     detachNativeCustomApiBridge();
-    try {
-      stopElementsForward?.();
-    } catch {
-    }
-    stopElementsForward = null;
+    devtoolsHost.stopElementsForwarding();
     ctx.networkForward?.detachSimulator();
     ctx.networkForward?.setDevtoolsHost(null);
     tearDownNativeSimulatorView("close");
-    hidePopover();
-    destroyViewInternal(settingsView);
-    settingsView = null;
-    destroyViewInternal(simulatorView);
-    simulatorView = null;
-    simulatorViewAdded = false;
+    overlayPanels.hidePopover();
+    overlayPanels.destroySettings();
+    devtoolsHost.destroyHostView();
     simulatorWebContentsId = null;
     nativeSimulatorProjectPath = null;
   }
-  function removeSimulatorDevtoolsView() {
-    if (simulatorView && simulatorViewAdded) {
-      try {
-        ctx.windows.mainWindow.contentView.removeChildView(simulatorView);
-      } catch (e) {
-        console.error("[workbench] removeSimulatorDevtoolsView error", e);
-      }
-      simulatorViewAdded = false;
-    }
-  }
-  async function showSettings() {
-    if (!settingsView) {
-      settingsView = new WebContentsView2({
-        webPreferences: {
-          nodeIntegration: false,
-          contextIsolation: true,
-          sandbox: false,
-          preload: mainPreloadPath
-        }
-      });
-      applyNavigationHardening(settingsView.webContents, ctx.rendererDir);
-      settingsView.setBackgroundColor("#00000000");
-      await settingsView.webContents.loadFile(
-        path7.join(ctx.rendererDir, "entries/settings/index.html")
-      );
-    }
-    applySettingsBounds();
-  }
-  function hideSettings() {
-    overlayDesired.delete(VIEW_ID.settings);
-    reconcileNow();
-  }
-  function showPopover(data) {
-    hidePopover();
-    const popover = new WebContentsView2({
-      webPreferences: {
-        nodeIntegration: false,
-        contextIsolation: true,
-        sandbox: false,
-        preload: mainPreloadPath
-      }
-    });
-    applyNavigationHardening(popover.webContents, ctx.rendererDir);
-    popoverView = popover;
-    popover.setBackgroundColor("#00000000");
-    applyPopoverBounds();
-    popover.webContents.once("did-finish-load", () => {
-      ctx.notify.popoverInit(popover, data);
-    });
-    popover.webContents.loadFile(
-      path7.join(ctx.rendererDir, "entries/popover/index.html")
-    );
-  }
-  function hidePopover() {
-    if (!popoverView) return;
-    overlayDesired.delete(VIEW_ID.popover);
-    destroyViewInternal(popoverView);
-    popoverView = null;
-    reconcileNow();
-    ctx.notify.popoverClosed();
-  }
-  function repositionAll() {
-    if (overlayDesired.has(VIEW_ID.settings)) applySettingsBounds();
-    if (overlayDesired.has(VIEW_ID.popover)) applyPopoverBounds();
-  }
-  function disposeAll() {
-    detachSimulator();
-    detachWorkbench();
-    hostToolbarPort.dispose();
-    destroyViewInternal(hostToolbarView);
-    hostToolbarView = null;
-    hostToolbarViewAdded = false;
-    if (hostToolbarRuntimeAcquired) {
-      releaseHostToolbarSessionRuntime();
-      hostToolbarRuntimeAcquired = false;
-    }
-    safeArea.dispose();
-  }
-  function resize(_simWidth) {
-    if (overlayDesired.has(VIEW_ID.settings)) applySettingsBounds();
-  }
+  reconciler.registerView(VIEW_ID.simulator, {
+    getView: () => nativeSimulatorView,
+    setAdded: (added) => {
+      nativeSimulatorViewAdded = added;
+    },
+    gateHidden: () => !nativeSimulatorView,
+    applyBounds: (view, bounds, extra) => applyNativeSimulatorBounds(view, bounds, extra?.zoom ?? 1)
+  });
   return {
     attachNativeSimulator,
+    softReloadNativeSimulator,
     detachSimulator,
-    reapplySafeArea: (device) => safeArea.reapplyAll(device),
-    showSettings,
-    hideSettings,
-    showPopover,
-    hidePopover,
-    repositionAll,
-    disposeAll,
     getSimulatorWebContentsId: () => simulatorWebContentsId,
     getSimulatorWebContents: () => {
       if (simulatorWebContentsId == null) return null;
       const wc = webContents.fromId(simulatorWebContentsId);
       return wc && !wc.isDestroyed() ? wc : null;
     },
-    getSimulatorProjectPath: () => nativeSimulatorProjectPath,
-    getSettingsWebContents: () => {
-      if (!settingsView) return null;
-      if (settingsView.webContents.isDestroyed()) return null;
-      return settingsView.webContents;
-    },
-    getSettingsWebContentsId: () => {
-      if (!settingsView) return null;
-      if (settingsView.webContents.isDestroyed()) return null;
-      return settingsView.webContents.id;
-    },
-    getPopoverWebContentsId: () => {
-      if (!popoverView) return null;
-      if (popoverView.webContents.isDestroyed()) return null;
-      return popoverView.webContents.id;
-    },
-    getHostToolbarWebContentsId: () => liveHostToolbarWebContents()?.id ?? null,
-    getHostToolbarHeight: () => hostToolbarLastHeight,
-    resize,
-    setPlacementSnapshot,
-    attachWorkbench,
-    setWorkbenchSource,
-    detachWorkbench,
-    openFileInWorkbench,
-    setHostToolbarHeight,
-    hostToolbar
+    getSimulatorProjectPath: () => nativeSimulatorProjectPath
+  };
+}
+
+// src/main/services/views/view-manager.ts
+function createViewManager(ctx) {
+  const safeArea = createSafeAreaController({ connections: ctx.connections });
+  const reconciler = createPlacementReconciler(ctx);
+  const workbench = createWorkbenchView(ctx, reconciler);
+  const devtoolsHost = createDevtoolsHost(ctx, reconciler, {
+    openFileInWorkbench: workbench.openFileInWorkbench
+  });
+  const hostToolbar = createHostToolbarView(ctx, reconciler, {
+    reapplyPresentOverlays: () => reapplyToolbarDependentOverlays()
+  });
+  const overlayPanels = createOverlayPanelsView(ctx, reconciler, {
+    getHostToolbarHeight: hostToolbar.getHostToolbarHeight
+  });
+  const nativeSimulator = createNativeSimulatorView(ctx, reconciler, {
+    safeArea,
+    devtoolsHost,
+    overlayPanels
+  });
+  function reapplyToolbarDependentOverlays() {
+    overlayPanels.reapplyPresentOverlays();
+  }
+  function disposeAll() {
+    nativeSimulator.detachSimulator();
+    workbench.detachWorkbench();
+    hostToolbar.dispose();
+    safeArea.dispose();
+  }
+  return {
+    attachNativeSimulator: nativeSimulator.attachNativeSimulator,
+    softReloadNativeSimulator: nativeSimulator.softReloadNativeSimulator,
+    detachSimulator: nativeSimulator.detachSimulator,
+    reapplySafeArea: (device) => safeArea.reapplyAll(device),
+    showSettings: overlayPanels.showSettings,
+    hideSettings: overlayPanels.hideSettings,
+    showPopover: overlayPanels.showPopover,
+    hidePopover: overlayPanels.hidePopover,
+    repositionAll: () => overlayPanels.reapplyPresentOverlays(),
+    disposeAll,
+    getSimulatorWebContentsId: nativeSimulator.getSimulatorWebContentsId,
+    getSimulatorWebContents: nativeSimulator.getSimulatorWebContents,
+    getSimulatorProjectPath: nativeSimulator.getSimulatorProjectPath,
+    getSettingsWebContents: overlayPanels.getSettingsWebContents,
+    getSettingsWebContentsId: overlayPanels.getSettingsWebContentsId,
+    getPopoverWebContentsId: overlayPanels.getPopoverWebContentsId,
+    getHostToolbarWebContentsId: hostToolbar.getHostToolbarWebContentsId,
+    getHostToolbarHeight: hostToolbar.getHostToolbarHeight,
+    resize: () => overlayPanels.applySettingsBoundsIfPresent(),
+    setPlacementSnapshot: reconciler.setPlacementSnapshot,
+    attachWorkbench: workbench.attachWorkbench,
+    setWorkbenchSource: workbench.setWorkbenchSource,
+    detachWorkbench: workbench.detachWorkbench,
+    openFileInWorkbench: workbench.openFileInWorkbench,
+    setHostToolbarHeight: hostToolbar.setHostToolbarHeight,
+    hostToolbar: hostToolbar.control
   };
 }
 
@@ -3466,7 +3736,7 @@ function createWindowService(mainWindow) {
 
 // src/main/windows/settings-window/create.ts
 import { BrowserWindow as BrowserWindow3 } from "electron";
-import path8 from "path";
+import path9 from "path";
 async function createSettingsWindow(parent, rendererDir2) {
   const win = new BrowserWindow3({
     width: 420,
@@ -3484,7 +3754,7 @@ async function createSettingsWindow(parent, rendererDir2) {
     }
   });
   applyNavigationHardening(win.webContents, rendererDir2);
-  await win.loadFile(path8.join(rendererDir2, "entries/workbench-settings/index.html"));
+  await win.loadFile(path9.join(rendererDir2, "entries/workbench-settings/index.html"));
   return win;
 }
 
@@ -3535,11 +3805,11 @@ import { z as z2 } from "zod";
 
 // src/main/services/projects/project-repository.ts
 import { app as app6 } from "electron";
-import path9 from "path";
+import path10 from "path";
 import fs5 from "fs";
 var log2 = createLogger("projects");
 function getProjectsFile() {
-  return path9.join(app6.getPath("userData"), "dimina-projects.json");
+  return path10.join(app6.getPath("userData"), "dimina-projects.json");
 }
 function load() {
   try {
@@ -3561,13 +3831,13 @@ function validateProjectDir(dirPath) {
   if (!fs5.existsSync(dirPath)) {
     return `\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dirPath}`;
   }
-  if (!fs5.existsSync(path9.join(dirPath, "app.json"))) {
-    const configPath = path9.join(dirPath, "project.config.json");
+  if (!fs5.existsSync(path10.join(dirPath, "app.json"))) {
+    const configPath = path10.join(dirPath, "project.config.json");
     if (fs5.existsSync(configPath)) {
       try {
         const cfg = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
         if (cfg.miniprogramRoot) {
-          const resolvedRoot = path9.resolve(dirPath, cfg.miniprogramRoot);
+          const resolvedRoot = path10.resolve(dirPath, cfg.miniprogramRoot);
           return `\u8BE5\u76EE\u5F55\u7F3A\u5C11 app.json\uFF0Cproject.config.json \u4E2D\u6307\u5B9A\u4E86 miniprogramRoot: "${cfg.miniprogramRoot}"\uFF0C\u8BF7\u5BFC\u5165 ${resolvedRoot}`;
         }
       } catch (err) {
@@ -3580,9 +3850,9 @@ function validateProjectDir(dirPath) {
 }
 function addProject(dirPath) {
   const projects = load();
-  let name = path9.basename(dirPath);
+  let name = path10.basename(dirPath);
   try {
-    const configPath = path9.join(dirPath, "project.config.json");
+    const configPath = path10.join(dirPath, "project.config.json");
     if (fs5.existsSync(configPath)) {
       const cfg = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
       if (cfg.projectname) name = cfg.projectname;
@@ -3621,7 +3891,7 @@ function getCompileConfig(dirPath) {
   };
 }
 function getProjectPages(dirPath) {
-  const appJsonPath = path9.join(dirPath, "app.json");
+  const appJsonPath = path10.join(dirPath, "app.json");
   try {
     const appJson = JSON.parse(
       fs5.readFileSync(appJsonPath, "utf-8")
@@ -3647,7 +3917,7 @@ function getProjectSettings(projectPath) {
     return { uploadWithSourceMap: false };
   }
   try {
-    const configPath = path9.join(projectPath, "project.config.json");
+    const configPath = path10.join(projectPath, "project.config.json");
     const config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
     return {
       uploadWithSourceMap: !!config.setting?.uploadWithSourceMap
@@ -3658,7 +3928,7 @@ function getProjectSettings(projectPath) {
 }
 function updateProjectSettings(projectPath, patch) {
   if (!projectPath) return;
-  const configPath = path9.join(projectPath, "project.config.json");
+  const configPath = path10.join(projectPath, "project.config.json");
   let config = {};
   try {
     config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
@@ -3794,7 +4064,7 @@ function createWorkspaceService(ctx) {
         sourcemap: true,
         fileTypes: ctx.fileTypes,
         watch: compile.watch,
-        onRebuild: () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u70ED\u66F4\u65B0", true),
+        onRebuild: () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u91CD\u542F", true),
         onBuildError: (err) => sendStatus("error", String(err)),
         onLog: (entry) => {
           if (sessionGeneration !== logGeneration) return;
@@ -3963,16 +4233,16 @@ function createWorkspaceService(ctx) {
 // src/main/services/projects/thumbnail.ts
 import { createHash } from "crypto";
 import fs6 from "fs";
-import path10 from "path";
+import path11 from "path";
 import { app as app7 } from "electron";
 function getThumbnailDir() {
-  return path10.join(app7.getPath("userData"), "thumbnails");
+  return path11.join(app7.getPath("userData"), "thumbnails");
 }
 function hashProjectPath(projectPath) {
   return createHash("sha256").update(projectPath).digest("hex").slice(0, 16);
 }
 function getThumbnailPath(projectPath) {
-  return path10.join(getThumbnailDir(), `${hashProjectPath(projectPath)}.png`);
+  return path11.join(getThumbnailDir(), `${hashProjectPath(projectPath)}.png`);
 }
 var DATA_URL_PNG_PREFIX = "data:image/png;base64,";
 function saveThumbnailFromDataUrl(projectPath, imageDataUrl) {
@@ -4033,20 +4303,20 @@ function sanitizeTemplates(templates) {
 }
 
 // src/main/services/projects/builtin-templates.ts
-import path11 from "node:path";
-var TEMPLATES_DIR = path11.join(devtoolsPackageRoot, "templates");
+import path12 from "node:path";
+var TEMPLATES_DIR = path12.join(devtoolsPackageRoot, "templates");
 var BUILTIN_TEMPLATES = [
   {
     id: "blank",
     name: "Blank",
     description: "\u6700\u5C0F\u9AA8\u67B6\uFF1Aapp.* + \u4E00\u4E2A index \u9875\u9762",
-    source: { type: "directory", path: path11.join(TEMPLATES_DIR, "blank") }
+    source: { type: "directory", path: path12.join(TEMPLATES_DIR, "blank") }
   },
   {
     id: "taro-todo",
     name: "Taro Todo",
     description: "Taro \u7F16\u8BD1\u4EA7\u7269\u7684 Todo \u793A\u4F8B",
-    source: { type: "directory", path: path11.join(TEMPLATES_DIR, "taro-todo") }
+    source: { type: "directory", path: path12.join(TEMPLATES_DIR, "taro-todo") }
   }
 ];
 
@@ -4192,6 +4462,11 @@ var SimulatorAttachNativeSchema = z3.tuple([
   }),
   SimWidth
 ]);
+var SimulatorSoftReloadSchema = z3.tuple([
+  z3.string().url().refine((u) => u.startsWith("http://") || u.startsWith("https://"), {
+    message: "simulator URL must be http(s)"
+  })
+]);
 var SimulatorSetDeviceInfoSchema = z3.tuple([
   z3.object({
     brand: z3.string().max(64),
@@ -4283,79 +4558,14 @@ var SettingsProjectSettingsChangedSchema = z3.tuple([
 var ProjectCaptureThumbnailSchema = z3.tuple([AbsolutePath]);
 var ProjectGetThumbnailSchema = z3.tuple([AbsolutePath]);
 
-// src/shared/bridge-channels.ts
-var BRIDGE_CHANNELS = {
-  SPAWN: "dmb:spawn",
-  DISPOSE: "dmb:dispose",
-  PAGE_OPEN: "dmb:page:open",
-  PAGE_CLOSE: "dmb:page:close",
-  PAGE_LIFECYCLE: "dmb:page:lifecycle",
-  NAV_CALLBACK: "dmb:nav:callback",
-  SERVICE_INVOKE: "dmb:service:invoke",
-  SERVICE_PUBLISH: "dmb:service:publish",
-  RENDER_INVOKE: "dmb:render:invoke",
-  RENDER_PUBLISH: "dmb:render:publish",
-  TO_SERVICE: "dmb:to-service",
-  TO_RENDER: "dmb:to-render",
-  SIMULATOR_API: "dmb:simulator-api",
-  /** simulator → main: ack of an API_CALL request (carries success/fail args). */
-  API_RESPONSE: "dmb:api:response",
-  /**
-   * simulator webview preload → main (sendSync): "is native-host mode on?".
-   * The guest preload can't read the launch `process.env`, so it asks main
-   * (which can) at install time. Reply is `e.returnValue = boolean`.
-   */
-  NATIVE_HOST_ENABLED: "dmb:native-host-enabled",
-  /**
-   * simulator (DeviceShell) → main: the visible top-of-stack page bridgeId.
-   * Main has no z-order concept — the active page lives only in DeviceShell's
-   * ShellState — so devtools panels / automation that must target "the current
-   * page's render webContents" resolve it through this signal. Fire-and-forget.
-   */
-  ACTIVE_PAGE: "dmb:active-page",
-  /**
-   * simulator (DeviceShell) → main: the FULL ordered page stack (bottom→top)
-   * whenever it changes. Main has no stack of its own (it only learns the
-   * active bridgeId via ACTIVE_PAGE), so automation's `App.getPageStack` needs
-   * this to report multi-page stacks. Fire-and-forget.
-   */
-  PAGE_STACK: "dmb:page-stack"
-};
-var SIMULATOR_EVENTS = {
-  DOM_READY: "simulator:dom-ready",
-  NAV_BAR: "simulator:navigation-bar",
-  NAV_ACTION: "simulator:nav-action",
-  TAB_ACTION: "simulator:tab-action",
-  /** main → simulator: invoke a wx.* API on the simulator-resident MiniApp. */
-  API_CALL: "simulator:api-call",
-  /**
-   * main → simulator: the renderer toolbar picked a different device. Carries a
-   * NativeDeviceInfo; DeviceShell resizes the bezel + re-renders status bar /
-   * notch. The race-free INITIAL device rides NativeHostConfig.device (read
-   * synchronously at preload bridge-install); this event covers live changes.
-   */
-  DEVICE_CHANGE: "simulator:device-change"
-};
-function deviceInfoToHostEnv(d) {
-  return {
-    brand: d.brand,
-    model: d.model,
-    system: d.system,
-    platform: d.platform,
-    pixelRatio: d.pixelRatio,
-    screenWidth: d.screenWidth,
-    screenHeight: d.screenHeight,
-    windowWidth: d.screenWidth,
-    windowHeight: Math.max(0, d.screenHeight - d.statusBarHeight),
-    statusBarHeight: d.statusBarHeight
-  };
-}
-
 // src/main/ipc/simulator.ts
 function registerSimulatorIpc(ctx) {
   return new IpcRegistry(ctx.senderPolicy).handle(SimulatorChannel.AttachNative, (_, ...args) => {
     const [simulatorUrl, simWidth] = validate(SimulatorChannel.AttachNative, SimulatorAttachNativeSchema, args);
     return ctx.views.attachNativeSimulator(simulatorUrl, simWidth);
+  }).handle(SimulatorChannel.SoftReload, (_, ...args) => {
+    const [simulatorUrl] = validate(SimulatorChannel.SoftReload, SimulatorSoftReloadSchema, args);
+    return ctx.views.softReloadNativeSimulator(simulatorUrl);
   }).handle(SimulatorChannel.Detach, () => {
     ctx.views.detachSimulator();
   }).handle(SimulatorChannel.SetDeviceInfo, (_, ...args) => {
@@ -4391,11 +4601,11 @@ var popoverModule = {
 
 // src/main/ipc/projects.ts
 import { app as app8, dialog } from "electron";
-import path13 from "path";
+import path14 from "path";
 
 // src/main/services/projects/create-project-service.ts
 import fs7 from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 var DEFAULT_TEMPLATE_ID = "blank";
 async function createProject(input, ctx) {
   const name = (input.name ?? "").trim();
@@ -4442,7 +4652,7 @@ async function createProject(input, ctx) {
       force: true
     });
   }
-  const cfgPath = path12.join(target, "project.config.json");
+  const cfgPath = path13.join(target, "project.config.json");
   let cfg = {};
   if (fs7.existsSync(cfgPath)) {
     try {
@@ -4528,7 +4738,7 @@ function registerProjectsIpc(ctx) {
     }
     try {
       const settings = loadWorkbenchSettings();
-      const newBase = path13.dirname(input.path);
+      const newBase = path14.dirname(input.path);
       if (newBase && settings.lastCreateBaseDir !== newBase) {
         saveWorkbenchSettings({ ...settings, lastCreateBaseDir: newBase });
       }
@@ -4700,7 +4910,7 @@ import { DisposableRegistry as DisposableRegistry6 } from "@dimina-kit/electron-
 
 // src/main/ipc/bridge-router.ts
 import { app as app12, ipcMain as ipcMain3, protocol as protocol2, session as electronSession, webContents as webContents2 } from "electron";
-import path16 from "node:path";
+import path17 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/shared/simulator-api-metadata.ts
@@ -4709,13 +4919,40 @@ function isPersistentSimulatorApi(name) {
   return PERSISTENT_SIMULATOR_APIS.has(name);
 }
 
+// src/main/ipc/session-listener-bag.ts
+function createSessionListenerBag() {
+  const records = [];
+  let disposed = false;
+  return {
+    on(emitter, event, fn) {
+      if (disposed) return;
+      emitter.on(event, fn);
+      records.push({ emitter, event, fn });
+    },
+    once(emitter, event, fn) {
+      if (disposed) return;
+      emitter.once(event, fn);
+      records.push({ emitter, event, fn });
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const { emitter, event, fn } of records) {
+        if (emitter.isDestroyed?.()) continue;
+        emitter.removeListener(event, fn);
+      }
+      records.length = 0;
+    }
+  };
+}
+
 // src/main/ipc/bridge-router.ts
 import { createDebugTap } from "@dimina-kit/electron-deck/main";
 
 // src/main/services/dimina-resource-server.ts
 import http from "node:http";
 import fs8 from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 var MIME_TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -4731,7 +4968,7 @@ var MIME_TYPES = {
   ".wasm": "application/wasm"
 };
 async function startDiminaResourceServer(rootDir) {
-  const root = path14.resolve(rootDir);
+  const root = path15.resolve(rootDir);
   const server = http.createServer((req, res) => {
     void handleRequest(root, req, res);
   });
@@ -4779,7 +5016,7 @@ async function handleRequest(root, req, res) {
       return;
     }
     res.writeHead(200, {
-      "content-type": MIME_TYPES[path14.extname(filePath)] ?? "application/octet-stream",
+      "content-type": MIME_TYPES[path15.extname(filePath)] ?? "application/octet-stream",
       "content-length": stat.size,
       "cache-control": "no-store"
     });
@@ -4795,8 +5032,8 @@ async function handleRequest(root, req, res) {
 }
 function resolveContainedPath(root, pathname) {
   const relative = pathname.replace(/^\/+/, "") || "index.html";
-  const resolved = path14.resolve(root, relative);
-  if (resolved !== root && !resolved.startsWith(root + path14.sep)) return null;
+  const resolved = path15.resolve(root, relative);
+  if (resolved !== root && !resolved.startsWith(root + path15.sep)) return null;
   return resolved;
 }
 function setCorsHeaders(res) {
@@ -4808,11 +5045,11 @@ function setCorsHeaders(res) {
 
 // src/main/windows/service-host-window/create.ts
 import { app as app10, BrowserWindow as BrowserWindow4 } from "electron";
-import path15 from "node:path";
+import path16 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var SERVICE_HOST_PARTITION = SHARED_MINIAPP_PARTITION;
-var serviceHostPreloadPath = path15.join(devtoolsPackageRoot, "dist/service-host/preload.cjs");
-var serviceHostHtmlPath = path15.join(devtoolsPackageRoot, "dist/service-host/service.html");
+var serviceHostPreloadPath = path16.join(devtoolsPackageRoot, "dist/service-host/preload.cjs");
+var serviceHostHtmlPath = path16.join(devtoolsPackageRoot, "dist/service-host/service.html");
 function constructServiceHostWindow(opts = {}) {
   const partition = opts.partition ?? SERVICE_HOST_PARTITION;
   configureMiniappSession(partition);
@@ -5870,7 +6107,8 @@ function installBridgeRouter(ctx) {
   const state = {
     appSessions: /* @__PURE__ */ new Map(),
     pageSessions: /* @__PURE__ */ new Map(),
-    wcIdToAppSessionId: /* @__PURE__ */ new Map(),
+    serviceWcIdToAppSessionId: /* @__PURE__ */ new Map(),
+    simulatorWcIdToAppSessionIds: /* @__PURE__ */ new Map(),
     wcIdToBridgeId: /* @__PURE__ */ new Map(),
     pendingApiCalls: /* @__PURE__ */ new Map(),
     pool: null,
@@ -5902,8 +6140,8 @@ function installBridgeRouter(ctx) {
   const onNativeHostQuery = (event) => {
     const reply = {
       enabled: true,
-      renderHostHtmlUrl: pathToFileURL3(path16.join(devtoolsPackageRoot, "dist/render-host/pageFrame.html")).toString(),
-      renderPreloadUrl: pathToFileURL3(path16.join(devtoolsPackageRoot, "dist/render-host/preload.cjs")).toString(),
+      renderHostHtmlUrl: pathToFileURL3(path17.join(devtoolsPackageRoot, "dist/render-host/pageFrame.html")).toString(),
+      renderPreloadUrl: pathToFileURL3(path17.join(devtoolsPackageRoot, "dist/render-host/preload.cjs")).toString(),
       device: currentDevice ?? void 0
     };
     event.returnValue = reply;
@@ -5978,9 +6216,34 @@ function installBridgeRouter(ctx) {
       return Promise.all(ids.map((id) => disposeAppSession(state, id))).then(() => {
       });
     },
-    debugTap: state.debugTap
+    debugTap: state.debugTap,
+    census: () => {
+      const simulatorDestroyedListeners = {};
+      let simulatorWcBindings = 0;
+      for (const ids of state.simulatorWcIdToAppSessionIds.values()) simulatorWcBindings += ids.size;
+      for (const ap of state.appSessions.values()) {
+        const wc = ap.simulatorWc;
+        if (!wc.isDestroyed() && simulatorDestroyedListeners[wc.id] === void 0) {
+          simulatorDestroyedListeners[wc.id] = wc.listenerCount("destroyed");
+        }
+      }
+      return {
+        appSessions: state.appSessions.size,
+        pageSessions: state.pageSessions.size,
+        serviceWcBindings: state.serviceWcIdToAppSessionId.size,
+        simulatorWcs: state.simulatorWcIdToAppSessionIds.size,
+        simulatorWcBindings,
+        renderWcBindings: state.wcIdToBridgeId.size,
+        pendingApiCalls: state.pendingApiCalls.size,
+        simulatorDestroyedListeners
+      };
+    }
   };
   ctx.bridge = bridgeHandle;
+  if (process.env.NODE_ENV === "test") {
+    ;
+    globalThis.__diminaResourceCensus = () => bridgeHandle.census?.();
+  }
   const consoleForwarder = createConsoleForwarder(bridgeHandle);
   ctx.consoleForwarder = consoleForwarder;
   ctx.guestConsole = consoleForwarder;
@@ -5992,8 +6255,7 @@ function installBridgeRouter(ctx) {
   const onActivePage = (event, payload) => {
     const ap = state.appSessions.get(payload.appSessionId);
     if (!ap) return;
-    const senderApp = appByWc(state, event.sender);
-    if (!senderApp || senderApp.appSessionId !== ap.appSessionId) return;
+    if (!senderBoundToSession(state, event.sender, ap)) return;
     if (ap.pages.has(payload.bridgeId)) {
       ap.activeBridgeId = payload.bridgeId;
       const pagePath = state.pageSessions.get(payload.bridgeId)?.pagePath;
@@ -6007,8 +6269,7 @@ function installBridgeRouter(ctx) {
   const onPageStack = (event, payload) => {
     const ap = state.appSessions.get(payload.appSessionId);
     if (!ap) return;
-    const senderApp = appByWc(state, event.sender);
-    if (!senderApp || senderApp.appSessionId !== ap.appSessionId) return;
+    if (!senderBoundToSession(state, event.sender, ap)) return;
     ap.pageStack = payload.stack;
   };
   ipcMain3.on(BRIDGE_CHANNELS.PAGE_STACK, onPageStack);
@@ -6038,8 +6299,7 @@ function installBridgeRouter(ctx) {
     handlePageLifecycle(state, event.sender, payload);
     if (payload.event === "pageUnload" && ctx.appData) {
       const ap = state.appSessions.get(payload.appSessionId);
-      const senderApp = appByWc(state, event.sender);
-      if (ap && senderApp && senderApp.appSessionId === ap.appSessionId) {
+      if (ap && senderBoundToSession(state, event.sender, ap)) {
         ctx.appData.evictBridge(ap.appId, payload.bridgeId);
       }
     }
@@ -6058,9 +6318,8 @@ function installBridgeRouter(ctx) {
   const onDispose = (event, payload) => {
     const target = resolveAppByBridgeId(state, payload.bridgeId);
     if (!target) return;
-    const senderApp = appByWc(state, event.sender);
-    if (senderApp && senderApp.appSessionId !== target.appSessionId) {
-      console.warn(`[bridge-router] DISPOSE rejected: sender belongs to ${senderApp.appSessionId}, target ${target.appSessionId}`);
+    if (!senderBoundToSession(state, event.sender, target) && appByWc(state, event.sender)) {
+      console.warn(`[bridge-router] DISPOSE rejected: sender not bound to target ${target.appSessionId}`);
       return;
     }
     void disposeAppSession(state, target.appSessionId);
@@ -6159,7 +6418,7 @@ async function handleSpawn(state, ctx, event, opts) {
   const simulatorWc = resolveSimulatorWebContents(ctx, opts.simulatorWcId, event.sender);
   const pagePath = normalizePagePath(opts.pagePath || "pages/index/index");
   const workspaceProjectPath = typeof ctx.workspace.getProjectPath === "function" ? ctx.workspace.getProjectPath() : "";
-  const pkgRoot = path16.resolve(opts.pkgRoot || workspaceProjectPath || process.cwd());
+  const pkgRoot = path17.resolve(opts.pkgRoot || workspaceProjectPath || process.cwd());
   const root = opts.root || "main";
   const apiNamespaces = ctx.apiNamespaces ?? [];
   let resourceServer = null;
@@ -6167,7 +6426,7 @@ async function handleSpawn(state, ctx, event, opts) {
   if (opts.resourceBaseUrl) {
     resourceBaseUrl = opts.resourceBaseUrl.endsWith("/") ? opts.resourceBaseUrl : `${opts.resourceBaseUrl}/`;
   } else {
-    resourceServer = await startDiminaResourceServer(path16.resolve(pkgRoot, root));
+    resourceServer = await startDiminaResourceServer(path17.resolve(pkgRoot, root));
     resourceBaseUrl = resourceServer.baseUrl;
   }
   const selectedDevice = ctx.bridge?.getDevice?.() ?? null;
@@ -6226,8 +6485,8 @@ async function handleSpawn(state, ctx, event, opts) {
     pages: /* @__PURE__ */ new Map(),
     activeBridgeId: null,
     poolEntryId,
-    onServiceClosed: null,
     onServiceBoot: null,
+    listenerBag: createSessionListenerBag(),
     registryHandle: null
   };
   const rootPage = {
@@ -6246,23 +6505,22 @@ async function handleSpawn(state, ctx, event, opts) {
   state.appSessions.set(appSessionId, appSession);
   state.pageSessions.set(bridgeId, rootPage);
   appSession.pages.set(bridgeId, rootPage);
-  bindWc(state.wcIdToAppSessionId, serviceWindow.webContents, appSessionId);
-  bindWc(state.wcIdToAppSessionId, simulatorWc, appSessionId);
+  bindWc(state.serviceWcIdToAppSessionId, serviceWindow.webContents, appSessionId);
+  bindSimulatorWc(state.simulatorWcIdToAppSessionIds, simulatorWc, appSessionId);
   state.connections.acquire(serviceWindow.webContents).own(() => {
-    if (state.wcIdToAppSessionId.get(appSession.serviceWc.id) === appSessionId) {
-      state.wcIdToAppSessionId.delete(appSession.serviceWc.id);
+    if (state.serviceWcIdToAppSessionId.get(appSession.serviceWc.id) === appSessionId) {
+      state.serviceWcIdToAppSessionId.delete(appSession.serviceWc.id);
     }
   });
   appSession.registryHandle = ctx.registry.add(() => disposeAppSession(state, appSessionId));
   const onServiceClosed = () => {
     void disposeAppSession(state, appSessionId, { serviceAlreadyClosed: true });
   };
-  appSession.onServiceClosed = onServiceClosed;
-  serviceWindow.once("closed", onServiceClosed);
+  appSession.listenerBag.once(serviceWindow, "closed", onServiceClosed);
   const onSimulatorDestroyed = () => {
     void disposeAppSession(state, appSessionId);
   };
-  simulatorWc.once("destroyed", onSimulatorDestroyed);
+  appSession.listenerBag.once(simulatorWc, "destroyed", onSimulatorDestroyed);
   if (simulatorWc.isDestroyed()) {
     void disposeAppSession(state, appSessionId);
   }
@@ -6310,8 +6568,7 @@ async function handleSpawn(state, ctx, event, opts) {
 async function handlePageOpen(state, event, opts) {
   const ap = state.appSessions.get(opts.appSessionId);
   if (!ap) throw new Error(`[bridge-router] PAGE_OPEN unknown appSession ${opts.appSessionId}`);
-  const senderApp = appByWc(state, event.sender);
-  if (!senderApp || senderApp.appSessionId !== opts.appSessionId) {
+  if (!senderBoundToSession(state, event.sender, ap)) {
     throw new Error("[bridge-router] PAGE_OPEN rejected: caller not bound to app session");
   }
   const pagePath = normalizePagePath(opts.pagePath);
@@ -6344,8 +6601,7 @@ function handlePageClose(state, sender, payload) {
   }
   const ap = state.appSessions.get(page.appSessionId);
   if (!ap) return;
-  const senderApp = appByWc(state, sender);
-  if (!senderApp || senderApp.appSessionId !== ap.appSessionId) {
+  if (!senderBoundToSession(state, sender, ap)) {
     console.warn("[bridge-router] PAGE_CLOSE rejected: caller not bound to app session");
     return;
   }
@@ -6354,8 +6610,7 @@ function handlePageClose(state, sender, payload) {
 function handlePageLifecycle(state, sender, payload) {
   const ap = state.appSessions.get(payload.appSessionId);
   if (!ap) return;
-  const senderApp = appByWc(state, sender);
-  if (!senderApp || senderApp.appSessionId !== ap.appSessionId) return;
+  if (!senderBoundToSession(state, sender, ap)) return;
   forwardToService(ap, {
     type: payload.event,
     target: "service",
@@ -6365,8 +6620,7 @@ function handlePageLifecycle(state, sender, payload) {
 function handleNavCallback(state, sender, payload) {
   const ap = state.appSessions.get(payload.appSessionId);
   if (!ap) return;
-  const senderApp = appByWc(state, sender);
-  if (!senderApp || senderApp.appSessionId !== ap.appSessionId) return;
+  if (!senderBoundToSession(state, sender, ap)) return;
   const result = { errMsg: payload.errMsg };
   if (payload.ok) {
     sendCallback(ap, payload.callbacks.success, result);
@@ -6382,18 +6636,23 @@ async function bootServiceHost(state, ap, ctx) {
     reportLogicLoadFailure(ap, ctx);
     return;
   }
-  forwardToService(ap, makeLoadResource(ap, ap.pages.get(ap.appSessionId), "service"));
+  const rootPage = ap.pages.get(ap.appSessionId);
+  const rootMissing = !!rootPage && !pageInManifest(ap, rootPage.pagePath);
+  if (rootMissing) {
+    reportPageNotFound(ap, ctx, rootPage.pagePath);
+  } else if (rootPage) {
+    forwardToService(ap, makeLoadResource(ap, rootPage, "service"));
+  }
   for (const page of ap.pages.values()) {
-    if (page.renderLoadPending) {
-      page.renderLoadPending = false;
-      sendRenderLoadResource(ap, page);
-    }
+    if (!page.renderLoadPending) continue;
+    page.renderLoadPending = false;
+    sendRenderLoadResource(ap, page);
   }
 }
 function sendRenderLoadResource(ap, page) {
-  if (page.renderWc && !page.renderWc.isDestroyed()) {
-    page.renderWc.send(BRIDGE_CHANNELS.TO_RENDER, { msg: makeLoadResource(ap, page, "render") });
-  }
+  if (!page.renderWc || page.renderWc.isDestroyed()) return;
+  if (!pageInManifest(ap, page.pagePath)) return;
+  page.renderWc.send(BRIDGE_CHANNELS.TO_RENDER, { msg: makeLoadResource(ap, page, "render") });
 }
 function logicBundleUrl(ap) {
   return ap.resourceServer ? new URL("logic.js", ap.resourceBaseUrl).toString() : new URL(`${ap.appId}/${ap.root}/logic.js`, ap.resourceBaseUrl).toString();
@@ -6418,6 +6677,14 @@ function reportLogicLoadFailure(ap, ctx) {
   console.error(message);
   ctx.guestConsole?.emit({ source: "service", level: "error", args: [message] });
 }
+function pageInManifest(ap, pagePath) {
+  return ap.manifest.pages.includes(normalizePagePath(pagePath));
+}
+function reportPageNotFound(ap, ctx, pagePath) {
+  const message = `Page[${pagePath}] not found. May be caused by: 1. Forgetting to add page route in app.json. 2. Invoking Page() in async task.`;
+  console.error(`[bridge-router] ${message}`);
+  ctx.guestConsole?.emit({ source: "service", level: "error", args: [message] });
+}
 function maybeSendResourceLoaded(ap, page) {
   if (page.resourceLoadedSent || !ap.serviceLoaded || !page.renderLoaded) return;
   page.resourceLoadedSent = true;
@@ -6723,8 +6990,7 @@ function handleApiResponse(state, sender, payload) {
     clearTimeout(pending.timer);
     return;
   }
-  const senderApp = appByWc(state, sender);
-  if (!senderApp || senderApp.appSessionId !== ap.appSessionId) {
+  if (!senderBoundToSession(state, sender, ap)) {
     console.warn("[bridge-router] API_RESPONSE rejected: sender not bound to app session");
     return;
   }
@@ -6829,8 +7095,14 @@ function pageFromMsg(state, ap, msg) {
 }
 function appByWc(state, wc) {
   if (wc.isDestroyed()) return void 0;
-  const appSessionId = state.wcIdToAppSessionId.get(wc.id);
+  const appSessionId = state.serviceWcIdToAppSessionId.get(wc.id);
   if (appSessionId) return state.appSessions.get(appSessionId);
+  const hosted = state.simulatorWcIdToAppSessionIds.get(wc.id);
+  if (hosted) {
+    let latest;
+    for (const id of hosted) latest = state.appSessions.get(id) ?? latest;
+    if (latest) return latest;
+  }
   const bridgeId = state.wcIdToBridgeId.get(wc.id);
   if (bridgeId) {
     const page = state.pageSessions.get(bridgeId);
@@ -6838,6 +7110,12 @@ function appByWc(state, wc) {
   }
   return void 0;
 }
+function senderBoundToSession(state, sender, ap) {
+  if (sender.isDestroyed()) return false;
+  const hosted = state.simulatorWcIdToAppSessionIds.get(sender.id);
+  if (hosted) return hosted.has(ap.appSessionId);
+  return appByWc(state, sender)?.appSessionId === ap.appSessionId;
+}
 function resolveAppByBridgeId(state, bridgeId) {
   if (state.appSessions.has(bridgeId)) return state.appSessions.get(bridgeId);
   const page = state.pageSessions.get(bridgeId);
@@ -6848,6 +7126,15 @@ function bindWc(map, wc, id) {
   if (wc.isDestroyed()) return;
   map.set(wc.id, id);
 }
+function bindSimulatorWc(map, wc, id) {
+  if (wc.isDestroyed()) return;
+  let hosted = map.get(wc.id);
+  if (!hosted) {
+    hosted = /* @__PURE__ */ new Set();
+    map.set(wc.id, hosted);
+  }
+  hosted.add(id);
+}
 function readBridgeId(msg) {
   return typeof msg.body?.bridgeId === "string" ? msg.body.bridgeId : void 0;
 }
@@ -6890,11 +7177,9 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
     state.pageSessions.delete(page.bridgeId);
   }
   ap.pages.clear();
+  ap.listenerBag.dispose();
   if (ap.poolEntryId !== null && state.pool && !opts.serviceAlreadyClosed) {
     state.connections.reset(ap.serviceWc.id);
-    if (ap.onServiceClosed && !ap.serviceWindow.isDestroyed()) {
-      ap.serviceWindow.removeListener("closed", ap.onServiceClosed);
-    }
     if (ap.onServiceBoot && !ap.serviceWindow.isDestroyed()) {
       ap.serviceWindow.webContents.removeListener("did-finish-load", ap.onServiceBoot);
     }
@@ -6906,8 +7191,14 @@ async function disposeAppSession(state, appSessionId, opts = {}) {
   } else if (!opts.serviceAlreadyClosed && !ap.serviceWindow.isDestroyed()) {
     ap.serviceWindow.close();
   }
-  state.wcIdToAppSessionId.delete(ap.serviceWc.id);
-  state.wcIdToAppSessionId.delete(ap.simulatorWc.id);
+  if (state.serviceWcIdToAppSessionId.get(ap.serviceWc.id) === appSessionId) {
+    state.serviceWcIdToAppSessionId.delete(ap.serviceWc.id);
+  }
+  const hosted = state.simulatorWcIdToAppSessionIds.get(ap.simulatorWc.id);
+  if (hosted) {
+    hosted.delete(appSessionId);
+    if (hosted.size === 0) state.simulatorWcIdToAppSessionIds.delete(ap.simulatorWc.id);
+  }
   if (ap.resourceServer) {
     await ap.resourceServer.close().catch((error) => {
       console.warn("[bridge-router] resource server close failed:", error);
@@ -8625,6 +8916,11 @@ function createNetworkForwarder(bridge) {
       trimQueue();
       return;
     }
+    if (!isFrontendSettled(wc)) {
+      trimQueue();
+      scheduleReadyRetry();
+      return;
+    }
     if (sink === "idle") beginProbing();
     const batch = [];
     let batchChars = 0;
@@ -9225,7 +9521,7 @@ function setupSimulatorCurrentPage(host, options) {
 
 // src/main/services/render-inspect/index.ts
 import { readFileSync } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 var DEFAULT_SOURCE_PATH = "dist/render-host/render-inspect.js";
 var HIGHLIGHT_CONFIG = {
   showInfo: true,
@@ -9251,7 +9547,7 @@ function withTimeout(p, ms) {
   });
 }
 function createRenderInspector(options = {}) {
-  const loadSource = options.loadSource ?? (() => readFileSync(path17.join(devtoolsPackageRoot, DEFAULT_SOURCE_PATH), "utf8"));
+  const loadSource = options.loadSource ?? (() => readFileSync(path18.join(devtoolsPackageRoot, DEFAULT_SOURCE_PATH), "utf8"));
   let cachedSource = null;
   const injected = /* @__PURE__ */ new Set();
   const selfAttached = /* @__PURE__ */ new Set();
@@ -9414,13 +9710,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, path23, mime, bytes) {
+function registerTempFile(store, path24, mime, bytes) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-  store.delete(path23);
-  store.set(path23, { bytes: buf, mime });
+  store.delete(path24);
+  store.set(path24, { bytes: buf, mime });
 }
-function revokeTempFile(store, path23) {
-  store.delete(path23);
+function revokeTempFile(store, path24) {
+  store.delete(path24);
 }
 function revokeAllTempFiles(store) {
   store.clear();
@@ -9428,14 +9724,14 @@ function revokeAllTempFiles(store) {
 
 // src/shared/vpath.ts
 import os from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 var DIFILE_PREFIX = "difile://";
 function sandboxBase() {
   const env = typeof process !== "undefined" && process.env && process.env.DIMINA_HOME || "";
   if (env) {
-    return path18.join(env, "files");
+    return path19.join(env, "files");
   }
-  return path18.join(os.homedir(), ".dimina", "files");
+  return path19.join(os.homedir(), ".dimina", "files");
 }
 function resolveVPath(url) {
   if (typeof url !== "string") return null;
@@ -9469,15 +9765,15 @@ function resolveVPath(url) {
     return { kind, writable };
   }
   const base = sandboxBase();
-  const joined = path18.join(base, decoded);
-  const normalized = path18.normalize(joined);
-  if (normalized !== base && !normalized.startsWith(base + path18.sep)) return null;
+  const joined = path19.join(base, decoded);
+  const normalized = path19.normalize(joined);
+  if (normalized !== base && !normalized.startsWith(base + path19.sep)) return null;
   return { kind, writable, realPath: normalized };
 }
 
 // src/main/services/simulator-temp-files/disk.ts
 import fs9 from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 var EXT_MIME = {
   ".txt": "text/plain",
   ".log": "text/plain",
@@ -9542,7 +9838,7 @@ function sniffMime(head) {
   return null;
 }
 function extMime(realPath) {
-  const ext = path19.extname(realPath).toLowerCase();
+  const ext = path20.extname(realPath).toLowerCase();
   if (!ext) return null;
   return EXT_MIME[ext] ?? null;
 }
@@ -9612,7 +9908,7 @@ async function readDiskFile(realPath, opts) {
 }
 async function writeDiskFile(realPath, bytes) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-  await fs9.mkdir(path19.dirname(realPath), { recursive: true });
+  await fs9.mkdir(path20.dirname(realPath), { recursive: true });
   await fs9.writeFile(realPath, buf);
 }
 async function readDiskDir(realPath) {
@@ -9754,28 +10050,28 @@ async function handleDifileRequest(ctx, req) {
 
 // src/main/services/simulator-temp-files/fs-channels.ts
 import fs10 from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 async function enforceSandbox(realPath) {
   if (typeof realPath !== "string" || realPath.length === 0) {
     throw new Error("sandbox: realPath must be a non-empty string");
   }
   const base = sandboxBase();
   const baseReal = await fs10.realpath(base).catch(() => base);
-  const normalized = path20.normalize(realPath);
-  if (normalized !== base && !normalized.startsWith(base + path20.sep)) {
+  const normalized = path21.normalize(realPath);
+  if (normalized !== base && !normalized.startsWith(base + path21.sep)) {
     throw new Error("sandbox: realPath escapes the user-data base");
   }
   let probe = normalized;
-  while (probe !== path20.parse(probe).root) {
+  while (probe !== path21.parse(probe).root) {
     try {
       const resolved = await fs10.realpath(probe);
-      if (resolved !== baseReal && !resolved.startsWith(baseReal + path20.sep)) {
+      if (resolved !== baseReal && !resolved.startsWith(baseReal + path21.sep)) {
         throw new Error("sandbox: realPath escapes the user-data base via symlink");
       }
       break;
     } catch (err) {
       if (err.code === "ENOENT") {
-        probe = path20.dirname(probe);
+        probe = path21.dirname(probe);
         continue;
       }
       throw err;
@@ -9831,10 +10127,10 @@ function setupSimulatorTempFiles(simSession) {
   const store = /* @__PURE__ */ new Map();
   const pendingWaiters = /* @__PURE__ */ new Map();
   let disposed = false;
-  function drainWaiters(path23) {
-    const list = pendingWaiters.get(path23);
+  function drainWaiters(path24) {
+    const list = pendingWaiters.get(path24);
     if (!list) return;
-    pendingWaiters.delete(path23);
+    pendingWaiters.delete(path24);
     for (const fn of list) fn();
   }
   function drainAllWaiters() {
@@ -9847,15 +10143,15 @@ function setupSimulatorTempFiles(simSession) {
   const registry = new IpcRegistry(simulatorOnlyPolicy);
   registry.on("simulator:temp-file:write", (_event, payload) => {
     if (disposed) return;
-    const { path: path23, mime, bytes } = payload;
-    registerTempFile(store, path23, mime, bytes);
+    const { path: path24, mime, bytes } = payload;
+    registerTempFile(store, path24, mime, bytes);
     enforceStoreCap(store);
-    drainWaiters(path23);
+    drainWaiters(path24);
   });
   registry.on("simulator:temp-file:revoke", (_event, payload) => {
     if (disposed) return;
-    const { path: path23 } = payload;
-    revokeTempFile(store, path23);
+    const { path: path24 } = payload;
+    revokeTempFile(store, path24);
   });
   registry.on("simulator:temp-file:revoke-all", () => {
     if (disposed) return;
@@ -9993,7 +10289,7 @@ function setupSimulatorSessionPolicy() {
 import http2 from "node:http";
 import nodeFs2 from "node:fs";
 import fs11 from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 var MAX_FS_WRITE_BYTES = 32 * 1024 * 1024;
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -10017,8 +10313,8 @@ function setIsolationHeaders(res) {
 }
 function containedStaticPath(root, pathname) {
   const rel = pathname.replace(/^\/+/, "") || "index.html";
-  const resolved = path21.resolve(root, rel);
-  if (resolved !== root && !resolved.startsWith(root + path21.sep)) return null;
+  const resolved = path22.resolve(root, rel);
+  if (resolved !== root && !resolved.startsWith(root + path22.sep)) return null;
   return resolved;
 }
 function serveStaticFile(res, root, pathname) {
@@ -10029,7 +10325,7 @@ function serveStaticFile(res, root, pathname) {
     return;
   }
   Promise.all([fs11.realpath(root), fs11.realpath(candidate)]).then(([realRoot, realFile]) => {
-    if (realFile !== realRoot && !realFile.startsWith(realRoot + path21.sep)) {
+    if (realFile !== realRoot && !realFile.startsWith(realRoot + path22.sep)) {
       res.writeHead(403);
       res.end("Forbidden");
       return;
@@ -10041,7 +10337,7 @@ function serveStaticFile(res, root, pathname) {
         return;
       }
       res.writeHead(200, {
-        "Content-Type": MIME[path21.extname(realFile)] ?? "application/octet-stream",
+        "Content-Type": MIME[path22.extname(realFile)] ?? "application/octet-stream",
         "Content-Length": stat.size,
         "Cache-Control": "no-store"
       });
@@ -10183,7 +10479,7 @@ async function listFilesRecursive(dir, base = "") {
   for (const e of entries) {
     const rel = base ? `${base}/${e.name}` : e.name;
     if (e.isDirectory()) {
-      out.push(...await listFilesRecursive(path21.join(dir, e.name), rel));
+      out.push(...await listFilesRecursive(path22.join(dir, e.name), rel));
     } else if (e.isFile()) {
       out.push(rel);
     }
@@ -10200,9 +10496,9 @@ async function readContributedExtensions(extensionsDir) {
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const extDir = path21.join(extensionsDir, e.name);
+    const extDir = path22.join(extensionsDir, e.name);
     try {
-      const pkgRaw = await fs11.readFile(path21.join(extDir, "package.json"), "utf8");
+      const pkgRaw = await fs11.readFile(path22.join(extDir, "package.json"), "utf8");
       const files = await listFilesRecursive(extDir);
       out.push({ dir: e.name, packageJson: JSON.parse(pkgRaw), files });
     } catch {
@@ -10211,8 +10507,8 @@ async function readContributedExtensions(extensionsDir) {
   return out;
 }
 async function startWorkbenchCoiServer(options) {
-  const root = path21.resolve(options.rootDir);
-  const contribRoot = options.extensionsDir ? path21.resolve(options.extensionsDir) : null;
+  const root = path22.resolve(options.rootDir);
+  const contribRoot = options.extensionsDir ? path22.resolve(options.extensionsDir) : null;
   const server = http2.createServer((req, res) => {
     setIsolationHeaders(res);
     const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -10430,7 +10726,7 @@ async function disposeContext(ctx) {
 function createConfiguredMainWindow(config, rendererDir2) {
   const mainWindow = createMainWindow({
     title: config.appName ?? "Dimina DevTools",
-    indexHtml: path22.join(rendererDir2, "entries/main/index.html"),
+    indexHtml: path23.join(rendererDir2, "entries/main/index.html"),
     width: config.window?.width,
     height: config.window?.height,
     minWidth: config.window?.minWidth,
@@ -10725,8 +11021,8 @@ async function createDevtoolsRuntime(config = {}) {
       bridge: context.bridge
     }));
   }
-  const bundleDir = config.editorViewConfig?.bundleDir ?? path22.join(devtoolsPackageRoot, "dist/vscode-workbench");
-  if (!fs12.existsSync(path22.join(bundleDir, "index.html"))) {
+  const bundleDir = config.editorViewConfig?.bundleDir ?? path23.join(devtoolsPackageRoot, "dist/vscode-workbench");
+  if (!fs12.existsSync(path23.join(bundleDir, "index.html"))) {
     console.warn(
       `[workbench] editor bundle not found at ${bundleDir} \u2014 skipping embedded editor assembly`
     );