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

package/dist/main/ipc/app.d.ts

@@ -1,3 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerAppIpc(ctx: Pick<WorkbenchContext, 'preloadPath' | 'brandingProvider' | 'appName'>): void;
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerAppIpc(ctx: Pick<WorkbenchContext, 'preloadPath' | 'brandingProvider' | 'appName' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=app.d.ts.map

package/dist/main/ipc/app.js

@@ -1,11 +1,12 @@
-import { ipcMain } from 'electron';
 import fs from 'fs';
 import { AppChannel } from '../../shared/ipc-channels.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerAppIpc(ctx) {
-    ipcMain.handle(AppChannel.GetPreloadPath, () => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(AppChannel.GetPreloadPath, () => {
         return `file://${fs.realpathSync(ctx.preloadPath)}`;
-    });
-    ipcMain.handle(AppChannel.GetBranding, async () => {
+    })
+        .handle(AppChannel.GetBranding, async () => {
         if (ctx.brandingProvider)
             return ctx.brandingProvider();
         return { appName: ctx.appName };

package/dist/main/ipc/index.d.ts

@@ -1,9 +1,10 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
 export { registerPanelsIpc } from './panels.js';
-export { registerPopoverIpc } from './popover.js';
-export { registerProjectsIpc } from './projects.js';
-export { registerSessionIpc } from './session.js';
-export { registerSettingsIpc } from './settings.js';
+export { registerPopoverIpc, popoverModule } from './popover.js';
+export { registerProjectsIpc, projectsModule } from './projects.js';
+export { registerSessionIpc, sessionModule } from './session.js';
+export { registerSettingsIpc, settingsModule } from './settings.js';
 export { registerToolbarIpc } from './toolbar.js';
+export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/ipc/index.js

@@ -1,9 +1,10 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
 export { registerPanelsIpc } from './panels.js';
-export { registerPopoverIpc } from './popover.js';
-export { registerProjectsIpc } from './projects.js';
-export { registerSessionIpc } from './session.js';
-export { registerSettingsIpc } from './settings.js';
+export { registerPopoverIpc, popoverModule } from './popover.js';
+export { registerProjectsIpc, projectsModule } from './projects.js';
+export { registerSessionIpc, sessionModule } from './session.js';
+export { registerSettingsIpc, settingsModule } from './settings.js';
 export { registerToolbarIpc } from './toolbar.js';
+export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.js.map

package/dist/main/ipc/panels.d.ts

@@ -1,3 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerPanelsIpc(ctx: Pick<WorkbenchContext, 'panels' | 'views' | 'workspace'>): void;
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerPanelsIpc(ctx: Pick<WorkbenchContext, 'panels' | 'views' | 'workspace' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=panels.d.ts.map

package/dist/main/ipc/panels.js

@@ -1,16 +1,21 @@
-import { ipcMain, webContents } from 'electron';
+import { webContents } from 'electron';
 import { PanelChannel } from '../../shared/ipc-channels.js';
+import { PanelEvalSchema, PanelSelectSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 const BUILTIN_PANELS = [
     { id: 'wxml', label: 'WXML' },
     { id: 'appdata', label: 'AppData' },
     { id: 'storage', label: 'Storage' },
 ];
 export function registerPanelsIpc(ctx) {
-    ipcMain.handle(PanelChannel.List, () => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(PanelChannel.List, () => {
         return BUILTIN_PANELS
             .filter((p) => ctx.panels.includes(p.id));
-    });
-    ipcMain.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 undefined;
@@ -23,14 +28,14 @@ export function registerPanelsIpc(ctx) {
         catch {
             return undefined;
         }
-    });
-    ipcMain.handle(PanelChannel.Select, (_event, _panelId) => {
-        // Hide the simulator overlay when switching to a built-in panel
+    })
+        .handle(PanelChannel.Select, (_event, ...args) => {
+        validate(PanelChannel.Select, PanelSelectSchema, args);
         if (ctx.views.hasSimulatorView() && ctx.views.isSimulatorAdded()) {
             ctx.views.hideSimulator();
         }
-    });
-    ipcMain.handle(PanelChannel.SelectSimulator, () => {
+    })
+        .handle(PanelChannel.SelectSimulator, () => {
         if (ctx.views.hasSimulatorView() && !ctx.views.isSimulatorAdded()) {
             ctx.views.showSimulator(ctx.views.getLastSimWidth());
         }

package/dist/main/ipc/popover.d.ts

@@ -1,3 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerPopoverIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify'>): void;
+import type { WorkbenchModule } from '../services/module.js';
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerPopoverIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy'>): Disposable;
+export declare const popoverModule: WorkbenchModule;
 //# sourceMappingURL=popover.d.ts.map

package/dist/main/ipc/popover.js

@@ -1,13 +1,23 @@
-import { ipcMain } from 'electron';
 import { PopoverChannel } from '../../shared/ipc-channels.js';
+import { PopoverShowSchema, PopoverRelaunchSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerPopoverIpc(ctx) {
-    ipcMain.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);
-    });
-    ipcMain.handle(PopoverChannel.Hide, () => ctx.views.hidePopover());
-    ipcMain.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);
     });
 }
+export const popoverModule = {
+    setup: (ctx) => registerPopoverIpc(ctx),
+};
 //# sourceMappingURL=popover.js.map

package/dist/main/ipc/projects.d.ts

@@ -1,3 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerProjectsIpc(ctx: Pick<WorkbenchContext, 'workspace' | 'mainWindow'>): void;
+import type { WorkbenchModule } from '../services/module.js';
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerProjectsIpc(ctx: Pick<WorkbenchContext, 'workspace' | 'mainWindow' | 'senderPolicy'>): Disposable;
+export declare const projectsModule: WorkbenchModule;
 //# sourceMappingURL=projects.d.ts.map

package/dist/main/ipc/projects.js

@@ -1,15 +1,52 @@
-import { ipcMain, dialog } from 'electron';
+import { dialog } from 'electron';
 import { ProjectsChannel, DialogChannel } from '../../shared/ipc-channels.js';
+import { ProjectsAddSchema, ProjectsRemoveSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerProjectsIpc(ctx) {
-    ipcMain.handle(ProjectsChannel.List, () => ctx.workspace.listProjects());
-    ipcMain.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: '选择小程序项目目录',
         });
         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: '无法导入项目',
+                message: '该目录不是有效的小程序项目',
+                detail: dirError,
+                buttons: ['确定'],
+            });
+            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: '项目已存在',
+                message: '该项目已在列表中',
+                detail: dirPath,
+                buttons: ['确定'],
+            });
+        }
+        return project;
+    })
+        .handle(ProjectsChannel.Remove, (_event, ...args) => {
+        const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
+        return ctx.workspace.removeProject(dirPath);
     });
