@dimina-kit/devtools 0.3.0 → 0.3.1-dev.20260515105504

package/dist/main/index.bundle.js

@@ -14,6 +14,9 @@ var DEFAULTS = {
     enabled: false,
     port: 7789
   },
+  compile: {
+    watch: true
+  },
   theme: "system"
 };
 function getSettingsFile() {
@@ -32,10 +35,18 @@ function loadWorkbenchSettings() {
         enabled: data.mcp?.enabled ?? DEFAULTS.mcp.enabled,
         port: data.mcp?.port ?? DEFAULTS.mcp.port
       },
+      compile: {
+        watch: data.compile?.watch ?? DEFAULTS.compile.watch
+      },
       theme
     };
   } catch {
-    return { ...DEFAULTS, cdp: { ...DEFAULTS.cdp }, mcp: { ...DEFAULTS.mcp } };
+    return {
+      ...DEFAULTS,
+      cdp: { ...DEFAULTS.cdp },
+      mcp: { ...DEFAULTS.mcp },
+      compile: { ...DEFAULTS.compile }
+    };
   }
 }
 function saveWorkbenchSettings(settings) {
@@ -63,15 +74,32 @@ function setupCdpPort() {
 
 // src/main/app/app.ts
 import { app as app11, BrowserWindow as BrowserWindow3, nativeImage } from "electron";
-import fs4 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path8 from "path";
 
 // src/main/utils/paths.ts
+import fs2 from "fs";
 import path2 from "path";
 import { fileURLToPath } from "url";
-var __dirname = path2.dirname(fileURLToPath(import.meta.url));
-var rendererDir = path2.join(__dirname, "../../../dist/renderer");
-var defaultPreloadPath = path2.join(__dirname, "../../preload/windows/simulator.js");
+function resolveDevtoolsPackageRoot() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  const root = path2.parse(dir).root;
+  while (dir !== root) {
+    const pkgPath = path2.join(dir, "package.json");
+    try {
+      const pkg2 = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+      if (pkg2.name === "@dimina-kit/devtools") return dir;
+    } catch {
+    }
+    dir = path2.dirname(dir);
+  }
+  throw new Error("@dimina-kit/devtools package root not found from " + fileURLToPath(import.meta.url));
+}
+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/app/lifecycle.ts
 import { app as app3, globalShortcut } from "electron";
@@ -86,7 +114,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, View, session, shell as shell2 } from "electron";
+import path4 from "path";
 
 // src/main/services/simulator/referer.ts
 var DEFAULT_VERSION = "develop";
@@ -113,12 +142,51 @@ 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) {
@@ -137,7 +205,7 @@ function configureSimulatorSession() {
   });
 }
 function createMainWindow(opts) {
-  configureSimulatorSession();
+  configureSimulatorSession(opts.simulatorPreloadPath);
   const mainWindow = new BrowserWindow({
     width: opts.width ?? 1280,
     height: opts.height ?? 980,
@@ -147,8 +215,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
     }
   });
