@dimina-kit/devtools 0.3.1 → 0.3.2-dev.20260522085907

package/dist/main/index.bundle.js

@@ -1,6 +1,10 @@
 // src/main/app/bootstrap.ts
 import { app as app2 } from "electron";
 
+// src/shared/constants.ts
+var DEFAULT_CDP_PORT = 9222;
+var DEFAULT_SCENE = 1001;
+
 // src/main/services/settings/index.ts
 import { app, nativeTheme } from "electron";
 import fs from "fs";
@@ -8,13 +12,17 @@ import path from "path";
 var DEFAULTS = {
   cdp: {
     enabled: false,
-    port: 9222
+    port: DEFAULT_CDP_PORT
   },
   mcp: {
     enabled: false,
     port: 7789
   },
-  theme: "system"
+  compile: {
+    watch: true
+  },
+  theme: "system",
+  lastCreateBaseDir: null
 };
 function getSettingsFile() {
   return path.join(app.getPath("userData"), "dimina-workbench-settings.json");
@@ -32,10 +40,19 @@ function loadWorkbenchSettings() {
         enabled: data.mcp?.enabled ?? DEFAULTS.mcp.enabled,
         port: data.mcp?.port ?? DEFAULTS.mcp.port
       },
-      theme
+      compile: {
+        watch: data.compile?.watch ?? DEFAULTS.compile.watch
+      },
+      theme,
+      lastCreateBaseDir: typeof data.lastCreateBaseDir === "string" ? data.lastCreateBaseDir : DEFAULTS.lastCreateBaseDir
     };
   } catch {
-    return { ...DEFAULTS, cdp: { ...DEFAULTS.cdp }, mcp: { ...DEFAULTS.mcp } };
+    return {
+      ...DEFAULTS,
+      cdp: { ...DEFAULTS.cdp },
+      mcp: { ...DEFAULTS.mcp },
+      compile: { ...DEFAULTS.compile }
+    };
   }
 }
 function saveWorkbenchSettings(settings) {
@@ -57,14 +74,14 @@ function setupCdpPort() {
   if (settings.cdp.enabled || settings.mcp.enabled) {
     app2.commandLine.appendSwitch("remote-debugging-port", String(settings.cdp.port));
   } else if (!app2.isPackaged) {
-    app2.commandLine.appendSwitch("remote-debugging-port", String(settings.cdp.port || 9222));
+    app2.commandLine.appendSwitch("remote-debugging-port", String(settings.cdp.port || DEFAULT_CDP_PORT));
   }
 }
 
 // src/main/app/app.ts
-import { app as app11, BrowserWindow as BrowserWindow3, nativeImage } from "electron";
-import fs5 from "fs";
-import path6 from "path";
+import { app as app13, BrowserWindow as BrowserWindow4, nativeImage } from "electron";
+import fs7 from "fs";
+import path12 from "path";
 
 // src/main/utils/paths.ts
 import fs2 from "fs";
@@ -87,8 +104,86 @@ function resolveDevtoolsPackageRoot() {
 var devtoolsPackageRoot = resolveDevtoolsPackageRoot();
 var rendererDir = path2.join(devtoolsPackageRoot, "dist/renderer");
 var defaultPreloadPath = path2.join(devtoolsPackageRoot, "dist/preload/windows/simulator.js");
+var mainPreloadPath = path2.join(devtoolsPackageRoot, "dist/preload/windows/main.cjs");
 var simulatorDir = path2.join(devtoolsPackageRoot, "dist/simulator");
 
+// src/main/utils/theme.ts
+import { BrowserWindow, nativeTheme as nativeTheme2 } from "electron";
+
+// src/main/utils/disposable.ts
+function toDisposable(fn) {
+  let done = false;
+  return {
+    dispose() {
+      if (done) return;
+      done = true;
+      return fn();
+    }
+  };
+}
+var DisposableRegistry = class {
+  entries = [];
+  _disposed = false;
+  add(d) {
+    if (this._disposed) {
+      throw new Error("cannot add to disposed registry");
+    }
+    const fn = typeof d === "function" ? d : () => d.dispose();
+    const entry = { fn, released: false };
+    this.entries.push(entry);
+    return {
+      dispose: () => {
+        if (entry.released) return;
+        entry.released = true;
+        const i = this.entries.indexOf(entry);
+        if (i >= 0) this.entries.splice(i, 1);
+        return fn();
+      }
+    };
+  }
+  async disposeAll() {
+    if (this._disposed) return;
+    this._disposed = true;
+    const items = this.entries.slice().reverse();
+    this.entries = [];
+    const errors = [];
+    for (const entry of items) {
+      if (entry.released) continue;
+      entry.released = true;
+      try {
+        await entry.fn();
+      } catch (e) {
+        errors.push(e);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "DisposableRegistry encountered errors during disposeAll");
+    }
+  }
+  dispose() {
+    return this.disposeAll();
+  }
+};
+
+// src/main/utils/theme.ts
+function themeBg() {
+  return nativeTheme2.shouldUseDarkColors ? "#1a1a1a" : "#fafafa";
+}
+function installThemeBackgroundSync() {
+  const apply = () => {
+    const bg = themeBg();
+    for (const win of BrowserWindow.getAllWindows()) {
+      if (!win.isDestroyed()) {
+        win.setBackgroundColor(bg);
+      }
+    }
+  };
+  nativeTheme2.on("updated", apply);
+  return toDisposable(() => {
+    nativeTheme2.removeListener("updated", apply);
+  });
+}
+
 // src/main/app/lifecycle.ts
 import { app as app3, globalShortcut } from "electron";
 function registerAppLifecycle() {
@@ -102,7 +197,8 @@ function registerAppLifecycle() {
 }
 
 // src/main/windows/main-window/create.ts
-import { app as app4, BrowserWindow, View, globalShortcut as globalShortcut2, session } from "electron";
+import { app as app4, BrowserWindow as BrowserWindow2, View, session, shell as shell2 } from "electron";
+import path4 from "path";
 
 // src/main/services/simulator/referer.ts
 var DEFAULT_VERSION = "develop";
@@ -123,18 +219,51 @@ function getSimulatorServicewechatReferer() {
   return cachedRefererUrl;
 }
 
-// src/main/utils/theme.ts
-import { nativeTheme as nativeTheme2 } from "electron";
-function themeBg() {
-  return nativeTheme2.shouldUseDarkColors ? "#1a1a1a" : "#fafafa";
+// src/main/windows/navigation-hardening.ts
+import { shell } from "electron";
+import path3 from "path";
+import { pathToFileURL } from "url";
+function handleWindowOpenExternal(url) {
+  try {
+    const u = new URL(url);
+    if (u.protocol === "http:" || u.protocol === "https:") {
+      void shell.openExternal(url);
+    }
+  } catch {
+  }
+  return { action: "deny" };
+}
+function applyNavigationHardening(wc, rendererDir2) {
+  const rendererPrefix = pathToFileURL(rendererDir2 + path3.sep).href;
+  wc.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
+  wc.on("will-navigate", (event, url) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      event.preventDefault();
+      return;
+    }
+    if (parsed.protocol === "file:" && parsed.href.startsWith(rendererPrefix)) {
+      return;
+    }
+    event.preventDefault();
+    if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+      void shell.openExternal(url);
+    }
+  });
 }
 
 // src/main/windows/main-window/create.ts
 var simulatorSessionConfigured = false;
-function configureSimulatorSession() {
+function configureSimulatorSession(simulatorPreloadPath) {
   if (simulatorSessionConfigured) return;
   simulatorSessionConfigured = true;
   const simulatorSession = session.fromPartition("persist:simulator");
+  simulatorSession.registerPreloadScript({
+    type: "frame",
+    filePath: simulatorPreloadPath
+  });
   simulatorSession.webRequest.onBeforeSendHeaders((details, callback) => {
     const forcedReferer = getSimulatorServicewechatReferer();
     if (forcedReferer) {
@@ -148,13 +277,13 @@ function configureSimulatorSession() {
     headers["access-control-allow-headers"] = ["*"];
     headers["access-control-allow-methods"] = ["*"];
     headers["Cross-Origin-Opener-Policy"] = ["same-origin"];
-    headers["Cross-Origin-Embedder-Policy"] = ["require-corp"];
+    headers["Cross-Origin-Embedder-Policy"] = ["credentialless"];
     callback({ responseHeaders: headers });
   });
 }
 function createMainWindow(opts) {
-  configureSimulatorSession();
-  const mainWindow = new BrowserWindow({
+  configureSimulatorSession(opts.simulatorPreloadPath);
+  const mainWindow = new BrowserWindow2({
     width: opts.width ?? 1280,
     height: opts.height ?? 980,
     minWidth: opts.minWidth ?? 1e3,
@@ -163,8 +292,13 @@ function createMainWindow(opts) {
     show: false,
     backgroundColor: themeBg(),
     webPreferences: {
-      nodeIntegration: true,
-      contextIsolation: false,
+      nodeIntegration: false,
+      contextIsolation: true,
+      // `sandbox: false` is required so the preload bundle can `require('electron')`
+      // to access contextBridge/ipcRenderer. The renderer itself runs isolated.
+      sandbox: false,
+      preload: mainPreloadPath,
+      // The simulator <webview> still relies on the webview tag; keep it enabled.
       webviewTag: true
     }
   });
@@ -178,22 +312,45 @@ function createMainWindow(opts) {
       }
     }
   });
-  mainWindow.webContents.on("will-attach-webview", (_event, webPreferences) => {
+  const rendererDir2 = path4.dirname(opts.indexHtml);
+  applyNavigationHardening(mainWindow.webContents, rendererDir2);
+  mainWindow.webContents.on("will-attach-webview", (event, webPreferences, params) => {
+    ;
+    webPreferences.partition = "persist:simulator";
+    params.partition = "persist:simulator";
     webPreferences.contextIsolation = false;
+    void event;
+  });
+  mainWindow.webContents.on("did-attach-webview", (_event, webviewWebContents) => {
+    webviewWebContents.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
+    webviewWebContents.on("will-navigate", (e, url) => {
+      try {
+        const u = new URL(url);
+        if (u.protocol === "about:") return;
+        if ((u.protocol === "http:" || u.protocol === "https:") && (u.hostname === "localhost" || u.hostname === "127.0.0.1")) {
+          return;
+        }
+        e.preventDefault();
+        if (u.protocol === "http:" || u.protocol === "https:") {
+          void shell2.openExternal(url);
+        }
+      } catch {
+        e.preventDefault();
+      }
+    });
   });
   mainWindow.loadFile(opts.indexHtml);
   const container = new View();
   const mainWebView = mainWindow.contentView;
   container.addChildView(mainWebView);
   mainWindow.contentView = container;
-  globalShortcut2.register("CommandOrControl+Shift+I", () => {
-    mainWindow.webContents.openDevTools({ mode: "detach" });
-  });
   return mainWindow;
 }
 
 // src/main/windows/main-window/events.ts
+import { globalShortcut as globalShortcut2 } from "electron";
 function wireMainWindowEvents(win, state = {}) {
+  const registry = new DisposableRegistry();
   const mainWebView = win.contentView.children[0];
   const resizeMainWebView = () => {
     if (mainWebView) {
@@ -204,25 +361,56 @@ function wireMainWindowEvents(win, state = {}) {
   };
   resizeMainWebView();
   win.on("resize", resizeMainWebView);
+  registry.add(toDisposable(() => {
+    win.removeListener("resize", resizeMainWebView);
+  }));
   if (state.onClose) {
-    win.on("close", (event) => {
+    const onCloseHandler = (event) => {
       void state.onClose?.(event);
-    });
+    };
+    win.on("close", onCloseHandler);
+    registry.add(toDisposable(() => {
+      win.removeListener("close", onCloseHandler);
+    }));
+  }
+  const devToolsAccelerator = "CommandOrControl+Shift+I";
+  const registered = globalShortcut2.register(devToolsAccelerator, () => {
+    win.webContents.openDevTools({ mode: "detach" });
+  });
+  if (registered) {
+    registry.add(toDisposable(() => {
+      globalShortcut2.unregister(devToolsAccelerator);
+    }));
   }
+  return registry;
+}
+
+// src/main/utils/sender-policy.ts
+function createWorkbenchSenderPolicy(ctx) {
+  return (sender) => {
+    if (sender.isDestroyed()) return false;
+    if (ctx.windows.isMainSender(sender.id)) return true;
+    if (ctx.windows.isSettingsWindowSender(sender.id)) return true;
+    const settingsViewId = ctx.views.getSettingsWebContentsId();
+    if (settingsViewId != null && sender.id === settingsViewId) return true;
+    const popoverViewId = ctx.views.getPopoverWebContentsId();
+    if (popoverViewId != null && sender.id === popoverViewId) return true;
+    return false;
+  };
 }
 
 // src/main/services/default-adapter.ts
-import path3 from "path";
+import path5 from "path";
 import { app as app5 } from "electron";
 var defaultAdapter = {
   async openProject(opts) {
     const diminaKit = await import("@dimina-kit/devkit");
-    const openProject = diminaKit.openProject;
-    return openProject({
-      outputDir: path3.join(app5.getPath("userData"), "dimina-fe-output"),
+    const openProjectOpts = {
+      outputDir: path5.join(app5.getPath("userData"), "dimina-fe-output"),
       ...opts,
       simulatorDir
-    });
+    };
+    return diminaKit.openProject(openProjectOpts);
   }
 };
 
@@ -232,29 +420,31 @@ var SimulatorChannel = {
   Detach: "simulator:detach",
   Resize: "simulator:resize",
   SetVisible: "simulator:setVisible",
-  Console: "simulator:console",
-  Wxml: "simulator:wxml",
-  AppData: "simulator:appdata",
-  AppDataAll: "simulator:appdata-all"
+  Console: "simulator:console"
+};
+var SimulatorCustomApiChannel = {
+  List: "simulator:custom-apis:list",
+  Invoke: "simulator:custom-apis:invoke"
 };
 var SimulatorStorageChannel = {
   GetSnapshot: "simulator:storage:snapshot",
+  GetActivePrefix: "simulator:storage:activePrefix",
+  Set: "simulator:storage:set",
+  Remove: "simulator:storage:remove",
+  Clear: "simulator:storage:clear",
+  ClearAll: "simulator:storage:clearAll",
   Event: "simulator:storage:event"
 };
 var SimulatorElementChannel = {
   Inspect: "simulator:element:inspect",
   Clear: "simulator:element:clear"
 };
-var WorkbenchChannel = {
-  GetPanelConfig: "workbench:getPanelConfig",
-  GetApiNamespaces: "workbench:getApiNamespaces",
-  Reset: "workbench:reset"
-};
 var WorkbenchSettingsChannel = {
   Get: "workbenchSettings:get",
   Save: "workbenchSettings:save",
   SetTheme: "workbenchSettings:setTheme",
   GetCdpStatus: "workbenchSettings:getCdpStatus",
+  GetMcpStatus: "workbenchSettings:getMcpStatus",
   SetVisible: "workbenchSettings:setVisible",
   Init: "workbenchSettings:init"
 };
@@ -264,12 +454,22 @@ var ProjectChannel = {
   GetPages: "project:getPages",
   GetCompileConfig: "project:getCompileConfig",
   SaveCompileConfig: "project:saveCompileConfig",
-  Status: "project:status"
+  Status: "project:status",
+  CaptureThumbnail: "project:captureThumbnail",
+  GetThumbnail: "project:getThumbnail"
 };
 var ProjectsChannel = {
   List: "projects:list",
   Add: "projects:add",
-  Remove: "projects:remove"
+  Remove: "projects:remove",
+  /** Phase 3: merged + sanitized template catalog for the create-project dialog. */
+  ListTemplates: "projects:listTemplates",
+  /** Phase 3: host-supplied create-project dialog hook (returns input or null). */
+  OpenCreateDialog: "projects:openCreateDialog",
+  /** Phase 3: server-side scaffold + register (delegates to create-project-service). */
+  Create: "projects:create",
+  /** Default values used to pre-fill the create-project dialog (baseDir). */
+  GetCreateDefaults: "projects:getCreateDefaults"
 };
 var DialogChannel = {
   OpenDirectory: "dialog:openDirectory"
@@ -311,6 +511,13 @@ var SettingsChannel = {
   Closed: "settings:closed",
   Changed: "settings:changed"
 };
+var UpdateChannel = {
+  Check: "updates:check",
+  Download: "updates:download",
+  Install: "updates:install",
+  DownloadProgress: "updates:downloadProgress",
+  Available: "updates:available"
+};
 
 // src/main/services/notifications/renderer-notifier.ts
 function liveWebContents(wc) {
@@ -320,8 +527,8 @@ function liveWebContents(wc) {
 }
 function createRendererNotifier(ctx) {
   function sendToMain(channel, ...args) {
-    if (ctx.mainWindow.isDestroyed()) return;
-    const wc = liveWebContents(ctx.mainWindow.webContents);
+    if (ctx.windows.mainWindow.isDestroyed()) return;
+    const wc = liveWebContents(ctx.windows.mainWindow.webContents);
     if (!wc) return;
     wc.send(channel, ...args);
   }
@@ -344,9 +551,6 @@ function createRendererNotifier(ctx) {
     popoverRelaunch(config) {
       sendToMain(PopoverChannel.Relaunch, config);
     },
-    workbenchReset() {
-      sendToMain(WorkbenchChannel.Reset);
-    },
     toolbarActionsChanged() {
       sendToMain(ToolbarChannel.ActionsChanged);
     },
@@ -371,7 +575,7 @@ function createRendererNotifier(ctx) {
 
 // src/main/services/views/view-manager.ts
 import { WebContentsView as WebContentsView2, webContents } from "electron";
-import path4 from "path";
+import path6 from "path";
 
 // src/main/services/layout/index.ts
 var HEADER_H = 40;
@@ -420,9 +624,9 @@ function createViewManager(ctx) {
   let simulatorWebContentsId = null;
   function destroyViewInternal(view) {
     if (!view) return;
-    if (!ctx.mainWindow.isDestroyed()) {
+    if (!ctx.windows.mainWindow.isDestroyed()) {
       try {
-        ctx.mainWindow.contentView.removeChildView(view);
+        ctx.windows.mainWindow.contentView.removeChildView(view);
       } catch {
       }
     }
@@ -434,18 +638,18 @@ function createViewManager(ctx) {
     }
   }
   function applySimulatorBounds(simWidth) {
-    if (!simulatorView || ctx.mainWindow.isDestroyed()) return;
-    const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+    if (!simulatorView || ctx.windows.mainWindow.isDestroyed()) return;
+    const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
     simulatorView.setBounds(computeSimulatorBounds(w, h, simWidth));
   }
   function applySettingsBounds() {
-    if (!settingsView || ctx.mainWindow.isDestroyed()) return;
-    const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+    if (!settingsView || ctx.windows.mainWindow.isDestroyed()) return;
+    const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
     settingsView.setBounds(computeSettingsBounds(w, h));
   }
   function applyPopoverBounds() {
-    if (!popoverView || ctx.mainWindow.isDestroyed()) return;
-    const [w = 0, h = 0] = ctx.mainWindow.getContentSize();
+    if (!popoverView || ctx.windows.mainWindow.isDestroyed()) return;
+    const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
     popoverView.setBounds(computePopoverBounds(w, h));
   }
   function attachSimulator(simWcId, simWidth) {
@@ -493,7 +697,7 @@ function createViewManager(ctx) {
       });
     });
     if (getDefaultTab(ctx) === "simulator") {
-      ctx.mainWindow.contentView.addChildView(simulatorView);
+      ctx.windows.mainWindow.contentView.addChildView(simulatorView);
       simulatorViewAdded = true;
       applySimulatorBounds(simWidth);
     }
@@ -512,7 +716,7 @@ function createViewManager(ctx) {
     lastSimWidth = simWidth;
     if (!simulatorView) return;
     if (!simulatorViewAdded) {
-      ctx.mainWindow.contentView.addChildView(simulatorView);
+      ctx.windows.mainWindow.contentView.addChildView(simulatorView);
       simulatorViewAdded = true;
     }
     applySimulatorBounds(simWidth);
@@ -520,7 +724,7 @@ function createViewManager(ctx) {
   function hideSimulator() {
     if (simulatorView && simulatorViewAdded) {
       try {
-        ctx.mainWindow.contentView.removeChildView(simulatorView);
+        ctx.windows.mainWindow.contentView.removeChildView(simulatorView);
       } catch (e) {
         console.error("[workbench] hideSimulator error", e);
       }
@@ -530,14 +734,20 @@ function createViewManager(ctx) {
   async function showSettings() {
     if (!settingsView) {
       settingsView = new WebContentsView2({
-        webPreferences: { nodeIntegration: true, contextIsolation: false }
+        webPreferences: {
+          nodeIntegration: false,
+          contextIsolation: true,
+          sandbox: false,
+          preload: mainPreloadPath
+        }
       });
+      applyNavigationHardening(settingsView.webContents, ctx.rendererDir);
       await settingsView.webContents.loadFile(
-        path4.join(ctx.rendererDir, "entries/settings/index.html")
+        path6.join(ctx.rendererDir, "entries/settings/index.html")
       );
     }
     if (!settingsViewAdded) {
-      ctx.mainWindow.contentView.addChildView(settingsView);
+      ctx.windows.mainWindow.contentView.addChildView(settingsView);
       settingsViewAdded = true;
     }
     applySettingsBounds();
@@ -545,7 +755,7 @@ function createViewManager(ctx) {
   function hideSettings() {
     if (settingsView && settingsViewAdded) {
       try {
-        ctx.mainWindow.contentView.removeChildView(settingsView);
+        ctx.windows.mainWindow.contentView.removeChildView(settingsView);
       } catch {
       }
       settingsViewAdded = false;
@@ -554,17 +764,23 @@ function createViewManager(ctx) {
   function showPopover(data) {
     hidePopover();
     const popover = new WebContentsView2({
-      webPreferences: { nodeIntegration: true, contextIsolation: false }
+      webPreferences: {
+        nodeIntegration: false,
+        contextIsolation: true,
+        sandbox: false,
+        preload: mainPreloadPath
+      }
     });
+    applyNavigationHardening(popover.webContents, ctx.rendererDir);
     popoverView = popover;
     popover.setBackgroundColor("#00000000");
-    ctx.mainWindow.contentView.addChildView(popover);
+    ctx.windows.mainWindow.contentView.addChildView(popover);
     applyPopoverBounds();
     popover.webContents.once("did-finish-load", () => {
       ctx.notify.popoverInit(popover, data);
     });
     popover.webContents.loadFile(
-      path4.join(ctx.rendererDir, "entries/popover/index.html")
+      path6.join(ctx.rendererDir, "entries/popover/index.html")
     );
   }
   function hidePopover() {
@@ -585,14 +801,6 @@ function createViewManager(ctx) {
   function disposeAll() {
     detachSimulator();
   }
-  function logChildViews(_label) {
-  }
-  function positionSimulator(simWidth) {
-    applySimulatorBounds(simWidth);
-  }
-  function positionSettings() {
-    applySettingsBounds();
-  }
   function resize(simWidth) {
     lastSimWidth = simWidth;
     if (simulatorViewAdded) applySimulatorBounds(simWidth);
@@ -618,10 +826,12 @@ function createViewManager(ctx) {
     hidePopover,
     repositionAll,
     disposeAll,
-    logChildViews,
-    positionSimulator,
-    positionSettings,
     getSimulatorWebContentsId: () => simulatorWebContentsId,
+    getSimulatorWebContents: () => {
+      if (simulatorWebContentsId == null) return null;
+      const wc = webContents.fromId(simulatorWebContentsId);
+      return wc && !wc.isDestroyed() ? wc : null;
+    },
     getLastSimWidth: () => lastSimWidth,
     isSimulatorAdded: () => simulatorViewAdded,
     hasSimulatorView: () => simulatorView !== null,
@@ -630,19 +840,52 @@ function createViewManager(ctx) {
       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;
+    },
     resize,
     setVisible
   };
 }
 
+// src/main/services/window-service.ts
+function createWindowService(mainWindow) {
+  let settingsWin = null;
+  return {
+    get mainWindow() {
+      return mainWindow;
+    },
+    get settingsWindow() {
+      return settingsWin;
+    },
+    setSettingsWindow(win) {
+      settingsWin = win;
+    },
+    closeSettingsWindow() {
+      if (settingsWin && !settingsWin.isDestroyed()) settingsWin.close();
+      settingsWin = null;
+    },
+    isMainSender(id) {
+      return !mainWindow.isDestroyed() && mainWindow.webContents.id === id;
+    },
+    isSettingsWindowSender(id) {
+      return !!settingsWin && !settingsWin.isDestroyed() && settingsWin.webContents.id === id;
+    }
+  };
+}
+
 // src/main/services/projects/project-repository.ts
 import { app as app6 } from "electron";
-import path5 from "path";
+import path7 from "path";
 import fs3 from "fs";
 
-// src/shared/constants.ts
-var DEFAULT_SCENE = 1001;
-
 // src/main/utils/logger.ts
 var LEVEL_PRIORITY = {
   debug: 0,
@@ -684,7 +927,7 @@ function createLogger(tag) {
 // src/main/services/projects/project-repository.ts
 var log = createLogger("projects");
 function getProjectsFile() {
-  return path5.join(app6.getPath("userData"), "dimina-projects.json");
+  return path7.join(app6.getPath("userData"), "dimina-projects.json");
 }
 function load() {
   try {
@@ -706,13 +949,13 @@ function validateProjectDir(dirPath) {
   if (!fs3.existsSync(dirPath)) {
     return `\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dirPath}`;
   }
-  if (!fs3.existsSync(path5.join(dirPath, "app.json"))) {
-    const configPath = path5.join(dirPath, "project.config.json");
+  if (!fs3.existsSync(path7.join(dirPath, "app.json"))) {
+    const configPath = path7.join(dirPath, "project.config.json");
     if (fs3.existsSync(configPath)) {
       try {
         const cfg = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
         if (cfg.miniprogramRoot) {
-          const resolvedRoot = path5.resolve(dirPath, cfg.miniprogramRoot);
+          const resolvedRoot = path7.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) {
@@ -725,9 +968,9 @@ function validateProjectDir(dirPath) {
 }
 function addProject(dirPath) {
   const projects = load();
-  let name = path5.basename(dirPath);
+  let name = path7.basename(dirPath);
   try {
-    const configPath = path5.join(dirPath, "project.config.json");
+    const configPath = path7.join(dirPath, "project.config.json");
     if (fs3.existsSync(configPath)) {
       const cfg = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
       if (cfg.projectname) name = cfg.projectname;
@@ -766,7 +1009,7 @@ function getCompileConfig(dirPath) {
   };
 }
 function getProjectPages(dirPath) {
-  const appJsonPath = path5.join(dirPath, "app.json");
+  const appJsonPath = path7.join(dirPath, "app.json");
   try {
     const appJson = JSON.parse(
       fs3.readFileSync(appJsonPath, "utf-8")
@@ -792,7 +1035,7 @@ function getProjectSettings(projectPath) {
     return { uploadWithSourceMap: false };
   }
   try {
-    const configPath = path5.join(projectPath, "project.config.json");
+    const configPath = path7.join(projectPath, "project.config.json");
     const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
     return {
       uploadWithSourceMap: !!config.setting?.uploadWithSourceMap
@@ -803,7 +1046,7 @@ function getProjectSettings(projectPath) {
 }
 function updateProjectSettings(projectPath, patch) {
   if (!projectPath) return;
-  const configPath = path5.join(projectPath, "project.config.json");
+  const configPath = path7.join(projectPath, "project.config.json");
   let config = {};
   try {
     config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
@@ -819,12 +1062,19 @@ function updateProjectSettings(projectPath, patch) {
   );
 }
 
+// src/main/services/projects/types.ts
+var DEFAULT_COMPILE_CONFIG = {
+  startPage: "",
+  scene: DEFAULT_SCENE,
+  queryParams: []
+};
+
 // src/main/services/workspace/workspace-service.ts
 function createWorkspaceService(ctx) {
   let currentSession = null;
   let currentProjectPath = "";
-  function sendStatus(status, message) {
-    ctx.notify.projectStatus({ status, message });
+  function sendStatus(status2, message, hotReload) {
+    ctx.notify.projectStatus(hotReload ? { status: status2, message, hotReload: true } : { status: status2, message });
   }
   function bestEffort(label, fn) {
     try {
@@ -857,27 +1107,36 @@ function createWorkspaceService(ctx) {
       );
     }
   }
+  const provider = ctx.projectsProvider;
   return {
-    listProjects: () => listProjects(),
-    addProject: (dirPath) => addProject(dirPath),
-    removeProject: (dirPath) => removeProject(dirPath),
-    validateProjectDir: (dirPath) => validateProjectDir(dirPath),
+    listProjects: async () => provider.listProjects(),
+    addProject: async (dirPath) => provider.addProject(dirPath),
+    removeProject: async (dirPath) => {
+      await provider.removeProject(dirPath);
+    },
+    hasProject: async (dirPath) => {
+      const projects = await provider.listProjects();
+      return projects.some((p) => p.path === dirPath);
+    },
+    validateProjectDir: async (dirPath) => provider.validateProjectDir ? provider.validateProjectDir(dirPath) : null,
     async openProject(projectPath) {
       clearSimulatorServicewechatReferer();
       await disposeSession();
       currentProjectPath = "";
-      const dirError = validateProjectDir(projectPath);
+      const dirError = provider.validateProjectDir ? await provider.validateProjectDir(projectPath) : null;
       if (dirError) {
         sendStatus("error", dirError);
         return { success: false, error: dirError };
       }
       sendStatus("compiling", "\u6B63\u5728\u7F16\u8BD1...");
+      const { compile } = loadWorkbenchSettings();
       let session2;
       try {
         session2 = await ctx.adapter.openProject({
           projectPath,
           sourcemap: true,
-          onRebuild: () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u70ED\u66F4\u65B0"),
+          watch: compile.watch,
+          onRebuild: () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u70ED\u66F4\u65B0", true),
           onBuildError: (err) => sendStatus("error", String(err))
         });
       } catch (err) {
@@ -887,7 +1146,9 @@ function createWorkspaceService(ctx) {
       }
       currentSession = session2;
       currentProjectPath = projectPath;
-      bestEffort("updateLastOpened", () => updateLastOpened(projectPath));
+      bestEffort("updateLastOpened", () => {
+        if (provider.updateLastOpened) provider.updateLastOpened(projectPath);
+      });
       bestEffort("sendStatus", () => sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210"));
       bestEffort("applyReferer", () => applyRefererFromSession(session2));
       return {
@@ -905,14 +1166,132 @@ function createWorkspaceService(ctx) {
     getSession: () => currentSession,
     getProjectPath: () => currentProjectPath,
     hasActiveSession: () => currentSession !== null,
+    async captureThumbnail(projectPath) {
+      const wc = ctx.views.getSimulatorWebContents();
+      if (!wc) return null;
+      try {
+        const image = await wc.capturePage();
+        const dataUrl = `data:image/png;base64,${image.toPNG().toString("base64")}`;
+        if (provider.saveThumbnail) {
+          await provider.saveThumbnail(projectPath, dataUrl);
+        }
+        return dataUrl;
+      } catch {
+        return null;
+      }
+    },
+    async getThumbnail(projectPath) {
+      if (provider.getThumbnail) {
+        return await provider.getThumbnail(projectPath) ?? null;
+      }
+      return null;
+    },
+    // `getProjectPages` reads the project's own `app.json` from disk and is
+    // independent of the project registry — it stays on the repo helper.
     getProjectPages: (projectPath) => getProjectPages(projectPath),
-    getCompileConfig: (projectPath) => getCompileConfig(projectPath),
-    saveCompileConfig: (projectPath, config) => saveCompileConfig(projectPath, config),
+    getCompileConfig: async (projectPath) => provider.getCompileConfig ? await provider.getCompileConfig(projectPath) : DEFAULT_COMPILE_CONFIG,
+    saveCompileConfig: async (projectPath, config) => {
+      if (provider.saveCompileConfig) {
+        await provider.saveCompileConfig(projectPath, config);
+      }
+    },
+    // Per-project settings (uploadWithSourceMap etc.) live in the project's
+    // own `project.config.json`, not the registry — keep direct repo calls.
     getProjectSettings: (projectPath) => getProjectSettings(projectPath),
     updateProjectSettings: (projectPath, patch) => updateProjectSettings(projectPath, patch)
   };
 }
 
+// src/main/services/projects/thumbnail.ts
+import { createHash } from "crypto";
+import fs4 from "fs";
+import path8 from "path";
+import { app as app7 } from "electron";
+function getThumbnailDir() {
+  return path8.join(app7.getPath("userData"), "thumbnails");
+}
+function hashProjectPath(projectPath) {
+  return createHash("sha256").update(projectPath).digest("hex").slice(0, 16);
+}
+function getThumbnailPath(projectPath) {
+  return path8.join(getThumbnailDir(), `${hashProjectPath(projectPath)}.png`);
+}
+var DATA_URL_PNG_PREFIX = "data:image/png;base64,";
+function saveThumbnailFromDataUrl(projectPath, imageDataUrl) {
+  if (!imageDataUrl.startsWith(DATA_URL_PNG_PREFIX)) return;
+  const png = Buffer.from(imageDataUrl.slice(DATA_URL_PNG_PREFIX.length), "base64");
+  fs4.mkdirSync(getThumbnailDir(), { recursive: true });
+  fs4.writeFileSync(getThumbnailPath(projectPath), png);
+}
+function loadThumbnail(projectPath) {
+  const filePath = getThumbnailPath(projectPath);
+  try {
+    const buf = fs4.readFileSync(filePath);
+    return `${DATA_URL_PNG_PREFIX}${buf.toString("base64")}`;
+  } catch {
+    return null;
+  }
+}
+
+// src/main/services/projects/local-provider.ts
+function createLocalProjectsProvider() {
+  return {
+    listProjects: () => listProjects(),
+    addProject: (dirPath) => addProject(dirPath),
+    removeProject: (dirPath) => removeProject(dirPath),
+    validateProjectDir: (dirPath) => validateProjectDir(dirPath),
+    updateLastOpened: (dirPath) => updateLastOpened(dirPath),
+    getCompileConfig: (dirPath) => getCompileConfig(dirPath),
+    saveCompileConfig: (dirPath, cfg) => saveCompileConfig(dirPath, cfg),
+    saveThumbnail: (dirPath, dataUrl) => saveThumbnailFromDataUrl(dirPath, dataUrl),
+    getThumbnail: (dirPath) => loadThumbnail(dirPath)
+  };
+}
+
+// src/main/services/projects/templates.ts
+function resolveTemplates(builtin, injected, mode) {
+  let kept;
+  if (mode === "none") {
+    kept = [];
+  } else if (mode === "all") {
+    kept = [...builtin];
+  } else {
+    const byId = new Map(builtin.map((t) => [t.id, t]));
+    kept = [];
+    for (const id of mode) {
+      const t = byId.get(id);
+      if (t) kept.push(t);
+    }
+  }
+  const injectedIds = new Set(injected.map((t) => t.id));
+  const remaining = kept.filter((t) => !injectedIds.has(t.id));
+  return [...injected, ...remaining];
+}
+function sanitizeTemplates(templates) {
+  return templates.map((t) => {
+    const { generate: _generate, ...rest } = t;
+    return rest;
+  });
+}
+
+// src/main/services/projects/builtin-templates.ts
+import path9 from "node:path";
+var TEMPLATES_DIR = path9.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: path9.join(TEMPLATES_DIR, "blank") }
+  },
+  {
+    id: "taro-todo",
+    name: "Taro Todo",
+    description: "Taro \u7F16\u8BD1\u4EA7\u7269\u7684 Todo \u793A\u4F8B",
+    source: { type: "directory", path: path9.join(TEMPLATES_DIR, "taro-todo") }
+  }
+];
+
 // src/main/services/workbench-context.ts
 function hasBuiltinPanel(ctx, panelId) {
   return ctx.panels.includes(panelId);
@@ -924,7 +1303,6 @@ function getDefaultTab(ctx) {
 }
 function createWorkbenchContext(opts) {
   const ctx = {
-    mainWindow: opts.mainWindow,
     adapter: opts.adapter ?? defaultAdapter,
     preloadPath: opts.preloadPath,
     rendererDir: opts.rendererDir,
@@ -932,12 +1310,21 @@ function createWorkbenchContext(opts) {
     apiNamespaces: opts.apiNamespaces ?? [],
     appName: opts.appName ?? "Dimina DevTools",
     toolbarActions: opts.toolbarActions,
-    brandingProvider: opts.brandingProvider,
-    workbenchSettingsWindow: null
+    brandingProvider: opts.brandingProvider
   };
+  ctx.registry = new DisposableRegistry();
+  ctx.windows = createWindowService(opts.mainWindow);
   ctx.views = createViewManager(ctx);
   ctx.notify = createRendererNotifier(ctx);
+  ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();
+  ctx.projectTemplates = resolveTemplates(
+    BUILTIN_TEMPLATES,
+    opts.projectTemplates ?? [],
+    opts.builtinTemplates ?? "all"
+  );
+  ctx.customCreateProjectDialog = opts.customCreateProjectDialog;
   ctx.workspace = createWorkspaceService(ctx);
+  ctx.senderPolicy = createWorkbenchSenderPolicy(ctx);
   return ctx;
 }
 
@@ -967,6 +1354,17 @@ function installAppMenu(ctx) {
         { role: "quit" }
       ]
     },
+    {
+      label: "\u9879\u76EE",
+      submenu: [
+        {
+          label: "\u6253\u5F00\u9879\u76EE",
+          click: () => {
+            ctx.notify.windowNavigateBack();
+          }
+        }
+      ]
+    },
     {
       label: "\u7F16\u8F91",
       submenu: [
@@ -1008,72 +1406,256 @@ function installAppMenu(ctx) {
 }
 
 // src/main/ipc/app.ts
+import fs5 from "fs";
+
+// src/main/utils/ipc-registry.ts
 import { ipcMain } from "electron";
-import fs4 from "fs";
+
+// src/main/utils/ipc-schema.ts
+var IpcValidationError = class extends Error {
+  channel;
+  paths;
+  constructor(channel, issues) {
+    const paths = issues.map((i) => i.path.map((p) => String(p)).join(".") || "<root>");
+    super(`Invalid IPC arguments for ${channel}`);
+    this.name = "IpcValidationError";
+    this.channel = channel;
+    this.paths = paths;
+  }
+};
+function validate(channel, schema, args) {
+  const r = schema.safeParse(args);
+  if (!r.success) {
+    console.warn("[ipc] schema reject", channel, r.error.issues);
+    throw new IpcValidationError(channel, r.error.issues);
+  }
+  return r.data;
+}
+
+// src/main/utils/ipc-registry.ts
+var log2 = createLogger("ipc");
+function reportListenerError(channel, err) {
+  if (err instanceof IpcValidationError) {
+    log2.warn(`schema reject on '${channel}' at [${err.paths.join(", ")}]`);
+    return;
+  }
+  if (err instanceof Error) {
+    log2.error(`listener threw on '${channel}': ${err.message}`, err.stack);
+    return;
+  }
+  log2.error(`listener threw on '${channel}'`, err);
+}
+function isThenable(v) {
+  return v != null && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
+}
+function summarizeSender(sender) {
+  if (sender.isDestroyed()) return "<destroyed>";
+  const url = sender.getURL();
+  return `id=${sender.id} ${url.slice(0, 120)}`;
+}
+var IpcRegistry = class {
+  constructor(policy) {
+    this.policy = policy;
+  }
+  policy;
+  registry = new DisposableRegistry();
+  handle(channel, fn) {
+    const policy = this.policy;
+    const guarded = policy ? (event, ...args) => {
+      const sender = event.sender;
+      if (!policy(sender)) {
+        console.warn(
+          `[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`
+        );
+        throw new Error(`IPC sender rejected for channel ${channel}`);
+      }
+      return fn(event, ...args);
+    } : fn;
+    ipcMain.handle(channel, guarded);
+    this.registry.add(() => ipcMain.removeHandler(channel));
+    return this;
+  }
+  on(channel, fn) {
+    const policy = this.policy;
+    const raw = fn;
+    const safeInvoke = (event, args) => {
+      try {
+        const ret = raw(event, ...args);
+        if (isThenable(ret)) {
+          Promise.resolve(ret).catch((err) => reportListenerError(channel, err));
+        }
+      } catch (err) {
+        reportListenerError(channel, err);
+      }
+    };
+    const guarded = policy ? (event, ...args) => {
+      const sender = event.sender;
+      if (!policy(sender)) {
+        console.warn(
+          `[ipc] sender rejected for channel '${channel}' (${summarizeSender(sender)})`
+        );
+        return;
+      }
+      safeInvoke(event, args);
+    } : (event, ...args) => safeInvoke(event, args);
+    ipcMain.on(channel, guarded);
+    this.registry.add(() => {
+      ipcMain.removeListener(channel, guarded);
+    });
+    return this;
+  }
+  dispose() {
+    return this.registry.dispose();
+  }
+};
+
+// src/main/ipc/app.ts
 function registerAppIpc(ctx) {
-  ipcMain.handle(AppChannel.GetPreloadPath, () => {
-    return `file://${fs4.realpathSync(ctx.preloadPath)}`;
-  });
-  ipcMain.handle(AppChannel.GetBranding, async () => {
+  return new IpcRegistry(ctx.senderPolicy).handle(AppChannel.GetPreloadPath, () => {
+    return `file://${fs5.realpathSync(ctx.preloadPath)}`;
+  }).handle(AppChannel.GetBranding, async () => {
     if (ctx.brandingProvider) return ctx.brandingProvider();
     return { appName: ctx.appName };
   });
 }
 
+// src/shared/ipc-schemas.ts
+import { z } from "zod";
+var AbsolutePath = z.string().min(1).refine(
+  (p) => p.startsWith("/") || /^[a-zA-Z]:\\/.test(p) || /^[a-zA-Z]:\//.test(p),
+  "must be an absolute path"
+);
+var PanelEvalSchema = z.tuple([z.string().min(1).max(5e4)]);
+var ProjectsAddSchema = z.tuple([AbsolutePath]);
+var ProjectOpenSchema = z.tuple([AbsolutePath]);
+var CompileConfigShape = z.looseObject({
+  startPage: z.string().optional(),
+  scene: z.number().optional(),
+  queryParams: z.array(z.looseObject({ key: z.string(), value: z.string() })).optional()
+});
+var ProjectSaveCompileConfigSchema = z.tuple([
+  AbsolutePath,
+  CompileConfigShape
+]);
+var PopoverShowSchema = z.tuple([z.looseObject({})]);
+var SimWidth = z.number().int().min(100).max(2e3);
+var SimulatorAttachSchema = z.tuple([
+  z.number().int().positive(),
+  SimWidth
+]);
+var SimulatorResizeSchema = z.tuple([SimWidth]);
+var SimulatorSetVisibleSchema = z.tuple([z.boolean(), SimWidth]);
+var SimulatorCustomApiInvokeSchema = z.tuple([
+  z.string().min(1).max(256),
+  z.unknown()
+]);
+var ProjectGetPagesSchema = z.tuple([AbsolutePath]);
+var ProjectGetCompileConfigSchema = z.tuple([AbsolutePath]);
+var ProjectsRemoveSchema = z.tuple([AbsolutePath]);
+var WorkbenchSettingsSaveSchema = z.tuple([
+  z.looseObject({
+    cdp: z.looseObject({
+      enabled: z.boolean(),
+      port: z.number().int().min(0).max(65535)
+    }),
+    mcp: z.looseObject({
+      enabled: z.boolean(),
+      port: z.number().int().min(0).max(65535)
+    }),
+    compile: z.looseObject({
+      watch: z.boolean()
+    }),
+    theme: z.enum(["system", "light", "dark"]),
+    lastCreateBaseDir: z.union([z.string(), z.null()])
+  })
+]);
+var WorkbenchSettingsSetThemeSchema = z.tuple([
+  z.enum(["system", "light", "dark"])
+]);
+var WorkbenchSettingsSetVisibleSchema = z.tuple([z.boolean()]);
+var SettingsSetVisibleSchema = z.tuple([z.boolean()]);
+var SettingsConfigChangedSchema = z.tuple([CompileConfigShape]);
+var PopoverRelaunchSchema = z.tuple([CompileConfigShape]);
+var SettingsProjectSettingsChangedSchema = z.tuple([
+  z.looseObject({
+    uploadWithSourceMap: z.boolean().optional()
+  })
+]);
+var PanelSelectSchema = z.tuple([z.string().min(1).max(200)]);
+var ProjectCaptureThumbnailSchema = z.tuple([AbsolutePath]);
+var ProjectGetThumbnailSchema = z.tuple([AbsolutePath]);
+
+// src/main/services/simulator/custom-apis.ts
+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());
+    },
+    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();
+    }
+  };
+}
+var simulatorApiRegistry = createSimulatorApiRegistry();
+
 // src/main/ipc/simulator.ts
-import { ipcMain as ipcMain2 } from "electron";
 function registerSimulatorIpc(ctx) {
-  ipcMain2.handle(SimulatorChannel.Attach, (_, simWcId, simWidth) => {
+  return new IpcRegistry(ctx.senderPolicy).handle(SimulatorChannel.Attach, (_, ...args) => {
+    const [simWcId, simWidth] = validate(SimulatorChannel.Attach, SimulatorAttachSchema, args);
     ctx.views.attachSimulator(simWcId, simWidth);
-  });
-  ipcMain2.handle(SimulatorChannel.Detach, () => {
+  }).handle(SimulatorChannel.Detach, () => {
     ctx.views.detachSimulator();
-  });
-  ipcMain2.handle(SimulatorChannel.Resize, (_, simWidth) => {
+  }).handle(SimulatorChannel.Resize, (_, ...args) => {
+    const [simWidth] = validate(SimulatorChannel.Resize, SimulatorResizeSchema, args);
     ctx.views.resize(simWidth);
-  });
-  ipcMain2.handle(SimulatorChannel.SetVisible, (_, visible, simWidth) => {
+  }).handle(SimulatorChannel.SetVisible, (_, ...args) => {
+    const [visible, simWidth] = validate(SimulatorChannel.SetVisible, SimulatorSetVisibleSchema, args);
     ctx.views.setVisible(visible, simWidth);
-  });
-  ipcMain2.handle(WorkbenchChannel.GetPanelConfig, () => {
-    return ctx.panels;
-  });
-  ipcMain2.handle(WorkbenchChannel.GetApiNamespaces, () => {
-    return ctx.apiNamespaces;
-  });
-  ipcMain2.on(WorkbenchChannel.Reset, () => {
-    ctx.notify.workbenchReset();
+  }).handle(SimulatorCustomApiChannel.List, () => {
+    return simulatorApiRegistry.list();
+  }).handle(SimulatorCustomApiChannel.Invoke, (_, ...args) => {
+    const [name, params] = validate(SimulatorCustomApiChannel.Invoke, SimulatorCustomApiInvokeSchema, args);
+    return simulatorApiRegistry.invoke(name, params);
   });
 }
 
 // src/main/ipc/panels.ts
-import { ipcMain as ipcMain3, webContents as webContents2 } from "electron";
 var BUILTIN_PANELS = [
   { id: "wxml", label: "WXML" },
   { id: "appdata", label: "AppData" },
   { id: "storage", label: "Storage" }
 ];
 function registerPanelsIpc(ctx) {
-  ipcMain3.handle(PanelChannel.List, () => {
+  return new IpcRegistry(ctx.senderPolicy).handle(PanelChannel.List, () => {
     return BUILTIN_PANELS.filter((p) => ctx.panels.includes(p.id));
-  });
-  ipcMain3.handle(PanelChannel.Eval, async (_, expression) => {
-    const simWcId = ctx.views.getSimulatorWebContentsId();
-    if (!ctx.workspace.hasActiveSession() || simWcId == null) return void 0;
-    const sim = webContents2.fromId(simWcId);
-    if (!sim || sim.isDestroyed()) return void 0;
+  }).handle(PanelChannel.Eval, async (_event, ...args) => {
+    const [expression] = validate(PanelChannel.Eval, PanelEvalSchema, args);
+    if (!ctx.workspace.hasActiveSession()) return void 0;
+    const sim = ctx.views.getSimulatorWebContents();
+    if (!sim) return void 0;
     try {
       return await sim.executeJavaScript(expression);
     } catch {
       return void 0;
     }
-  });
-  ipcMain3.handle(PanelChannel.Select, (_event, _panelId) => {
+  }).handle(PanelChannel.Select, (_event, ...args) => {
+    validate(PanelChannel.Select, PanelSelectSchema, args);
     if (ctx.views.hasSimulatorView() && ctx.views.isSimulatorAdded()) {
       ctx.views.hideSimulator();
     }
-  });
-  ipcMain3.handle(PanelChannel.SelectSimulator, () => {
+  }).handle(PanelChannel.SelectSimulator, () => {
     if (ctx.views.hasSimulatorView() && !ctx.views.isSimulatorAdded()) {
       ctx.views.showSimulator(ctx.views.getLastSimWidth());
     }
@@ -1081,79 +1663,272 @@ function registerPanelsIpc(ctx) {
 }
 
 // src/main/ipc/popover.ts
-import { ipcMain as ipcMain4 } from "electron";
 function registerPopoverIpc(ctx) {
-  ipcMain4.handle(PopoverChannel.Show, (_event, data) => {
+  return new IpcRegistry(ctx.senderPolicy).handle(PopoverChannel.Show, (_event, ...args) => {
+    const [data] = validate(PopoverChannel.Show, PopoverShowSchema, args);
     ctx.views.showPopover(data);
-  });
-  ipcMain4.handle(PopoverChannel.Hide, () => ctx.views.hidePopover());
-  ipcMain4.on(PopoverChannel.Relaunch, (_, newConfig) => {
+  }).handle(PopoverChannel.Hide, () => {
+    ctx.views.hidePopover();
+  }).on(PopoverChannel.Relaunch, (_event, ...args) => {
+    const [newConfig] = validate(PopoverChannel.Relaunch, PopoverRelaunchSchema, args);
     ctx.views.hidePopover();
     ctx.notify.popoverRelaunch(newConfig);
   });
 }
+var popoverModule = {
+  setup: (ctx) => registerPopoverIpc(ctx)
+};
+
+// src/main/ipc/projects.ts
+import { app as app8, dialog } from "electron";
+import path11 from "path";
+
+// src/main/services/projects/create-project-service.ts
+import fs6 from "node:fs";
+import path10 from "node:path";
+var DEFAULT_TEMPLATE_ID = "blank";
+async function createProject(input, ctx) {
+  const name = (input.name ?? "").trim();
+  if (name.length === 0) {
+    throw new Error("Project name cannot be empty");
+  }
+  const target = input.path;
+  if (!target || typeof target !== "string") {
+    throw new Error("Project path is required");
+  }
+  if (fs6.existsSync(target)) {
+    const stat = fs6.statSync(target);
+    if (!stat.isDirectory()) {
+      throw new Error(`Project path exists and is not a directory: ${target}`);
+    }
+    const entries = fs6.readdirSync(target);
+    if (entries.length > 0) {
+      throw new Error(
+        `Project path is not empty (refusing to overwrite): ${target}`
+      );
+    }
+  }
+  const templateId = input.templateId ?? DEFAULT_TEMPLATE_ID;
+  const template = ctx.templates.find((t) => t.id === templateId);
+  if (!template) {
+    throw new Error(`Template not found: ${templateId}`);
+  }
+  if (!template.source && !template.generate) {
+    throw new Error(
+      `Template '${templateId}' has neither a source directory nor a generate function`
+    );
+  }
+  fs6.mkdirSync(target, { recursive: true });
+  if (template.generate) {
+    await template.generate(target, { name });
+  } else if (template.source) {
+    if (!fs6.existsSync(template.source.path)) {
+      throw new Error(
+        `Template source missing on disk: ${template.source.path}`
+      );
+    }
+    fs6.cpSync(template.source.path, target, {
+      recursive: true,
+      force: true
+    });
+  }
+  const cfgPath = path10.join(target, "project.config.json");
+  let cfg = {};
+  if (fs6.existsSync(cfgPath)) {
+    try {
+      cfg = JSON.parse(fs6.readFileSync(cfgPath, "utf-8"));
+    } catch {
+      cfg = {};
+    }
+  }
+  cfg.projectname = name;
+  fs6.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+  const created = await ctx.projectsProvider.addProject(target);
+  return created;
+}
 
 // src/main/ipc/projects.ts
-import { ipcMain as ipcMain5, dialog } from "electron";
 function registerProjectsIpc(ctx) {
-  ipcMain5.handle(ProjectsChannel.List, () => ctx.workspace.listProjects());
-  ipcMain5.handle(DialogChannel.OpenDirectory, async () => {
-    const result = await dialog.showOpenDialog(ctx.mainWindow, {
+  return new IpcRegistry(ctx.senderPolicy).handle(ProjectsChannel.List, () => {
+    return ctx.workspace.listProjects();
+  }).handle(DialogChannel.OpenDirectory, async () => {
+    const result = await dialog.showOpenDialog(ctx.windows.mainWindow, {
       properties: ["openDirectory"],
       title: "\u9009\u62E9\u5C0F\u7A0B\u5E8F\u9879\u76EE\u76EE\u5F55"
     });
     return result.canceled ? null : result.filePaths[0];
+  }).handle(ProjectsChannel.Add, async (_event, ...args) => {
+    const [dirPath] = validate(ProjectsChannel.Add, ProjectsAddSchema, args);
+    const dirError = await ctx.workspace.validateProjectDir(dirPath);
+    if (dirError) {
+      await dialog.showMessageBox(ctx.windows.mainWindow, {
+        type: "error",
+        title: "\u65E0\u6CD5\u5BFC\u5165\u9879\u76EE",
+        message: "\u8BE5\u76EE\u5F55\u4E0D\u662F\u6709\u6548\u7684\u5C0F\u7A0B\u5E8F\u9879\u76EE",
+        detail: dirError,
+        buttons: ["\u786E\u5B9A"]
+      });
+      throw new Error(dirError);
+    }
+    const duplicate = await ctx.workspace.hasProject(dirPath);
+    const project = await ctx.workspace.addProject(dirPath);
+    if (duplicate) {
+      await dialog.showMessageBox(ctx.windows.mainWindow, {
+        type: "info",
+        title: "\u9879\u76EE\u5DF2\u5B58\u5728",
+        message: "\u8BE5\u9879\u76EE\u5DF2\u5728\u5217\u8868\u4E2D",
+        detail: dirPath,
+        buttons: ["\u786E\u5B9A"]
+      });
+    }
+    return project;
+  }).handle(ProjectsChannel.Remove, (_event, ...args) => {
+    const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
+    return ctx.workspace.removeProject(dirPath);
+  }).handle(ProjectsChannel.ListTemplates, () => {
+    return sanitizeTemplates(ctx.projectTemplates ?? []);
+  }).handle(ProjectsChannel.OpenCreateDialog, async () => {
+    if (!ctx.customCreateProjectDialog) return null;
+    const sanitized = sanitizeTemplates(ctx.projectTemplates ?? []);
+    return await ctx.customCreateProjectDialog({
+      parentWindow: ctx.windows.mainWindow,
+      templates: sanitized
+    });
+  }).handle(ProjectsChannel.Create, async (_event, ...args) => {
+    const [raw] = args;
+    if (!raw || typeof raw !== "object") {
+      throw new Error("projects:create expects a CreateProjectInput object");
+    }
+    const input = raw;
+    let project;
+    try {
+      project = await createProject(input, {
+        templates: ctx.projectTemplates ?? [],
+        projectsProvider: ctx.projectsProvider
+      });
+    } catch (err) {
+      await dialog.showMessageBox(ctx.windows.mainWindow, {
+        type: "error",
+        title: "\u521B\u5EFA\u9879\u76EE\u5931\u8D25",
+        message: "\u65E0\u6CD5\u521B\u5EFA\u9879\u76EE",
+        detail: err instanceof Error ? err.message : String(err),
+        buttons: ["\u786E\u5B9A"]
+      });
+      throw err;
+    }
+    try {
+      const settings = loadWorkbenchSettings();
+      const newBase = path11.dirname(input.path);
+      if (newBase && settings.lastCreateBaseDir !== newBase) {
+        saveWorkbenchSettings({ ...settings, lastCreateBaseDir: newBase });
+      }
+    } catch (err) {
+      console.warn("[projects:create] failed to persist lastCreateBaseDir", err);
+    }
+    return project;
+  }).handle(ProjectsChannel.GetCreateDefaults, () => {
+    const settings = loadWorkbenchSettings();
+    const baseDir = settings.lastCreateBaseDir ?? safeAppPath("documents") ?? safeAppPath("home") ?? "";
+    return { baseDir };
   });
-  ipcMain5.handle(
-    ProjectsChannel.Add,
-    (_, dirPath) => ctx.workspace.addProject(dirPath)
-  );
-  ipcMain5.handle(
-    ProjectsChannel.Remove,
-    (_, dirPath) => ctx.workspace.removeProject(dirPath)
-  );
 }
+function safeAppPath(name) {
+  try {
+    return app8.getPath(name);
+  } catch {
+    return null;
+  }
+}
+var projectsModule = {
+  setup: (ctx) => registerProjectsIpc(ctx)
+};
 
 // src/main/ipc/session.ts
-import { ipcMain as ipcMain6 } from "electron";
 function registerSessionIpc(ctx) {
-  ipcMain6.handle(
-    ProjectChannel.Open,
-    (_, projectPath) => ctx.workspace.openProject(projectPath)
-  );
-  ipcMain6.handle(
-    ProjectChannel.GetPages,
-    (_, projectPath) => ctx.workspace.getProjectPages(projectPath)
-  );
-  ipcMain6.handle(
-    ProjectChannel.GetCompileConfig,
-    (_, projectPath) => ctx.workspace.getCompileConfig(projectPath)
-  );
-  ipcMain6.handle(
-    ProjectChannel.SaveCompileConfig,
-    (_, projectPath, config) => ctx.workspace.saveCompileConfig(projectPath, config)
-  );
-  ipcMain6.handle(ProjectChannel.Close, () => ctx.workspace.closeProject());
+  return new IpcRegistry(ctx.senderPolicy).handle(ProjectChannel.Open, (_, ...args) => {
+    const [projectPath] = validate(ProjectChannel.Open, ProjectOpenSchema, args);
+    return ctx.workspace.openProject(projectPath);
+  }).handle(ProjectChannel.GetPages, (_, ...args) => {
+    const [projectPath] = validate(ProjectChannel.GetPages, ProjectGetPagesSchema, args);
+    return ctx.workspace.getProjectPages(projectPath);
+  }).handle(ProjectChannel.GetCompileConfig, (_, ...args) => {
+    const [projectPath] = validate(
+      ProjectChannel.GetCompileConfig,
+      ProjectGetCompileConfigSchema,
+      args
+    );
+    return ctx.workspace.getCompileConfig(projectPath);
+  }).handle(ProjectChannel.SaveCompileConfig, (_, ...args) => {
+    const [projectPath, config] = validate(
+      ProjectChannel.SaveCompileConfig,
+      ProjectSaveCompileConfigSchema,
+      args
+    );
+    return ctx.workspace.saveCompileConfig(projectPath, config);
+  }).handle(ProjectChannel.Close, () => {
+    return ctx.workspace.closeProject();
+  }).handle(ProjectChannel.CaptureThumbnail, (_, ...args) => {
+    const [projectPath] = validate(
+      ProjectChannel.CaptureThumbnail,
+      ProjectCaptureThumbnailSchema,
+      args
+    );
+    return ctx.workspace.captureThumbnail(projectPath);
+  }).handle(ProjectChannel.GetThumbnail, (_, ...args) => {
+    const [projectPath] = validate(
+      ProjectChannel.GetThumbnail,
+      ProjectGetThumbnailSchema,
+      args
+    );
+    return ctx.workspace.getThumbnail(projectPath);
+  });
+}
+var sessionModule = {
+  setup: (ctx) => registerSessionIpc(ctx)
+};
+
+// src/main/ipc/settings.ts
+import { app as app9 } from "electron";
+
+// src/main/services/mcp/status.ts
+var status = { running: false, port: null, error: null };
+function getMcpStatus() {
+  return { ...status };
+}
+function recordMcpStarted(port) {
+  status = { running: true, port, error: null };
+}
+function recordMcpFailed(error) {
+  status = { running: false, port: null, error };
+}
+function recordMcpStopped() {
+  status = { running: false, port: null, error: null };
 }
 
 // src/main/ipc/settings.ts
-import { app as app7, ipcMain as ipcMain7 } from "electron";
 function registerSettingsIpc(ctx) {
-  ipcMain7.handle(WorkbenchSettingsChannel.Get, () => {
+  return new IpcRegistry(ctx.senderPolicy).handle(WorkbenchSettingsChannel.Get, () => {
     return loadWorkbenchSettings();
-  });
-  ipcMain7.handle(WorkbenchSettingsChannel.Save, (_, settings) => {
+  }).handle(WorkbenchSettingsChannel.Save, (_, ...args) => {
+    const [settings] = validate(
+      WorkbenchSettingsChannel.Save,
+      WorkbenchSettingsSaveSchema,
+      args
+    );
     saveWorkbenchSettings(settings);
     applyTheme(settings.theme ?? "system");
     return { success: true };
-  });
-  ipcMain7.handle(WorkbenchSettingsChannel.SetTheme, (_, theme) => {
+  }).handle(WorkbenchSettingsChannel.SetTheme, (_, ...args) => {
+    const [theme] = validate(
+      WorkbenchSettingsChannel.SetTheme,
+      WorkbenchSettingsSetThemeSchema,
+      args
+    );
     applyTheme(theme);
-  });
-  ipcMain7.handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
+  }).handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
     const settings = loadWorkbenchSettings();
-    const switchValue = app7.commandLine.getSwitchValue("remote-debugging-port");
-    const implicitDevDefault = !app7.isPackaged && !settings.cdp.enabled && switchValue === "9222";
+    const switchValue = app9.commandLine.getSwitchValue("remote-debugging-port");
+    const implicitDevDefault = !app9.isPackaged && !settings.cdp.enabled && switchValue === String(DEFAULT_CDP_PORT);
     return {
       configured: settings.cdp.enabled,
       port: settings.cdp.port,
@@ -1161,62 +1936,94 @@ function registerSettingsIpc(ctx) {
       activePort: switchValue ? parseInt(switchValue, 10) : null,
       implicitDevDefault
     };
-  });
-  ipcMain7.handle(WorkbenchSettingsChannel.SetVisible, async (_, visible) => {
+  }).handle(WorkbenchSettingsChannel.GetMcpStatus, () => {
+    const settings = loadWorkbenchSettings();
+    const runtime = getMcpStatus();
+    return {
+      configured: settings.mcp.enabled,
+      configuredPort: settings.mcp.port,
+      running: runtime.running,
+      activePort: runtime.port,
+      error: runtime.error
+    };
+  }).handle(WorkbenchSettingsChannel.SetVisible, async (_, ...args) => {
+    const [visible] = validate(
+      WorkbenchSettingsChannel.SetVisible,
+      WorkbenchSettingsSetVisibleSchema,
+      args
+    );
     if (visible) {
       await openSettingsWindow(ctx);
     } else {
-      ctx.workbenchSettingsWindow?.close();
+      ctx.windows.closeSettingsWindow();
     }
-  });
-  ipcMain7.handle(SettingsChannel.SetVisible, async (_, visible) => {
+  }).handle(SettingsChannel.SetVisible, async (_, ...args) => {
+    const [visible] = validate(SettingsChannel.SetVisible, SettingsSetVisibleSchema, args);
     if (visible) {
       await ctx.views.showSettings();
+      const projectPath = ctx.workspace.getProjectPath();
       ctx.notify.settingsInit({
-        projectPath: ctx.workspace.getProjectPath(),
-        config: ctx.workspace.getCompileConfig(ctx.workspace.getProjectPath()),
-        projectSettings: ctx.workspace.getProjectSettings(ctx.workspace.getProjectPath())
+        projectPath,
+        config: await ctx.workspace.getCompileConfig(projectPath),
+        projectSettings: ctx.workspace.getProjectSettings(projectPath)
       });
     } else {
       ctx.views.hideSettings();
       ctx.notify.settingsClosed();
     }
-  });
-  ipcMain7.on(SettingsChannel.ConfigChanged, (_, config) => {
-    if (ctx.workspace.getProjectPath()) {
-      ctx.workspace.saveCompileConfig(ctx.workspace.getProjectPath(), config);
+  }).on(SettingsChannel.ConfigChanged, async (_, ...args) => {
+    const [config] = validate(
+      SettingsChannel.ConfigChanged,
+      SettingsConfigChangedSchema,
+      args
+    );
+    const projectPath = ctx.workspace.getProjectPath();
+    if (projectPath) {
+      await ctx.workspace.saveCompileConfig(projectPath, config);
     }
     ctx.notify.settingsChanged(config);
+  }).on(SettingsChannel.ProjectSettingsChanged, (_, ...args) => {
+    const [patch] = validate(
+      SettingsChannel.ProjectSettingsChanged,
+      SettingsProjectSettingsChangedSchema,
+      args
+    );
+    ctx.workspace.updateProjectSettings(
+      ctx.workspace.getProjectPath(),
+      patch
+    );
   });
-  ipcMain7.on(
-    SettingsChannel.ProjectSettingsChanged,
-    (_, patch) => {
-      ctx.workspace.updateProjectSettings(ctx.workspace.getProjectPath(), patch);
-    }
-  );
 }
+var settingsModule = {
+  setup: (ctx) => registerSettingsIpc(ctx)
+};
 
 // src/main/ipc/toolbar.ts
-import { ipcMain as ipcMain8 } from "electron";
 function registerToolbarIpc(ctx) {
-  ipcMain8.handle(ToolbarChannel.GetActions, async () => {
+  return new IpcRegistry(ctx.senderPolicy).handle(ToolbarChannel.GetActions, async () => {
     if (ctx.toolbarActions) return ctx.toolbarActions();
     return [];
   });
 }
 
+// src/main/ipc/simulator-module.ts
+var simulatorModule = {
+  setup: (ctx) => {
+    const reg = new DisposableRegistry();
+    reg.add(registerSimulatorIpc(ctx));
+    reg.add(registerPanelsIpc(ctx));
+    reg.add(registerToolbarIpc(ctx));
+    return reg;
+  }
+};
+
 // src/main/services/automation/index.ts
-import { ipcMain as ipcMain9 } from "electron";
 import { WebSocketServer } from "ws";
 
 // src/main/services/automation/exec.ts
-import { webContents as webContents3 } from "electron";
 function getSimulator(ctx) {
-  const simWcId = ctx.views.getSimulatorWebContentsId();
-  if (!ctx.workspace.hasActiveSession() || simWcId == null) return null;
-  const sim = webContents3.fromId(simWcId);
-  if (!sim || sim.isDestroyed()) return null;
-  return sim;
+  if (!ctx.workspace.hasActiveSession()) return null;
+  return ctx.views.getSimulatorWebContents();
 }
 async function evalInSim(ctx, expression) {
   const sim = getSimulator(ctx);
@@ -1224,8 +2031,11 @@ async function evalInSim(ctx, expression) {
   return sim.executeJavaScript(expression);
 }
 function buildElAccess(ref, varName = "el") {
-  const escaped = ref.selector.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  return `const ${varName} = _doc.querySelectorAll('${escaped}')[${ref.index}]`;
+  return `const ${varName} = _doc.querySelectorAll(${JSON.stringify(ref.selector)})[${ref.index}]`;
+}
+function evalInElement(ctx, ref, body, varName = "el") {
+  return evalInSim(ctx, inIframe(`${buildElAccess(ref, varName)}
+${body}`));
 }
 function inIframe(code) {
   return `(() => {
@@ -1245,47 +2055,57 @@ toolHandlers["Tool.close"] = async (ctx) => {
   return {};
 };
 
+// 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 };
+}
+
 // src/main/services/automation/handlers/app.ts
 var appHandlers = {};
+async function readRoute(ctx) {
+  const { search } = await evalInSim(
+    ctx,
+    `({ search: location.search })`
+  );
+  return parseLocationRoute(search);
+}
 appHandlers["App.getCurrentPage"] = async (ctx) => {
-  const hash = await evalInSim(ctx, "location.hash");
-  const clean = hash.replace(/^#/, "");
-  const qIdx = clean.indexOf("?");
-  const pathPart = qIdx >= 0 ? clean.substring(0, qIdx) : clean;
-  const queryPart = qIdx >= 0 ? clean.substring(qIdx + 1) : "";
-  let pagePath;
-  if (pathPart.includes("|")) {
-    const parts = pathPart.split("|");
-    pagePath = parts[parts.length - 1] ?? "";
-  } else {
-    const slashIdx = pathPart.indexOf("/");
-    pagePath = slashIdx >= 0 ? pathPart.substring(slashIdx + 1) : pathPart;
-  }
-  const query = {};
-  if (queryPart) {
-    for (const pair of queryPart.split("&")) {
-      const [k, v] = pair.split("=");
-      if (k) query[k] = decodeURIComponent(v || "");
-    }
-  }
+  const route = await readRoute(ctx);
   const iframeCount = await evalInSim(ctx, `document.querySelectorAll('iframe').length`);
-  return { pageId: iframeCount, path: pagePath, query };
+  return {
+    pageId: iframeCount,
+    path: route?.current.pagePath ?? "",
+    query: route?.current.query ?? {}
+  };
 };
 appHandlers["App.getPageStack"] = async (ctx) => {
-  const hash = await evalInSim(ctx, "location.hash");
-  const clean = hash.replace(/^#/, "").replace(/\?.*$/, "");
+  const route = await readRoute(ctx);
   const pageStack = [];
-  if (clean.includes("|")) {
-    const parts = clean.split("|");
-    for (let i = 1; i < parts.length; i++) {
-      pageStack.push({ pageId: i, path: parts[i] ?? "", query: {} });
-    }
-  } else {
-    const slashIdx = clean.indexOf("/");
-    const currentPath = slashIdx >= 0 ? clean.substring(slashIdx + 1) : clean;
-    if (currentPath) {
-      pageStack.push({ pageId: 1, path: currentPath, query: {} });
-    }
+  if (!route) return { pageStack };
+  pageStack.push({ pageId: 1, path: route.entry.pagePath, query: route.entry.query });
+  if (route.current.pagePath !== route.entry.pagePath) {
+    pageStack.push({ pageId: 2, path: route.current.pagePath, query: route.current.query });
   }
   return { pageStack };
 };
@@ -1298,18 +2118,29 @@ appHandlers["App.callWxMethod"] = async (ctx, params) => {
     if (url) {
       const cleanUrl = url.startsWith("/") ? url : `/${url}`;
       const clicked = await evalInSim(ctx, inIframe(`
-        const el = _doc.querySelector('[data-path="${cleanUrl}"]')
+        const path = ${JSON.stringify(cleanUrl)}
+        const el = Array.from(_doc.querySelectorAll('[data-path]'))
+          .find(e => e.getAttribute('data-path') === path)
         if (el) { el.click(); return true }
         return false
       `)).catch(() => false);
       if (!clicked) {
-        const hash = await evalInSim(ctx, "location.hash");
-        const appId = hash.replace(/^#/, "").split("/")[0];
-        if (method === "reLaunch" || method === "redirectTo") {
-          await evalInSim(ctx, `location.href = location.pathname + '#${appId}${cleanUrl}'`);
-        } else {
-          await evalInSim(ctx, `location.hash = '#${appId}${cleanUrl}'`);
-        }
+        const apiName = JSON.stringify(method);
+        const urlJson = JSON.stringify(cleanUrl);
+        await evalInSim(
+          ctx,
+          `(() => {
+            const iframes = Array.from(document.querySelectorAll('iframe'))
+            for (const f of iframes) {
+              try {
+                if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
+                  f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
+                  return
+                }
+              } catch (_) {}
+            }
+          })()`
+        );
       }
       await new Promise((r) => setTimeout(r, 2e3));
     }
@@ -1444,109 +2275,97 @@ pageHandlers["Page.getWindowProperties"] = async (ctx, params) => {
 var elementHandlers = {};
 elementHandlers["Element.tap"] = async (ctx, params) => {
   const ref = getElementRef(params);
-  await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  await evalInElement(ctx, ref, `
     if (!el) throw new Error('Element not found')
     el.click()
-  `));
+  `);
   return {};
 };
 elementHandlers["Element.triggerEvent"] = async (ctx, params) => {
   const ref = getElementRef(params);
   const type = params.type;
   const detail = params.detail || {};
-  await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  await evalInElement(ctx, ref, `
     if (!el) throw new Error('Element not found')
     el.dispatchEvent(new CustomEvent('${type}', { detail: ${JSON.stringify(detail)}, bubbles: true }))
-  `));
+  `);
   return {};
 };
 elementHandlers["Element.touchstart"] = async (ctx, params) => {
   const ref = getElementRef(params);
-  await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchstart', { bubbles: true }))
-  `));
+  `);
   return {};
 };
 elementHandlers["Element.touchmove"] = async (ctx, params) => {
   const ref = getElementRef(params);
-  await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchmove', { bubbles: true }))
-  `));
+  `);
   return {};
 };
 elementHandlers["Element.touchend"] = async (ctx, params) => {
   const ref = getElementRef(params);
-  await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  await evalInElement(ctx, ref, `
     if (el) el.dispatchEvent(new TouchEvent('touchend', { bubbles: true }))
-  `));
+  `);
   return {};
 };
 elementHandlers["Element.getDOMProperties"] = async (ctx, params) => {
   const ref = getElementRef(params);
   const names = params.names;
-  const properties = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  const properties = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => null))}
     return ${JSON.stringify(names)}.map(n => el[n])
-  `));
+  `);
   return { properties };
 };
 elementHandlers["Element.getAttributes"] = async (ctx, params) => {
   const ref = getElementRef(params);
   const names = params.names;
-  const attributes = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  const attributes = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => null))}
     return ${JSON.stringify(names)}.map(n => el.getAttribute(n))
-  `));
+  `);
   return { attributes };
 };
 elementHandlers["Element.getStyles"] = async (ctx, params) => {
   const ref = getElementRef(params);
   const names = params.names;
-  const styles = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  const styles = await evalInElement(ctx, ref, `
     if (!el) return ${JSON.stringify(names.map(() => ""))}
     const cs = getComputedStyle(el)
     return ${JSON.stringify(names)}.map(n => cs.getPropertyValue(n))
-  `));
+  `);
   return { styles };
 };
 elementHandlers["Element.getWXML"] = async (ctx, params) => {
   const ref = getElementRef(params);
   const type = params.type || "inner";
   const prop = type === "outer" ? "outerHTML" : "innerHTML";
-  const wxml = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  const wxml = await evalInElement(ctx, ref, `
     return el ? el.${prop} : ''
-  `));
+  `);
   return { wxml };
 };
 elementHandlers["Element.getOffset"] = async (ctx, params) => {
   const ref = getElementRef(params);
-  return evalInSim(ctx, inIframe(`
-    ${buildElAccess(ref)}
+  return evalInElement(ctx, ref, `
     if (!el) return { left: 0, top: 0 }
     const r = el.getBoundingClientRect()
     return { left: r.left, top: r.top }
-  `));
+  `);
 };
 elementHandlers["Element.getElement"] = async (ctx, params) => {
   const parentRef = getElementRef(params);
   const selector = params.selector;
-  const escaped = selector.replace(/'/g, "\\'");
-  const info = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(parentRef, "parent")}
+  const info = await evalInElement(ctx, parentRef, `
     if (!parent) return null
-    const child = parent.querySelector('${escaped}')
+    const child = parent.querySelector(${JSON.stringify(selector)})
     if (!child) return null
     return { tagName: child.tagName.toLowerCase() }
-  `));
+  `, "parent");
   if (!info) throw new Error(`Child element not found: ${selector}`);
   const combinedSelector = `${parentRef.selector} ${selector}`;
   const elementId = registerElement(combinedSelector, 0, parentRef.pageId);
@@ -1555,14 +2374,12 @@ elementHandlers["Element.getElement"] = async (ctx, params) => {
 elementHandlers["Element.getElements"] = async (ctx, params) => {
   const parentRef = getElementRef(params);
   const selector = params.selector;
-  const escaped = selector.replace(/'/g, "\\'");
-  const items = await evalInSim(ctx, inIframe(`
-    ${buildElAccess(parentRef, "parent")}
+  const items = await evalInElement(ctx, parentRef, `
     if (!parent) return []
-    return Array.from(parent.querySelectorAll('${escaped}')).map(el => ({
+    return Array.from(parent.querySelectorAll(${JSON.stringify(selector)})).map(el => ({
       tagName: el.tagName.toLowerCase(),
     }))
-  `));
+  `, "parent");
   const combinedSelector = `${parentRef.selector} ${selector}`;
   return {
     elements: items.map((item, i) => ({
@@ -1595,7 +2412,6 @@ var handlers = {
   ...elementHandlers
 };
 var currentPort = null;
-var portIpcRegistered = false;
 async function startAutomationServer(ctx, port = 0) {
   const wss = new WebSocketServer({ port });
   const clients = /* @__PURE__ */ new Set();
@@ -1606,10 +2422,10 @@ async function startAutomationServer(ctx, port = 0) {
   const addr = wss.address();
   const resolvedPort = typeof addr === "object" && addr ? addr.port : port;
   currentPort = resolvedPort;
-  if (!portIpcRegistered) {
-    portIpcRegistered = true;
-    ipcMain9.handle(AutomationChannel.GetPort, () => currentPort);
-  }
+  const portIpc = new IpcRegistry(ctx.senderPolicy);
+  portIpc.handle(AutomationChannel.GetPort, () => {
+    return currentPort;
+  });
   function broadcast(event) {
     const msg = JSON.stringify(event);
     for (const ws of clients) {
@@ -1617,14 +2433,46 @@ async function startAutomationServer(ctx, port = 0) {
     }
   }
   let consoleForwardingSetup = false;
+  let pollInterval = null;
+  let pollStopTimer = null;
+  let attachedSim = null;
+  let ipcMessageHostHandler = null;
+  let simDestroyedHandler = null;
+  function detachConsoleForwarding() {
+    if (attachedSim) {
+      if (ipcMessageHostHandler) {
+        try {
+          if (!attachedSim.isDestroyed()) {
+            ;
+            attachedSim.removeListener("ipc-message-host", ipcMessageHostHandler);
+          }
+        } catch {
+        }
+      }
+      if (simDestroyedHandler) {
+        try {
+          if (!attachedSim.isDestroyed()) {
+            attachedSim.removeListener("destroyed", simDestroyedHandler);
+          }
+        } catch {
+        }
+      }
+    }
+    attachedSim = null;
+    ipcMessageHostHandler = null;
+    simDestroyedHandler = null;
+  }
   function setupConsoleForwarding() {
     if (consoleForwardingSetup) return;
     consoleForwardingSetup = true;
-    const check = setInterval(() => {
+    pollInterval = setInterval(() => {
       const sim = getSimulator(ctx);
       if (!sim) return;
-      clearInterval(check);
-      sim.on("ipc-message-host", (_event, channel, data) => {
+      if (pollInterval) {
+        clearInterval(pollInterval);
+        pollInterval = null;
+      }
+      const onIpcMessageHost = (_event, channel, data) => {
         if (channel === SimulatorChannel.Console) {
           const logData = data;
           broadcast({
@@ -1632,9 +2480,26 @@ async function startAutomationServer(ctx, port = 0) {
             params: { type: logData.level || "log", args: logData.args || [] }
           });
         }
-      });
+      };
+      const onSimDestroyed = () => {
+        attachedSim = null;
+        ipcMessageHostHandler = null;
+        simDestroyedHandler = null;
+        consoleForwardingSetup = false;
+      };
+      attachedSim = sim;
+      ipcMessageHostHandler = onIpcMessageHost;
+      simDestroyedHandler = onSimDestroyed;
+      sim.on("ipc-message-host", onIpcMessageHost);
+      sim.once("destroyed", onSimDestroyed);
     }, 1e3);
-    setTimeout(() => clearInterval(check), 3e4);
+    pollStopTimer = setTimeout(() => {
+      if (pollInterval) {
+        clearInterval(pollInterval);
+        pollInterval = null;
+      }
+      pollStopTimer = null;
+    }, 3e4);
   }
   wss.on("connection", (ws) => {
     clients.add(ws);
@@ -1665,7 +2530,24 @@ async function startAutomationServer(ctx, port = 0) {
   });
   return {
     close: () => {
+      if (pollInterval) {
+        clearInterval(pollInterval);
+        pollInterval = null;
+      }
+      if (pollStopTimer) {
+        clearTimeout(pollStopTimer);
+        pollStopTimer = null;
+      }
+      detachConsoleForwarding();
+      for (const ws of clients) {
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+      clients.clear();
       if (currentPort === resolvedPort) currentPort = null;
+      void portIpc.dispose();
       wss.close();
     },
     port: resolvedPort
@@ -1683,7 +2565,7 @@ import CDP from "chrome-remote-interface";
 var SIMULATOR_URL_PATTERN = "localhost:7788";
 var MAX_BUFFER = 500;
 var RECONNECT_INTERVAL_MS = 3e3;
-var cdpPort = 9222;
+var cdpPort = DEFAULT_CDP_PORT;
 var targets = {
   simulator: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] },
   workbench: { client: null, connected: false, timer: null, consoleLogs: [], networkRequests: [] }
@@ -1824,7 +2706,7 @@ function getClient(kind) {
 }
 
 // src/main/services/mcp/tool-registry.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 function registerCommonTargetTools(server, kind) {
   const descriptions = kind === "simulator" ? {
     screenshot: "Take a screenshot of the simulator webview",
@@ -1845,9 +2727,9 @@ function registerCommonTargetTools(server, kind) {
     return { content: [{ type: "image", data, mimeType: "image/png" }] };
   });
   server.tool(`${kind}_console_logs`, descriptions.consoleLogs, {
-    limit: z.number().optional().default(50).describe("Maximum number of log entries"),
-    level: z.enum(["error", "warning", "warn", "info", "log", "debug"]).optional().describe("Only return entries with this level"),
-    sinceTimestamp: z.string().optional().describe("ISO timestamp; only return entries at or after this time")
+    limit: z2.number().optional().default(50).describe("Maximum number of log entries"),
+    level: z2.enum(["error", "warning", "warn", "info", "log", "debug"]).optional().describe("Only return entries with this level"),
+    sinceTimestamp: z2.string().optional().describe("ISO timestamp; only return entries at or after this time")
   }, async ({ limit, level, sinceTimestamp }) => {
     getClient(kind);
     let entries = getTargetState(kind).consoleLogs;
@@ -1862,7 +2744,7 @@ function registerCommonTargetTools(server, kind) {
   });
   if (kind !== "workbench") {
     server.tool(`${kind}_evaluate`, descriptions.evaluate, {
-      expression: z.string().describe("JavaScript expression to evaluate")
+      expression: z2.string().describe("JavaScript expression to evaluate")
     }, async ({ expression }) => {
       const c = getClient(kind);
       const result = await c.Runtime.evaluate({ expression, returnByValue: true, awaitPromise: true });
@@ -1875,15 +2757,15 @@ ${JSON.stringify(result.exceptionDetails, null, 2)}` }], isError: true };
     });
   }
   server.tool(`${kind}_get_dom`, descriptions.getDom, {
-    depth: z.number().optional().default(3).describe("Maximum depth")
+    depth: z2.number().optional().default(3).describe("Maximum depth")
   }, async ({ depth }) => {
     const c = getClient(kind);
     const { root } = await c.DOM.getDocument({ depth });
     return { content: [{ type: "text", text: JSON.stringify(root, null, 2) }] };
   });
   server.tool(`${kind}_network_log`, descriptions.networkLog, {
-    limit: z.number().optional().default(20).describe("Maximum number of entries"),
-    minStatus: z.number().optional().describe("Only return entries with status >= minStatus (status 0 = failed before response is included when minStatus >= 400)")
+    limit: z2.number().optional().default(20).describe("Maximum number of entries"),
+    minStatus: z2.number().optional().describe("Only return entries with status >= minStatus (status 0 = failed before response is included when minStatus >= 400)")
   }, async ({ limit, minStatus }) => {
     getClient(kind);
     let entries = getTargetState(kind).networkRequests;
@@ -2126,11 +3008,11 @@ function registerContextTools(server) {
 }
 
 // src/main/services/mcp/tools/simulator-tools.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 function registerSimulatorTools(server) {
   server.tool("simulator_navigate", "Navigate the simulator to a URL, or reload the current page", {
-    url: z2.string().optional().describe("URL to navigate to"),
-    reload: z2.boolean().optional().describe("If true, reload current page instead of navigating")
+    url: z3.string().optional().describe("URL to navigate to"),
+    reload: z3.boolean().optional().describe("If true, reload current page instead of navigating")
   }, async ({ url, reload }) => {
     const c = getClient("simulator");
     if (reload) {
@@ -2145,15 +3027,15 @@ function registerSimulatorTools(server) {
     return { content: [{ type: "text", text: "Error: either url or reload is required" }], isError: true };
   });
   server.tool("simulator_input", "Dispatch input to the simulator. `tap_coord` requires x and y. `tap_selector` requires selector and optional nth. `type` requires selector and text. `scroll` requires x, y, deltaX, and deltaY. `key` is best-effort for common keys such as Enter, Escape, Tab, Arrow* and Space.", {
-    action: z2.enum(["tap_coord", "tap_selector", "type", "scroll", "key"]).describe("Input action to dispatch"),
-    x: z2.number().optional().describe("Viewport x coordinate for `tap_coord` or `scroll`"),
-    y: z2.number().optional().describe("Viewport y coordinate for `tap_coord` or `scroll`"),
-    selector: z2.string().optional().describe("CSS selector for `tap_selector` or `type`"),
-    nth: z2.number().int().optional().describe("Zero-based index when selector matches multiple elements; defaults to 0"),
-    text: z2.string().optional().describe("Text to insert for `type`"),
-    key: z2.string().optional().describe("Best-effort keyboard key name for `key`; common keys such as Enter, Escape, Tab, Arrow* and Space work best"),
-    deltaX: z2.number().optional().describe("Horizontal wheel delta for `scroll`"),
-    deltaY: z2.number().optional().describe("Vertical wheel delta for `scroll`")
+    action: z3.enum(["tap_coord", "tap_selector", "type", "scroll", "key"]).describe("Input action to dispatch"),
+    x: z3.number().optional().describe("Viewport x coordinate for `tap_coord` or `scroll`"),
+    y: z3.number().optional().describe("Viewport y coordinate for `tap_coord` or `scroll`"),
+    selector: z3.string().optional().describe("CSS selector for `tap_selector` or `type`"),
+    nth: z3.number().int().optional().describe("Zero-based index when selector matches multiple elements; defaults to 0"),
+    text: z3.string().optional().describe("Text to insert for `type`"),
+    key: z3.string().optional().describe("Best-effort keyboard key name for `key`; common keys such as Enter, Escape, Tab, Arrow* and Space work best"),
+    deltaX: z3.number().optional().describe("Horizontal wheel delta for `scroll`"),
+    deltaY: z3.number().optional().describe("Vertical wheel delta for `scroll`")
   }, async ({ action, x, y, selector, nth, text, key, deltaX, deltaY }) => {
     const c = getClient("simulator");
     const err = (msg) => ({ content: [{ type: "text", text: `Error: ${msg}` }], isError: true });
@@ -2301,94 +3183,280 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
   httpServer.on("error", (err) => {
     if (err.code === "EADDRINUSE") {
       console.warn(`[MCP] Port ${mcpPort} already in use \u2014 MCP server not started`);
+      recordMcpFailed("port-in-use");
     } else {
       console.error("[MCP] Server error:", err);
+      recordMcpFailed(err.message);
     }
   });
   httpServer.listen(mcpPort, "127.0.0.1", () => {
     console.log(`[MCP] SSE server listening on http://127.0.0.1:${mcpPort}/sse`);
+    recordMcpStarted(mcpPort);
+  });
+  return toDisposable(() => {
+    transports.clear();
+    httpServer.close();
+    recordMcpStopped();
   });
 }
 
 // src/main/services/simulator-storage/index.ts
-import { app as app8, ipcMain as ipcMain10, webContents as wcStatic } from "electron";
-var attachedWc = null;
-var hostWc = null;
+import { app as app10, webContents as wcStatic } from "electron";
 function isSimulatorWebview(wc) {
   if (wc.isDestroyed()) return false;
   if (wc.getType() !== "webview") return false;
   return wc.getURL().includes("simulator.html");
 }
-function detach() {
-  if (!attachedWc) return;
-  const wc = attachedWc;
-  attachedWc = null;
+function safeOff(target, event, fn) {
   try {
-    if (!wc.isDestroyed() && wc.debugger.isAttached()) {
-      wc.debugger.detach();
-    }
+    if (target.isDestroyed?.()) return;
+    target.removeListener(event, fn);
   } catch {
   }
 }
-async function attachToSim(wc) {
-  if (attachedWc === wc) return;
-  if (wc.isDestroyed()) return;
-  detach();
-  try {
-    if (!wc.debugger.isAttached()) {
-      wc.debugger.attach("1.3");
+function setupSimulatorStorage(host, options) {
+  const registry = new DisposableRegistry();
+  const getActiveAppId = options.getActiveAppId;
+  let attachedWc = null;
+  let attachDisposables = null;
+  let cachedOrigin = null;
+  function activePrefix() {
+    const appId = getActiveAppId();
+    return appId ? `${appId}_` : null;
+  }
+  function detachFromSim() {
+    if (!attachedWc) return;
+    const wc = attachedWc;
+    attachedWc = null;
+    cachedOrigin = null;
+    const ad = attachDisposables;
+    attachDisposables = null;
+    if (ad) void ad.disposeAll().catch(() => {
+    });
+    try {
+      if (!wc.isDestroyed() && wc.debugger.isAttached()) {
+        wc.debugger.detach();
+      }
+    } catch {
+    }
+  }
+  async function attachToSim(wc) {
+    if (attachedWc === wc) return;
+    if (wc.isDestroyed()) return;
+    detachFromSim();
+    try {
+      if (!wc.debugger.isAttached()) {
+        wc.debugger.attach("1.3");
+      }
+      await wc.debugger.sendCommand("DOMStorage.enable");
+      const attach = new DisposableRegistry();
+      attachDisposables = attach;
+      const onMessage = (_event, method, params) => forwardCdpMessage(method, params);
+      wc.debugger.on("message", onMessage);
+      attach.add(() => safeOff(wc.debugger, "message", onMessage));
+      const onDetach = () => {
+        if (attachedWc === wc) attachedWc = null;
+      };
+      wc.debugger.on("detach", onDetach);
+      attach.add(() => safeOff(wc.debugger, "detach", onDetach));
+      const onDestroyed = () => {
+        if (attachedWc === wc) {
+          attachedWc = null;
+          const ad = attachDisposables;
+          attachDisposables = null;
+          if (ad) void ad.disposeAll().catch(() => {
+          });
+        }
+      };
+      wc.once("destroyed", onDestroyed);
+      attach.add(() => safeOff(wc, "destroyed", onDestroyed));
+      attachedWc = wc;
+    } catch (e) {
+      console.warn("[storage-watcher] attach failed:", e.message);
+    }
+  }
+  function forwardCdpMessage(method, params) {
+    if (host.isDestroyed()) return;
+    const p = params;
+    const prefix = activePrefix();
+    let evt;
+    switch (method) {
+      case "DOMStorage.domStorageItemAdded": {
+        const key = String(p.key);
+        if (prefix && !key.startsWith(prefix)) return;
+        evt = { type: "added", key, newValue: String(p.newValue ?? "") };
+        break;
+      }
+      case "DOMStorage.domStorageItemUpdated": {
+        const key = String(p.key);
+        if (prefix && !key.startsWith(prefix)) return;
+        evt = {
+          type: "updated",
+          key,
+          oldValue: String(p.oldValue ?? ""),
+          newValue: String(p.newValue ?? "")
+        };
+        break;
+      }
+      case "DOMStorage.domStorageItemRemoved": {
+        const key = String(p.key);
+        if (prefix && !key.startsWith(prefix)) return;
+        evt = { type: "removed", key };
+        break;
+      }
+      case "DOMStorage.domStorageItemsCleared":
+        evt = { type: "cleared" };
+        break;
+      default:
+        return;
     }
-    await wc.debugger.sendCommand("DOMStorage.enable");
-    wc.debugger.on("message", onCdpMessage);
-    wc.debugger.on("detach", () => {
-      if (attachedWc === wc) attachedWc = null;
+    host.send(SimulatorStorageChannel.Event, evt);
+  }
+  async function ensureAttached() {
+    if (attachedWc && !attachedWc.isDestroyed()) return;
+    const sim = findSimulatorWebContents();
+    if (!sim) return;
+    await attachToSim(sim);
+  }
+  async function getStorageId() {
+    if (!attachedWc || attachedWc.isDestroyed()) return null;
+    if (!cachedOrigin) {
+      try {
+        cachedOrigin = String(await attachedWc.executeJavaScript("location.origin"));
+      } catch {
+        return null;
+      }
+    }
+    return { securityOrigin: cachedOrigin, isLocalStorage: true };
+  }
+  async function withStorageWrite(fn) {
+    await ensureAttached();
+    if (!attachedWc || attachedWc.isDestroyed()) {
+      return { ok: false, error: "simulator not attached" };
+    }
+    const storageId = await getStorageId();
+    if (!storageId) return { ok: false, error: "failed to resolve simulator origin" };
+    try {
+      return await fn({ wc: attachedWc, storageId });
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+  async function withStorageRead(fallback, fn) {
+    await ensureAttached();
+    if (!attachedWc || attachedWc.isDestroyed()) return fallback;
+    try {
+      const storageId = await getStorageId();
+      if (!storageId) return fallback;
+      return await fn({ wc: attachedWc, storageId });
+    } catch {
+      return fallback;
+    }
+  }
+  function pushSyntheticEvent(evt) {
+    if (host.isDestroyed()) return;
+    const prefix = activePrefix();
+    if (prefix && !evt.key.startsWith(prefix)) return;
+    host.send(SimulatorStorageChannel.Event, evt);
+  }
+  async function setItem(key, value) {
+    return withStorageWrite(async ({ wc, storageId }) => {
+      await wc.debugger.sendCommand("DOMStorage.setDOMStorageItem", { storageId, key, value });
+      pushSyntheticEvent({ type: "added", key, newValue: value });
+      return { ok: true };
     });
-    wc.once("destroyed", () => {
-      if (attachedWc === wc) attachedWc = null;
+  }
+  async function removeItem(key) {
+    return withStorageWrite(async ({ wc, storageId }) => {
+      await wc.debugger.sendCommand("DOMStorage.removeDOMStorageItem", { storageId, key });
+      pushSyntheticEvent({ type: "removed", key });
+      return { ok: true };
     });
-    attachedWc = wc;
-  } catch (e) {
-    console.warn("[storage-watcher] attach failed:", e.message);
   }
-}
-function onCdpMessage(_event, method, params) {
-  if (!hostWc || hostWc.isDestroyed()) return;
-  const p = params;
-  let evt;
-  switch (method) {
-    case "DOMStorage.domStorageItemAdded":
-      evt = { type: "added", key: String(p.key), newValue: String(p.newValue ?? "") };
-      break;
-    case "DOMStorage.domStorageItemUpdated":
-      evt = {
-        type: "updated",
-        key: String(p.key),
-        oldValue: String(p.oldValue ?? ""),
-        newValue: String(p.newValue ?? "")
-      };
-      break;
-    case "DOMStorage.domStorageItemRemoved":
-      evt = { type: "removed", key: String(p.key) };
-      break;
-    case "DOMStorage.domStorageItemsCleared":
-      evt = { type: "cleared" };
-      break;
-    default:
-      return;
+  async function clearScoped() {
+    return withStorageWrite(async ({ wc, storageId }) => {
+      const prefix = activePrefix();
+      if (!prefix) {
+        await wc.debugger.sendCommand("DOMStorage.clear", { storageId });
+        return { ok: true };
+      }
+      const result = await wc.debugger.sendCommand("DOMStorage.getDOMStorageItems", {
+        storageId
+      });
+      for (const [key] of result.entries) {
+        if (!key.startsWith(prefix)) continue;
+        await wc.debugger.sendCommand("DOMStorage.removeDOMStorageItem", { storageId, key });
+      }
+      return { ok: true };
+    });
   }
-  hostWc.send(SimulatorStorageChannel.Event, evt);
-}
-async function getSnapshot() {
-  if (!attachedWc || attachedWc.isDestroyed()) return [];
-  try {
-    const origin = await attachedWc.executeJavaScript("location.origin");
-    const result = await attachedWc.debugger.sendCommand("DOMStorage.getDOMStorageItems", {
-      storageId: { securityOrigin: origin, isLocalStorage: true }
+  async function clearAll() {
+    return withStorageWrite(async ({ wc, storageId }) => {
+      await wc.debugger.sendCommand("DOMStorage.clear", { storageId });
+      return { ok: true };
     });
-    return result.entries.map(([key, value]) => ({ key, value }));
-  } catch {
-    return [];
   }
+  async function getSnapshot() {
+    return withStorageRead([], async ({ wc, storageId }) => {
+      const result = await wc.debugger.sendCommand("DOMStorage.getDOMStorageItems", {
+        storageId
+      });
+      const prefix = activePrefix();
+      const filtered = prefix ? result.entries.filter(([key]) => key.startsWith(prefix)) : result.entries;
+      return filtered.map(([key, value]) => ({ key, value }));
+    });
+  }
+  for (const wc of wcStatic.getAllWebContents()) {
+    if (isSimulatorWebview(wc)) {
+      void attachToSim(wc);
+      break;
+    }
+  }
+  const wcSubs = /* @__PURE__ */ new Map();
+  const onWcCreated = (_event, wc) => {
+    const sub = new DisposableRegistry();
+    wcSubs.set(wc, sub);
+    const onFinishLoad = () => {
+      if (isSimulatorWebview(wc)) void attachToSim(wc);
+    };
+    wc.on("did-finish-load", onFinishLoad);
+    sub.add(() => safeOff(wc, "did-finish-load", onFinishLoad));
+    wc.once("destroyed", () => {
+      void sub.disposeAll().catch(() => {
+      });
+      wcSubs.delete(wc);
+    });
+  };
+  app10.on("web-contents-created", onWcCreated);
+  registry.add(() => {
+    app10.removeListener("web-contents-created", onWcCreated);
+  });
+  registry.add(async () => {
+    const subs = Array.from(wcSubs.values());
+    wcSubs.clear();
+    for (const sub of subs) {
+      await sub.disposeAll().catch(() => {
+      });
+    }
+  });
+  const ipc = new IpcRegistry(options.senderPolicy);
+  ipc.handle(SimulatorStorageChannel.GetSnapshot, () => getSnapshot());
+  ipc.handle(SimulatorStorageChannel.GetActivePrefix, () => activePrefix() ?? "");
+  ipc.handle(
+    SimulatorStorageChannel.Set,
+    (_event, payload) => setItem(String(payload?.key ?? ""), String(payload?.value ?? ""))
+  );
+  ipc.handle(
+    SimulatorStorageChannel.Remove,
+    (_event, payload) => removeItem(String(payload?.key ?? ""))
+  );
+  ipc.handle(SimulatorStorageChannel.Clear, () => clearScoped());
+  ipc.handle(SimulatorStorageChannel.ClearAll, () => clearAll());
+  ipc.handle(SimulatorElementChannel.Inspect, (_event, sid) => inspectElement(sid));
+  ipc.handle(SimulatorElementChannel.Clear, () => clearElementInspection());
+  registry.add(ipc);
+  registry.add(() => detachFromSim());
+  return registry;
 }
 function findSimulatorWebContents() {
   for (const wc of wcStatic.getAllWebContents()) {
@@ -2420,30 +3488,9 @@ async function clearElementInspection() {
   } catch {
   }
 }
-function setupSimulatorStorage(host) {
-  hostWc = host;
-  for (const wc of wcStatic.getAllWebContents()) {
-    if (isSimulatorWebview(wc)) {
-      void attachToSim(wc);
-      break;
-    }
-  }
-  app8.on("web-contents-created", (_event, wc) => {
-    wc.on("did-finish-load", () => {
-      if (isSimulatorWebview(wc)) {
-        void attachToSim(wc);
-      }
-    });
-    wc.on("did-navigate-in-page", () => {
-    });
-  });
-  ipcMain10.handle(SimulatorStorageChannel.GetSnapshot, getSnapshot);
-  ipcMain10.handle(SimulatorElementChannel.Inspect, (_event, sid) => inspectElement(sid));
-  ipcMain10.handle(SimulatorElementChannel.Clear, clearElementInspection);
-}
 
 // src/main/services/update/update-manager.ts
-import { app as app9, ipcMain as ipcMain11, shell } from "electron";
+import { app as app11, shell as shell3 } from "electron";
 var UpdateManager = class {
   checker;
   mainWindow;
@@ -2452,23 +3499,17 @@ var UpdateManager = class {
   downloadedPath = null;
   timer = null;
   initialTimer = null;
+  ipc;
   constructor(opts) {
     this.checker = opts.checker;
     this.mainWindow = opts.mainWindow;
-    this.getCurrentVersion = opts.getCurrentVersion ?? (() => app9.getVersion());
+    this.getCurrentVersion = opts.getCurrentVersion ?? (() => app11.getVersion());
+    this.ipc = new IpcRegistry(opts.senderPolicy);
     this.registerIpc();
     this.startPeriodicCheck(opts.checkInterval ?? 60 * 60 * 1e3, opts.initialDelay ?? 5e3);
   }
   registerIpc() {
-    ipcMain11.handle("updates:check", async () => {
-      return this.check();
-    });
-    ipcMain11.handle("updates:download", async () => {
-      return this.download();
-    });
-    ipcMain11.handle("updates:install", async () => {
-      this.install();
-    });
+    this.ipc.handle(UpdateChannel.Check, async () => this.check()).handle(UpdateChannel.Download, async () => this.download()).handle(UpdateChannel.Install, async () => this.install());
   }
   async check() {
     try {
@@ -2491,7 +3532,7 @@ var UpdateManager = class {
     }
     try {
       const filePath = await this.checker.downloadUpdate(this.latestUpdate, (percent) => {
-        this.mainWindow.webContents.send("updates:downloadProgress", { percent });
+        this.mainWindow.webContents.send(UpdateChannel.DownloadProgress, { percent });
       });
       this.downloadedPath = filePath;
       return { success: true, filePath };
@@ -2502,10 +3543,16 @@ var UpdateManager = class {
   }
   install() {
     if (this.downloadedPath) {
-      shell.openPath(this.downloadedPath);
-      app9.quit();
+      shell3.openPath(this.downloadedPath);
+      app11.quit();
     }
   }
+  /**
+   * Tear down timers + IPC handlers. Returns a Promise so callers that need
+   * a settled cleanup (e.g. workbench registry shutdown, the unit-test
+   * lifecycle suite) can await it; calling without await is also safe since
+   * the timer clears + handler removals are scheduled synchronously.
+   */
   dispose() {
     if (this.timer) {
       clearInterval(this.timer);
@@ -2515,9 +3562,7 @@ var UpdateManager = class {
       clearTimeout(this.initialTimer);
       this.initialTimer = null;
     }
-    ipcMain11.removeHandler("updates:check");
-    ipcMain11.removeHandler("updates:download");
-    ipcMain11.removeHandler("updates:install");
+    return this.ipc.dispose();
   }
   startPeriodicCheck(interval, initialDelay) {
     this.initialTimer = setTimeout(() => void this.checkAndNotify(), initialDelay);
@@ -2526,13 +3571,13 @@ var UpdateManager = class {
   async checkAndNotify() {
     const result = await this.check();
     if (result.hasUpdate && result.info) {
-      this.mainWindow.webContents.send("updates:available", result.info);
+      this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
     }
   }
 };
 
 // src/main/services/update/github-release-checker.ts
-import { app as app10 } from "electron";
+import { app as app12 } from "electron";
 
 // src/main/app/app.ts
 var DEFAULT_MODULES = {
@@ -2542,16 +3587,12 @@ var DEFAULT_MODULES = {
   popover: true,
   settings: true
 };
-var MODULE_REGISTRARS = {
-  projects: registerProjectsIpc,
-  session: registerSessionIpc,
-  simulator: (ctx) => {
-    registerSimulatorIpc(ctx);
-    registerPanelsIpc(ctx);
-    registerToolbarIpc(ctx);
-  },
-  popover: registerPopoverIpc,
-  settings: registerSettingsIpc
+var BUILTIN_MODULES = {
+  projects: projectsModule,
+  session: sessionModule,
+  simulator: simulatorModule,
+  popover: popoverModule,
+  settings: settingsModule
 };
 function parseAutoArgs() {
   const argv = process.argv;
@@ -2576,18 +3617,25 @@ function resolveModules(config) {
     ...config.modules
   };
 }
-async function disposeContext(ctx, updateManager) {
-  updateManager?.dispose();
+async function disposeContext(ctx) {
   await ctx.workspace.closeProject();
+  await ctx.registry.dispose().catch((err) => {
+    console.warn("[workbench] dispose registry encountered errors:", err);
+  });
 }
 function createConfiguredMainWindow(config, rendererDir2) {
   const mainWindow = createMainWindow({
     title: config.appName ?? "Dimina DevTools",
-    indexHtml: path6.join(rendererDir2, "entries/main/index.html"),
+    indexHtml: path12.join(rendererDir2, "entries/main/index.html"),
     width: config.window?.width,
     height: config.window?.height,
     minWidth: config.window?.minWidth,
-    minHeight: config.window?.minHeight
+    minHeight: config.window?.minHeight,
+    // P1: pass the same preload path the workbench context stores on
+    // ctx.preloadPath so hosts that ship a custom simulator preload are the
+    // ones registered on the persist:simulator session — otherwise the
+    // backstop wouldn't be the host's script.
+    simulatorPreloadPath: config.preloadPath ?? defaultPreloadPath
   });
   if (config.icon) {
     const icon = nativeImage.createFromPath(config.icon);
@@ -2605,13 +3653,21 @@ function createContext(config, mainWindow, rendererDir2) {
     appName: config.appName,
     apiNamespaces: config.apiNamespaces,
     brandingProvider: config.brandingProvider,
-    toolbarActions: config.toolbarActions
+    toolbarActions: config.toolbarActions,
+    // The host-supplied ProjectsProvider / template types in `shared/types`
+    // are structurally compatible with the main-process equivalents —
+    // these casts are safe; we re-narrow at the workspace-service /
+    // create-project-service boundary.
+    projectsProvider: config.projectsProvider,
+    projectTemplates: config.projectTemplates,
+    builtinTemplates: config.builtinTemplates,
+    customCreateProjectDialog: config.customCreateProjectDialog
   });
 }
 function registerBuiltinModules(config, context) {
   const modules = resolveModules(config);
   Object.keys(modules).forEach((moduleId) => {
-    if (modules[moduleId]) MODULE_REGISTRARS[moduleId](context);
+    if (modules[moduleId]) context.registry.add(BUILTIN_MODULES[moduleId].setup(context));
   });
 }
 function installMenu(config, mainWindow, context) {
@@ -2626,19 +3682,20 @@ async function setupAutomation(instance) {
   if (autoArgs.auto) {
     const server = await startAutomationServer(instance.context, autoArgs.autoPort);
     instance.automationServer = server;
+    instance.context.registry.add(() => server.close());
     console.log(`[automation] listening on ws://127.0.0.1:${server.port}`);
   }
 }
 function setupMcp() {
   const settings = loadWorkbenchSettings();
-  if (!settings.mcp.enabled) return;
-  const cdpPortSwitch = app11.commandLine.getSwitchValue("remote-debugging-port");
+  if (!settings.mcp.enabled) return null;
+  const cdpPortSwitch = app13.commandLine.getSwitchValue("remote-debugging-port");
   const cdpPort2 = cdpPortSwitch ? parseInt(cdpPortSwitch, 10) : settings.cdp.port;
-  startMcpServer(cdpPort2, settings.mcp.port);
+  return startMcpServer(cdpPort2, settings.mcp.port);
 }
 function wireAppWindowEvents(config, instance) {
   const { mainWindow, context } = instance;
-  wireMainWindowEvents(mainWindow, {
+  return wireMainWindowEvents(mainWindow, {
     context,
     onResize: () => context.views.repositionAll(),
     onClose: async (e) => {
@@ -2647,23 +3704,32 @@ function wireAppWindowEvents(config, instance) {
       if (config.onBeforeClose) {
         await config.onBeforeClose(instance);
       }
-      await disposeContext(context);
+      await context.workspace.closeProject();
       context.notify.windowNavigateBack();
     }
   });
 }
 function enableDevRendererAutoReload(rendererDir2) {
-  if (!app11.isPackaged) {
-    let reloadTimer = null;
-    fs5.watch(rendererDir2, { recursive: true }, () => {
-      if (reloadTimer) clearTimeout(reloadTimer);
-      reloadTimer = setTimeout(() => {
-        for (const win of BrowserWindow3.getAllWindows()) {
-          win.webContents.reload();
-        }
-      }, 300);
+  if (app13.isPackaged) {
+    return toDisposable(() => {
     });
   }
+  let reloadTimer = null;
+  const watcher = fs7.watch(rendererDir2, { recursive: true }, () => {
+    if (reloadTimer) clearTimeout(reloadTimer);
+    reloadTimer = setTimeout(() => {
+      for (const win of BrowserWindow4.getAllWindows()) {
+        win.webContents.reload();
+      }
+    }, 300);
+  });
+  return toDisposable(() => {
+    if (reloadTimer) {
+      clearTimeout(reloadTimer);
+      reloadTimer = null;
+    }
+    watcher.close();
+  });
 }
 function createWorkbenchApp(config = {}) {
   let setupPromise = null;
@@ -2671,18 +3737,19 @@ function createWorkbenchApp(config = {}) {
   setupCdpPort();
   async function setup() {
     if (setupPromise) return setupPromise;
-    setupPromise = app11.whenReady().then(async () => {
+    setupPromise = app13.whenReady().then(async () => {
       applyTheme(loadWorkbenchSettings().theme);
       const rendererDir2 = config.rendererDir ?? rendererDir;
       const mainWindow = createConfiguredMainWindow(config, rendererDir2);
       const context = createContext(config, mainWindow, rendererDir2);
-      registerAppIpc(context);
+      context.registry.add(registerAppIpc(context));
+      context.registry.add(installThemeBackgroundSync());
       registerBuiltinModules(config, context);
       installMenu(config, mainWindow, context);
       const instance = {
         mainWindow,
         context,
-        dispose: () => disposeContext(context, instance.updateManager)
+        dispose: () => disposeContext(context)
       };
       if (config.onSetup) {
         await config.onSetup(instance);
@@ -2695,22 +3762,37 @@ function createWorkbenchApp(config = {}) {
           initialDelay: config.updateOptions?.initialDelay,
           getCurrentVersion: config.updateOptions?.getCurrentVersion
         });
+        context.registry.add(() => instance.updateManager.dispose());
       }
       await setupAutomation(instance);
-      setupMcp();
-      setupSimulatorStorage(mainWindow.webContents);
-      wireAppWindowEvents(config, instance);
-      enableDevRendererAutoReload(rendererDir2);
+      const mcp = setupMcp();
+      if (mcp) context.registry.add(mcp);
+      context.registry.add(setupSimulatorStorage(mainWindow.webContents, {
+        senderPolicy: context.senderPolicy,
+        // Per-project filter for the simulator-storage panel: the simulator
+        // uses a fixed `persist:simulator` partition + a fixed simulator.html
+        // origin, so localStorage is shared across every project that has
+        // ever opened. The dimina runtime isolates writes with `${appId}_`
+        // prefixes; this callback lets the storage panel filter the CDP
+        // snapshot/event stream to the active appId.
+        getActiveAppId: () => {
+          const session2 = context.workspace.getSession();
+          const appInfo = session2?.appInfo;
+          return appInfo?.appId ?? null;
+        }
+      }));
+      context.registry.add(wireAppWindowEvents(config, instance));
+      context.registry.add(enableDevRendererAutoReload(rendererDir2));
       return instance;
     });
     return setupPromise;
   }
   function start() {
-    void setup();
     if (!appEventsRegistered) {
       appEventsRegistered = true;
       registerAppLifecycle();
     }
+    return setup().then(() => void 0);
   }
   return {
     setup,
@@ -2719,10 +3801,10 @@ function createWorkbenchApp(config = {}) {
 }
 
 // src/main/windows/settings-window/create.ts
-import { BrowserWindow as BrowserWindow4 } from "electron";
-import path7 from "path";
+import { BrowserWindow as BrowserWindow5 } from "electron";
+import path13 from "path";
 async function createSettingsWindow(parent, rendererDir2) {
-  const win = new BrowserWindow4({
+  const win = new BrowserWindow5({
     width: 420,
     height: 560,
     minWidth: 380,
@@ -2730,9 +3812,15 @@ async function createSettingsWindow(parent, rendererDir2) {
     parent: parent ?? void 0,
     title: "\u5F00\u53D1\u5DE5\u5177\u8BBE\u7F6E",
     backgroundColor: themeBg(),
-    webPreferences: { nodeIntegration: true, contextIsolation: false }
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      sandbox: false,
+      preload: mainPreloadPath
+    }
   });
-  await win.loadFile(path7.join(rendererDir2, "entries/workbench-settings/index.html"));
+  applyNavigationHardening(win.webContents, rendererDir2);
+  await win.loadFile(path13.join(rendererDir2, "entries/workbench-settings/index.html"));
   return win;
 }
 
@@ -2745,18 +3833,20 @@ function wireSettingsWindowEvents(win, onClosed) {
 
 // src/main/app/launch.ts
 function launch(config = {}) {
-  createWorkbenchApp(config).start();
+  return createWorkbenchApp(config).start();
 }
 async function openSettingsWindow(ctx) {
-  if (!ctx.workbenchSettingsWindow || ctx.workbenchSettingsWindow.isDestroyed()) {
-    ctx.workbenchSettingsWindow = await createSettingsWindow(ctx.mainWindow, ctx.rendererDir);
-    wireSettingsWindowEvents(ctx.workbenchSettingsWindow, () => {
-      ctx.workbenchSettingsWindow = null;
+  let win = ctx.windows.settingsWindow;
+  if (!win || win.isDestroyed()) {
+    win = await createSettingsWindow(ctx.windows.mainWindow, ctx.rendererDir);
+    ctx.windows.setSettingsWindow(win);
+    wireSettingsWindowEvents(win, () => {
+      ctx.windows.setSettingsWindow(null);
     });
   }
-  ctx.workbenchSettingsWindow.show();
-  ctx.workbenchSettingsWindow.focus();
-  ctx.notify.workbenchSettingsInit(ctx.workbenchSettingsWindow, {
+  win.show();
+  win.focus();
+  ctx.notify.workbenchSettingsInit(win, {
     settings: loadWorkbenchSettings()
   });
 }