-    ipcMain.handle(ProjectsChannel.Add, (_, dirPath) => ctx.workspace.addProject(dirPath));
-    ipcMain.handle(ProjectsChannel.Remove, (_, dirPath) => ctx.workspace.removeProject(dirPath));
 }
+export const projectsModule = {
+    setup: (ctx) => registerProjectsIpc(ctx),
+};
 //# sourceMappingURL=projects.js.map

package/dist/main/ipc/session.d.ts

@@ -1,3 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerSessionIpc(ctx: Pick<WorkbenchContext, 'workspace'>): void;
+import type { WorkbenchModule } from '../services/module.js';
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerSessionIpc(ctx: Pick<WorkbenchContext, 'workspace' | 'senderPolicy'>): Disposable;
+export declare const sessionModule: WorkbenchModule;
 //# sourceMappingURL=session.d.ts.map

package/dist/main/ipc/session.js

@@ -1,10 +1,30 @@
-import { ipcMain } from 'electron';
 import { ProjectChannel } from '../../shared/ipc-channels.js';
+import { ProjectGetCompileConfigSchema, ProjectGetPagesSchema, ProjectOpenSchema, ProjectSaveCompileConfigSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerSessionIpc(ctx) {
-    ipcMain.handle(ProjectChannel.Open, (_, projectPath) => ctx.workspace.openProject(projectPath));
-    ipcMain.handle(ProjectChannel.GetPages, (_, projectPath) => ctx.workspace.getProjectPages(projectPath));
-    ipcMain.handle(ProjectChannel.GetCompileConfig, (_, projectPath) => ctx.workspace.getCompileConfig(projectPath));
-    ipcMain.handle(ProjectChannel.SaveCompileConfig, (_, projectPath, config) => ctx.workspace.saveCompileConfig(projectPath, config));
-    ipcMain.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();
+    });
 }
+export const sessionModule = {
+    setup: (ctx) => registerSessionIpc(ctx),
+};
 //# sourceMappingURL=session.js.map