@@ -162,22 +235,102 @@ 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";
+
+// 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/windows/main-window/events.ts
 function wireMainWindowEvents(win, state = {}) {
+  const registry = new DisposableRegistry();
   const mainWebView = win.contentView.children[0];
   const resizeMainWebView = () => {
     if (mainWebView) {
@@ -188,25 +341,53 @@ 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 { fileURLToPath as fileURLToPath2 } from "url";
+import path5 from "path";
 import { app as app5 } from "electron";
-var __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
-var simulatorDir = path3.resolve(__dirname2, "../../simulator");
 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"),
+      outputDir: path5.join(app5.getPath("userData"), "dimina-fe-output"),
       ...opts,
       simulatorDir
     });
@@ -224,10 +405,23 @@ var SimulatorChannel = {
   AppData: "simulator:appdata",
   AppDataAll: "simulator:appdata-all"
 };
+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",
@@ -294,6 +488,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) {
@@ -354,7 +555,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;
@@ -513,10 +714,16 @@ 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) {
@@ -537,8 +744,14 @@ 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);
@@ -547,7 +760,7 @@ function createViewManager(ctx) {
       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() {
@@ -613,15 +826,51 @@ 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 fs2 from "fs";
+import path7 from "path";
+import fs3 from "fs";
 
 // src/shared/constants.ts
 var DEFAULT_SCENE = 1001;
@@ -667,17 +916,17 @@ 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 {
-    return JSON.parse(fs2.readFileSync(getProjectsFile(), "utf-8"));
+    return JSON.parse(fs3.readFileSync(getProjectsFile(), "utf-8"));
   } catch {
     return [];
   }
 }
 function save(projects) {
-  fs2.writeFileSync(getProjectsFile(), JSON.stringify(projects, null, 2));
+  fs3.writeFileSync(getProjectsFile(), JSON.stringify(projects, null, 2));
 }
 function listProjects() {
   return load();
@@ -686,16 +935,16 @@ function validateProjectDir(dirPath) {
   if (!dirPath) {
     return "\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u8DEF\u5F84\u4E3A\u7A7A\uFF0C\u8BF7\u9009\u62E9\u5305\u542B\u5C0F\u7A0B\u5E8F\u6E90\u7801\u7684\u76EE\u5F55";
   }
-  if (!fs2.existsSync(dirPath)) {
+  if (!fs3.existsSync(dirPath)) {
     return `\u5C0F\u7A0B\u5E8F\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dirPath}`;
   }
-  if (!fs2.existsSync(path5.join(dirPath, "app.json"))) {
-    const configPath = path5.join(dirPath, "project.config.json");
-    if (fs2.existsSync(configPath)) {
+  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(fs2.readFileSync(configPath, "utf-8"));
+        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) {
@@ -706,13 +955,16 @@ function validateProjectDir(dirPath) {
   }
   return null;
 }
+function hasProject(dirPath) {
+  return load().some((p) => p.path === 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");
-    if (fs2.existsSync(configPath)) {
-      const cfg = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    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;
     }
   } catch (err) {
@@ -749,10 +1001,10 @@ 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(
-      fs2.readFileSync(appJsonPath, "utf-8")
+      fs3.readFileSync(appJsonPath, "utf-8")
     );
     return {
       pages: appJson.pages || [],
@@ -775,8 +1027,8 @@ function getProjectSettings(projectPath) {
     return { uploadWithSourceMap: false };
   }
   try {
-    const configPath = path5.join(projectPath, "project.config.json");
-    const config = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    const configPath = path7.join(projectPath, "project.config.json");
+    const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
     return {
       uploadWithSourceMap: !!config.setting?.uploadWithSourceMap
     };
@@ -786,17 +1038,17 @@ 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(fs2.readFileSync(configPath, "utf-8"));
+    config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
   } catch {
   }
   const nextSetting = {
     ...config.setting ?? {},
     ...patch.uploadWithSourceMap === void 0 ? {} : { uploadWithSourceMap: patch.uploadWithSourceMap }
   };
-  fs2.writeFileSync(
+  fs3.writeFileSync(
     configPath,
     JSON.stringify({ ...config, setting: nextSetting }, null, 2)
   );
@@ -806,8 +1058,8 @@ function updateProjectSettings(projectPath, patch) {
 function createWorkspaceService(ctx) {
   let currentSession = null;
   let currentProjectPath = "";
-  function sendStatus(status, message) {
-    ctx.notify.projectStatus({ status, message });
+  function sendStatus(status, message, hotReload) {
+    ctx.notify.projectStatus(hotReload ? { status, message, hotReload: true } : { status, message });
   }
   function bestEffort(label, fn) {
     try {
@@ -844,6 +1096,7 @@ function createWorkspaceService(ctx) {
     listProjects: () => listProjects(),
     addProject: (dirPath) => addProject(dirPath),
     removeProject: (dirPath) => removeProject(dirPath),
+    hasProject: (dirPath) => hasProject(dirPath),
     validateProjectDir: (dirPath) => validateProjectDir(dirPath),
     async openProject(projectPath) {
       clearSimulatorServicewechatReferer();
@@ -855,12 +1108,14 @@ function createWorkspaceService(ctx) {
         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) {
@@ -918,9 +1173,12 @@ function createWorkbenchContext(opts) {
     brandingProvider: opts.brandingProvider,
     workbenchSettingsWindow: null
   };
+  ctx.registry = new DisposableRegistry();
+  ctx.windows = createWindowService(ctx.mainWindow);
   ctx.views = createViewManager(ctx);
   ctx.notify = createRendererNotifier(ctx);
   ctx.workspace = createWorkspaceService(ctx);
+  ctx.senderPolicy = createWorkbenchSenderPolicy(ctx);
   return ctx;
 }
 
@@ -991,56 +1249,246 @@ function installAppMenu(ctx) {
 }
 
 // src/main/ipc/app.ts
+import fs4 from "fs";
+
+// src/main/utils/ipc-registry.ts
 import { ipcMain } from "electron";
-import fs3 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://${fs3.realpathSync(ctx.preloadPath)}`;
-  });
-  ipcMain.handle(AppChannel.GetBranding, async () => {
+  return new IpcRegistry(ctx.senderPolicy).handle(AppChannel.GetPreloadPath, () => {
+    return `file://${fs4.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"])
+  })
+]);
+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)]);
+
+// 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, () => {
+  }).handle(SimulatorCustomApiChannel.List, () => {
+    return simulatorApiRegistry.list();
+  }).handle(SimulatorCustomApiChannel.Invoke, (_, ...args) => {
+    const [name, params] = validate(SimulatorCustomApiChannel.Invoke, SimulatorCustomApiInvokeSchema, args);
+    return simulatorApiRegistry.invoke(name, params);
+  }).handle(WorkbenchChannel.GetPanelConfig, () => {
     return ctx.panels;
-  });
-  ipcMain2.handle(WorkbenchChannel.GetApiNamespaces, () => {
+  }).handle(WorkbenchChannel.GetApiNamespaces, () => {
     return ctx.apiNamespaces;
-  });
-  ipcMain2.on(WorkbenchChannel.Reset, () => {
+  }).on(WorkbenchChannel.Reset, () => {
     ctx.notify.workbenchReset();
   });
 }
 
 // src/main/ipc/panels.ts
-import { ipcMain as ipcMain3, webContents as webContents2 } from "electron";
+import { 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) => {
+  }).handle(PanelChannel.Eval, async (_event, ...args) => {
+    const [expression] = validate(PanelChannel.Eval, PanelEvalSchema, args);
     const simWcId = ctx.views.getSimulatorWebContentsId();
     if (!ctx.workspace.hasActiveSession() || simWcId == null) return void 0;
     const sim = webContents2.fromId(simWcId);
@@ -1050,13 +1498,12 @@ function registerPanelsIpc(ctx) {
     } 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());
     }
@@ -1064,76 +1511,119 @@ 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 { ipcMain as ipcMain5, dialog } from "electron";
+import { dialog } from "electron";
 function registerProjectsIpc(ctx) {
-  ipcMain5.handle(ProjectsChannel.List, () => ctx.workspace.listProjects());
-  ipcMain5.handle(DialogChannel.OpenDirectory, async () => {
+  return new IpcRegistry(ctx.senderPolicy).handle(ProjectsChannel.List, () => {
+    return ctx.workspace.listProjects();
+  }).handle(DialogChannel.OpenDirectory, async () => {
     const result = await dialog.showOpenDialog(ctx.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 = ctx.workspace.validateProjectDir(dirPath);
+    if (dirError) {
+      await dialog.showMessageBox(ctx.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 = ctx.workspace.hasProject(dirPath);
+    const project = ctx.workspace.addProject(dirPath);
+    if (duplicate) {
+      await dialog.showMessageBox(ctx.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);
   });
-  ipcMain5.handle(
-    ProjectsChannel.Add,
-    (_, dirPath) => ctx.workspace.addProject(dirPath)
-  );
-  ipcMain5.handle(
-    ProjectsChannel.Remove,
-    (_, dirPath) => ctx.workspace.removeProject(dirPath)
-  );
 }
+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();
+  });
 }
+var sessionModule = {
+  setup: (ctx) => registerSessionIpc(ctx)
+};
 
 // src/main/ipc/settings.ts
-import { app as app7, ipcMain as ipcMain7 } from "electron";
+import { app as app7 } 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";
@@ -1144,15 +1634,19 @@ function registerSettingsIpc(ctx) {
       activePort: switchValue ? parseInt(switchValue, 10) : null,
       implicitDevDefault
     };
-  });
-  ipcMain7.handle(WorkbenchSettingsChannel.SetVisible, async (_, visible) => {
+  }).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();
       ctx.notify.settingsInit({
@@ -1164,32 +1658,55 @@ function registerSettingsIpc(ctx) {
       ctx.views.hideSettings();
       ctx.notify.settingsClosed();
     }
-  });
-  ipcMain7.on(SettingsChannel.ConfigChanged, (_, config) => {
+  }).on(SettingsChannel.ConfigChanged, (_, ...args) => {
+    const [config] = validate(
+      SettingsChannel.ConfigChanged,
+      SettingsConfigChangedSchema,
+      args
+    );
     if (ctx.workspace.getProjectPath()) {
-      ctx.workspace.saveCompileConfig(ctx.workspace.getProjectPath(), config);
+      ctx.workspace.saveCompileConfig(
+        ctx.workspace.getProjectPath(),
+        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
@@ -1578,7 +2095,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();
@@ -1589,10 +2105,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) {
@@ -1600,14 +2116,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({
@@ -1615,9 +2163,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);
@@ -1648,7 +2213,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
@@ -1807,7 +2389,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",
@@ -1828,9 +2410,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;
@@ -1845,7 +2427,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 });
@@ -1858,15 +2440,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;
@@ -2109,11 +2691,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) {
@@ -2128,15 +2710,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 });
@@ -2291,110 +2873,327 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
   httpServer.listen(mcpPort, "127.0.0.1", () => {
     console.log(`[MCP] SSE server listening on http://127.0.0.1:${mcpPort}/sse`);
   });
+  return toDisposable(() => {
+    transports.clear();
+    httpServer.close();
+  });
 }
 
 // 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 app8, 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");
-    }
-    await wc.debugger.sendCommand("DOMStorage.enable");
-    wc.debugger.on("message", onCdpMessage);
-    wc.debugger.on("detach", () => {
-      if (attachedWc === wc) attachedWc = null;
+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(() => {
     });
-    wc.once("destroyed", () => {
-      if (attachedWc === wc) attachedWc = null;
-    });
-    attachedWc = wc;
-  } catch (e) {
-    console.warn("[storage-watcher] attach failed:", e.message);
+    try {
+      if (!wc.isDestroyed() && wc.debugger.isAttached()) {
+        wc.debugger.detach();
+      }
+    } catch {
+    }
   }
-}
-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 ?? "")
+  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;
       };
-      break;
-    case "DOMStorage.domStorageItemRemoved":
-      evt = { type: "removed", key: String(p.key) };
-      break;
-    case "DOMStorage.domStorageItemsCleared":
-      evt = { type: "cleared" };
-      break;
-    default:
-      return;
+      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;
+    }
+    host.send(SimulatorStorageChannel.Event, evt);
   }
-  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 }
-    });
-    return result.entries.map(([key, value]) => ({ key, value }));
-  } catch {
-    return [];
+  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 };
+  }
+  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) {
+    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 {
+      await attachedWc.debugger.sendCommand("DOMStorage.setDOMStorageItem", {
+        storageId,
+        key,
+        value
+      });
+      pushSyntheticEvent({ type: "added", key, newValue: value });
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+  async function removeItem(key) {
+    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 {
+      await attachedWc.debugger.sendCommand("DOMStorage.removeDOMStorageItem", {
+        storageId,
+        key
+      });
+      pushSyntheticEvent({ type: "removed", key });
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+  async function clearScoped() {
+    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" };
+    const prefix = activePrefix();
+    try {
+      if (!prefix) {
+        await attachedWc.debugger.sendCommand("DOMStorage.clear", { storageId });
+        return { ok: true };
+      }
+      const result = await attachedWc.debugger.sendCommand("DOMStorage.getDOMStorageItems", {
+        storageId
+      });
+      for (const [key] of result.entries) {
+        if (!key.startsWith(prefix)) continue;
+        await attachedWc.debugger.sendCommand("DOMStorage.removeDOMStorageItem", {
+          storageId,
+          key
+        });
+      }
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+  async function clearAll() {
+    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 {
+      await attachedWc.debugger.sendCommand("DOMStorage.clear", { storageId });
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }
+  async function getSnapshot() {
+    await ensureAttached();
+    if (!attachedWc || attachedWc.isDestroyed()) return [];
+    try {
+      const storageId = await getStorageId();
+      if (!storageId) return [];
+      const result = await attachedWc.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 }));
+    } catch {
+      return [];
+    }
   }
-}
-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", () => {
+  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);
     });
+  };
+  app8.on("web-contents-created", onWcCreated);
+  registry.add(() => {
+    app8.removeListener("web-contents-created", onWcCreated);
   });
-  ipcMain10.handle(SimulatorStorageChannel.GetSnapshot, getSnapshot);
+  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()) {
+    if (isSimulatorWebview(wc)) return wc;
+  }
+  return null;
+}
+async function inspectElement(sid) {
+  if (!sid) return null;
+  const sim = findSimulatorWebContents();
+  if (!sim) return null;
+  try {
+    const result = await sim.executeJavaScript(
+      `window.__simulatorData && window.__simulatorData.highlightElement ? window.__simulatorData.highlightElement(${JSON.stringify(sid)}) : null`
+    );
+    return result ?? null;
+  } catch (e) {
+    console.warn("[simulator-element] inspect failed:", e.message);
+    return null;
+  }
+}
+async function clearElementInspection() {
+  const sim = findSimulatorWebContents();
+  if (!sim) return;
+  try {
+    await sim.executeJavaScript(
+      "window.__simulatorData && window.__simulatorData.unhighlightElement && window.__simulatorData.unhighlightElement()"
+    );
+  } catch {
+  }
 }
 
 // src/main/services/update/update-manager.ts
-import { app as app9, ipcMain as ipcMain11, shell } from "electron";
+import { app as app9, shell as shell3 } from "electron";
 var UpdateManager = class {
   checker;
   mainWindow;
@@ -2403,23 +3202,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.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 {
@@ -2442,7 +3235,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 };
@@ -2453,10 +3246,16 @@ var UpdateManager = class {
   }
   install() {
     if (this.downloadedPath) {
-      shell.openPath(this.downloadedPath);
+      shell3.openPath(this.downloadedPath);
       app9.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);
@@ -2466,9 +3265,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);
@@ -2477,7 +3274,7 @@ 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);
     }
   }
 };