package/dist/main/ipc/settings.d.ts

@@ -1,3 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerSettingsIpc(ctx: Pick<WorkbenchContext, 'workbenchSettingsWindow' | 'views' | 'notify' | 'workspace' | 'mainWindow' | 'rendererDir'>): void;
+import type { Disposable } from '../utils/disposable.js';
+import type { WorkbenchModule } from '../services/module.js';
+export declare function registerSettingsIpc(ctx: Pick<WorkbenchContext, 'workbenchSettingsWindow' | 'views' | 'notify' | 'workspace' | 'mainWindow' | 'rendererDir' | 'senderPolicy' | 'windows'>): Disposable;
+export declare const settingsModule: WorkbenchModule;
 //# sourceMappingURL=settings.d.ts.map

package/dist/main/ipc/settings.js

@@ -1,20 +1,26 @@
-import { app, ipcMain } from 'electron';
+import { app } from 'electron';
 import { openSettingsWindow } from '../app/launch.js';
 import { loadWorkbenchSettings, saveWorkbenchSettings, applyTheme, } from '../services/settings/index.js';
 import { WorkbenchSettingsChannel, SettingsChannel } from '../../shared/ipc-channels.js';
+import { SettingsConfigChangedSchema, SettingsProjectSettingsChangedSchema, SettingsSetVisibleSchema, WorkbenchSettingsSaveSchema, WorkbenchSettingsSetThemeSchema, WorkbenchSettingsSetVisibleSchema, } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerSettingsIpc(ctx) {
-    ipcMain.handle(WorkbenchSettingsChannel.Get, () => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(WorkbenchSettingsChannel.Get, () => {
         return loadWorkbenchSettings();
-    });
-    ipcMain.handle(WorkbenchSettingsChannel.Save, (_, settings) => {
+    })
+        .handle(WorkbenchSettingsChannel.Save, (_, ...args) => {
+        const [settings] = validate(WorkbenchSettingsChannel.Save, WorkbenchSettingsSaveSchema, args);
         saveWorkbenchSettings(settings);
         applyTheme(settings.theme ?? 'system');
         return { success: true };
-    });
-    ipcMain.handle(WorkbenchSettingsChannel.SetTheme, (_, theme) => {
+    })
+        .handle(WorkbenchSettingsChannel.SetTheme, (_, ...args) => {
+        const [theme] = validate(WorkbenchSettingsChannel.SetTheme, WorkbenchSettingsSetThemeSchema, args);
         applyTheme(theme);
-    });
-    ipcMain.handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
+    })
+        .handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
         const settings = loadWorkbenchSettings();
         const switchValue = app.commandLine.getSwitchValue('remote-debugging-port');
         const implicitDevDefault = !app.isPackaged && !settings.cdp.enabled && switchValue === '9222';
@@ -25,16 +31,18 @@ export function registerSettingsIpc(ctx) {
             activePort: switchValue ? parseInt(switchValue, 10) : null,
             implicitDevDefault,
         };
-    });
-    ipcMain.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();
         }
-    });
-    ipcMain.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({
@@ -47,15 +55,20 @@ export function registerSettingsIpc(ctx) {
             ctx.views.hideSettings();
             ctx.notify.settingsClosed();
         }
-    });
-    ipcMain.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.notify.settingsChanged(config);
-    });
-    ipcMain.on(SettingsChannel.ProjectSettingsChanged, (_, patch) => {
+    })
+        .on(SettingsChannel.ProjectSettingsChanged, (_, ...args) => {
+        const [patch] = validate(SettingsChannel.ProjectSettingsChanged, SettingsProjectSettingsChangedSchema, args);
         ctx.workspace.updateProjectSettings(ctx.workspace.getProjectPath(), patch);
     });
 }
+export const settingsModule = {
+    setup: (ctx) => registerSettingsIpc(ctx),
+};
 //# sourceMappingURL=settings.js.map

package/dist/main/ipc/simulator-module.d.ts

@@ -0,0 +1,8 @@
+import type { WorkbenchModule } from '../services/module.js';
+/**
+ * The 'simulator' built-in module fans out into three IPC registrars
+ * (core simulator, panels, toolbar). Bundle them under a single module
+ * so app.ts only sees one entry per BuiltinModuleId.
+ */
+export declare const simulatorModule: WorkbenchModule;
+//# sourceMappingURL=simulator-module.d.ts.map

package/dist/main/ipc/simulator-module.js

@@ -0,0 +1,19 @@
+import { DisposableRegistry } from '../utils/disposable.js';
+import { registerSimulatorIpc } from './simulator.js';
+import { registerPanelsIpc } from './panels.js';
+import { registerToolbarIpc } from './toolbar.js';
+/**
+ * The 'simulator' built-in module fans out into three IPC registrars
+ * (core simulator, panels, toolbar). Bundle them under a single module
+ * so app.ts only sees one entry per BuiltinModuleId.
+ */
+export const simulatorModule = {
+    setup: (ctx) => {
+        const reg = new DisposableRegistry();
+        reg.add(registerSimulatorIpc(ctx));
+        reg.add(registerPanelsIpc(ctx));
+        reg.add(registerToolbarIpc(ctx));
+        return reg;
+    },
+};
+//# sourceMappingURL=simulator-module.js.map

package/dist/main/ipc/simulator.d.ts

@@ -1,3 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerSimulatorIpc(ctx: Pick<WorkbenchContext, 'views' | 'panels' | 'apiNamespaces' | 'notify'>): void;
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerSimulatorIpc(ctx: Pick<WorkbenchContext, 'views' | 'panels' | 'apiNamespaces' | 'notify' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=simulator.d.ts.map

package/dist/main/ipc/simulator.js

@@ -1,25 +1,39 @@
-import { ipcMain } from 'electron';
-import { SimulatorChannel, WorkbenchChannel } from '../../shared/ipc-channels.js';
+import { SimulatorChannel, SimulatorCustomApiChannel, WorkbenchChannel } from '../../shared/ipc-channels.js';
+import { SimulatorAttachSchema, SimulatorCustomApiInvokeSchema, SimulatorResizeSchema, SimulatorSetVisibleSchema, } from '../../shared/ipc-schemas.js';
+import { simulatorApiRegistry } from '../services/simulator/custom-apis.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerSimulatorIpc(ctx) {
-    ipcMain.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);
-    });
-    ipcMain.handle(SimulatorChannel.Detach, () => {
+    })
+        .handle(SimulatorChannel.Detach, () => {
         ctx.views.detachSimulator();
-    });
-    ipcMain.handle(SimulatorChannel.Resize, (_, simWidth) => {
+    })
+        .handle(SimulatorChannel.Resize, (_, ...args) => {
+        const [simWidth] = validate(SimulatorChannel.Resize, SimulatorResizeSchema, args);
         ctx.views.resize(simWidth);
-    });
-    ipcMain.handle(SimulatorChannel.SetVisible, (_, visible, simWidth) => {
+    })
+        .handle(SimulatorChannel.SetVisible, (_, ...args) => {
+        const [visible, simWidth] = validate(SimulatorChannel.SetVisible, SimulatorSetVisibleSchema, args);
         ctx.views.setVisible(visible, simWidth);
-    });
-    ipcMain.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;
-    });
-    ipcMain.handle(WorkbenchChannel.GetApiNamespaces, () => {
+    })
+        .handle(WorkbenchChannel.GetApiNamespaces, () => {
         return ctx.apiNamespaces;
-    });
-    ipcMain.on(WorkbenchChannel.Reset, () => {
+    })
+        .on(WorkbenchChannel.Reset, () => {
         ctx.notify.workbenchReset();
     });
 }

package/dist/main/ipc/toolbar.d.ts

@@ -1,3 +1,4 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
-export declare function registerToolbarIpc(ctx: Pick<WorkbenchContext, 'toolbarActions'>): void;
+import type { Disposable } from '../utils/disposable.js';
+export declare function registerToolbarIpc(ctx: Pick<WorkbenchContext, 'toolbarActions' | 'senderPolicy'>): Disposable;
 //# sourceMappingURL=toolbar.d.ts.map

package/dist/main/ipc/toolbar.js