@@ -2493,16 +3290,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;
@@ -2527,18 +3320,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: path8.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);
@@ -2562,7 +3362,7 @@ function createContext(config, mainWindow, rendererDir2) {
 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) {
@@ -2577,19 +3377,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;
+  if (!settings.mcp.enabled) return null;
   const cdpPortSwitch = app11.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) => {
@@ -2598,23 +3399,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;
-    fs4.watch(rendererDir2, { recursive: true }, () => {
-      if (reloadTimer) clearTimeout(reloadTimer);
-      reloadTimer = setTimeout(() => {
-        for (const win of BrowserWindow3.getAllWindows()) {
-          win.webContents.reload();
-        }
-      }, 300);
+  if (app11.isPackaged) {
+    return toDisposable(() => {
     });
   }
+  let reloadTimer = null;
+  const watcher = fs5.watch(rendererDir2, { recursive: true }, () => {
+    if (reloadTimer) clearTimeout(reloadTimer);
+    reloadTimer = setTimeout(() => {
+      for (const win of BrowserWindow3.getAllWindows()) {
+        win.webContents.reload();
+      }
+    }, 300);
+  });
+  return toDisposable(() => {
+    if (reloadTimer) {
+      clearTimeout(reloadTimer);
+      reloadTimer = null;
+    }
+    watcher.close();
+  });
 }
 function createWorkbenchApp(config = {}) {
   let setupPromise = null;
@@ -2627,13 +3437,13 @@ function createWorkbenchApp(config = {}) {
       const rendererDir2 = config.rendererDir ?? rendererDir;
       const mainWindow = createConfiguredMainWindow(config, rendererDir2);
       const context = createContext(config, mainWindow, rendererDir2);
-      registerAppIpc(context);
+      context.registry.add(registerAppIpc(context));
       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);
@@ -2646,22 +3456,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,
@@ -2671,7 +3496,7 @@ function createWorkbenchApp(config = {}) {
 
 // src/main/windows/settings-window/create.ts
 import { BrowserWindow as BrowserWindow4 } from "electron";
-import path7 from "path";
+import path9 from "path";
 async function createSettingsWindow(parent, rendererDir2) {
   const win = new BrowserWindow4({
     width: 420,
@@ -2681,9 +3506,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(path9.join(rendererDir2, "entries/workbench-settings/index.html"));
   return win;
 }
 
@@ -2696,13 +3527,16 @@ 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, () => {
+    const win = await createSettingsWindow(ctx.mainWindow, ctx.rendererDir);
+    ctx.workbenchSettingsWindow = win;
+    ctx.windows.setSettingsWindow(win);
+    wireSettingsWindowEvents(win, () => {
       ctx.workbenchSettingsWindow = null;
+      ctx.windows.setSettingsWindow(null);
     });
   }
   ctx.workbenchSettingsWindow.show();