@@ -1,7 +1,8 @@
-import { ipcMain } from 'electron';
 import { ToolbarChannel } from '../../shared/ipc-channels.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
 export function registerToolbarIpc(ctx) {
-    ipcMain.handle(ToolbarChannel.GetActions, async () => {
+    return new IpcRegistry(ctx.senderPolicy)
+        .handle(ToolbarChannel.GetActions, async () => {
         if (ctx.toolbarActions)
             return ctx.toolbarActions();
         return [];

package/dist/main/services/automation/index.js

@@ -9,9 +9,9 @@
  * This server handles these messages by delegating to the workbench context
  * (simulator webContents, IPC handlers, etc.) without modifying dimina upstream.
  */
-import { ipcMain } from 'electron';
 import { WebSocketServer } from 'ws';
 import { AutomationChannel, SimulatorChannel } from '../../../shared/ipc-channels.js';
+import { IpcRegistry } from '../../utils/ipc-registry.js';
 import { getSimulator } from './exec.js';
 import { toolHandlers } from './handlers/tool.js';
 import { appHandlers } from './handlers/app.js';
@@ -25,7 +25,6 @@ const handlers = {
     ...elementHandlers,
 };
 let currentPort = null;
-let portIpcRegistered = false;
 export function getAutomationPort() {
     return currentPort;
 }
@@ -40,10 +39,14 @@ export async function startAutomationServer(ctx, port = 0) {
     // ws always binds via an http.Server, so address() is AddressInfo here.
     const resolvedPort = typeof addr === 'object' && addr ? addr.port : port;
     currentPort = resolvedPort;
-    if (!portIpcRegistered) {
-        portIpcRegistered = true;
-        ipcMain.handle(AutomationChannel.GetPort, () => currentPort);
-    }
+    // Gate AutomationChannel.GetPort with the workbench sender policy (only
+    // the main renderer + workbench settings/popover overlays are allowed to
+    // read the port — see createWorkbenchSenderPolicy; the simulator webview
+    // is intentionally NOT trusted for IPC invokes).
+    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) {
@@ -51,19 +54,55 @@ export async function startAutomationServer(ctx, port = 0) {
                 ws.send(msg);
         }
     }
-    // Forward simulator console logs as App.logAdded events
+    // Forward simulator console logs as App.logAdded events.
+    // Track the polling interval + stop timer + currently-attached sim and
+    // the named handler so we can fully detach on close() or sim destruction.
+    // Without this the listener accumulates across create/dispose cycles and
+    // across simulator rebuilds.
     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()) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        ;
+                        attachedSim.removeListener('ipc-message-host', ipcMessageHostHandler);
+                    }
+                }
+                catch { /* noop */ }
+            }
+            if (simDestroyedHandler) {
+                try {
+                    if (!attachedSim.isDestroyed()) {
+                        attachedSim.removeListener('destroyed', simDestroyedHandler);
+                    }
+                }
+                catch { /* noop */ }
+            }
+        }
+        attachedSim = null;
+        ipcMessageHostHandler = null;
+        simDestroyedHandler = null;
+    }
     function setupConsoleForwarding() {
         if (consoleForwardingSetup)
             return;
         consoleForwardingSetup = true;
-        // Poll for simulator and set up listener
-        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({
@@ -71,10 +110,29 @@ export async function startAutomationServer(ctx, port = 0) {
                         params: { type: logData.level || 'log', args: logData.args || [] },
                     });
                 }
-            });
+            };
+            const onSimDestroyed = () => {
+                // Sim webContents is dead — drop refs (removeListener on a destroyed
+                // sender would throw) and allow re-attach to a new simulator.
+                attachedSim = null;
+                ipcMessageHostHandler = null;
+                simDestroyedHandler = null;
+                consoleForwardingSetup = false;
+            };
+            attachedSim = sim;
+            ipcMessageHostHandler = onIpcMessageHost;
+            simDestroyedHandler = onSimDestroyed;
+            sim.on('ipc-message-host', onIpcMessageHost);
+            sim.once('destroyed', onSimDestroyed);
         }, 1000);
         // Stop polling after 30s
-        setTimeout(() => clearInterval(check), 30000);
+        pollStopTimer = setTimeout(() => {
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+            pollStopTimer = null;
+        }, 30000);
     }
     wss.on('connection', (ws) => {
         clients.add(ws);
@@ -109,8 +167,25 @@ export 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 { /* noop */ }
+            }
+            clients.clear();
             if (currentPort === resolvedPort)
                 currentPort = null;
+            void portIpc.dispose();
             wss.close();
         },
         port: resolvedPort,

package/dist/main/services/default-adapter.js

@@ -1,8 +1,6 @@
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { app } from 'electron';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const simulatorDir = path.resolve(__dirname, '../../simulator');
+import { simulatorDir } from '../utils/paths.js';
 export const defaultAdapter = {
     async openProject(opts) {
         const diminaKit = await import('@dimina-kit/devkit');