@dimina-kit/devtools 0.4.0-dev.20260831134112 → 0.4.0-dev.20260907055341

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

@@ -1,4 +1,7 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-export declare function registerAppIpc(ctx: Pick<WorkbenchContext, 'brandingProvider' | 'appName' | 'senderPolicy'>): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+type AppIpcCtx = Pick<WorkbenchContext, 'brandingProvider' | 'appName' | 'senderPolicy'>;
+export declare function registerAppIpc(input: IpcInput<AppIpcCtx>): Disposable;
+export {};
 //# sourceMappingURL=app.d.ts.map

package/dist/main/ipc/app.js

@@ -1,8 +1,9 @@
 import { AppChannel } from '../../shared/ipc-channels.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-export function registerAppIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(AppChannel.GetBranding, async () => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerAppIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(AppChannel.GetBranding, async (ctx) => {
         if (ctx.brandingProvider)
             return ctx.brandingProvider();
         return { appName: ctx.appName };

package/dist/main/ipc/device-picker.d.ts

@@ -0,0 +1,16 @@
+import type { WorkbenchModule } from '../services/module.js';
+import type { ViewManager } from '../services/views/view-manager.js';
+import type { RendererNotifier } from '../services/notifications/renderer-notifier.js';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import { type SenderPolicy } from '../utils/ipc-registry.js';
+import { type IpcInput } from '../utils/ipc-context-source.js';
+/** Module-local narrow deps — deliberately NOT `Pick<WorkbenchContext, ...>`
+ * (the gate in eslint.config.* is shrink-only; see its message). */
+export interface DevicePickerIpcDeps {
+    views: Pick<ViewManager, 'showDevicePicker' | 'hideDevicePicker'>;
+    notify: Pick<RendererNotifier, 'devicePickerSelected'>;
+    senderPolicy?: SenderPolicy;
+}
+export declare function registerDevicePickerIpc(input: IpcInput<DevicePickerIpcDeps>): Disposable;
+export declare const devicePickerModule: WorkbenchModule;
+//# sourceMappingURL=device-picker.d.ts.map

package/dist/main/ipc/device-picker.js

@@ -0,0 +1,27 @@
+import { DevicePickerChannel } from '../../shared/ipc-channels-overlays.js';
+import { DevicePickerDeviceSchema } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerDevicePickerIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .onRouted(DevicePickerChannel.Show, (ctx, _event, ...args) => {
+        const [data] = validate(DevicePickerChannel.Show, DevicePickerDeviceSchema, args);
+        ctx.views.showDevicePicker(data);
+    })
+        .onRouted(DevicePickerChannel.Cancel, (ctx) => {
+        ctx.views.hideDevicePicker();
+    })
+        .onRouted(DevicePickerChannel.Select, (ctx, _event, ...args) => {
+        const [data] = validate(DevicePickerChannel.Select, DevicePickerDeviceSchema, args);
+        ctx.views.hideDevicePicker();
+        ctx.notify.devicePickerSelected(data);
+    });
+    // OverlayChannel.Ready is registered once, in tooltip.ts — every overlay
+    // renderer (this one included) funnels readiness through that single
+    // listener, so a second registration here would double-fire markOverlayReady.
+}
+export const devicePickerModule = {
+    setup: (ctx) => registerDevicePickerIpc(ctx),
+};
+//# sourceMappingURL=device-picker.js.map

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

@@ -3,6 +3,7 @@ export { registerSimulatorIpc } from './simulator.js';
 export { registerPopoverIpc, popoverModule } from './popover.js';
 export { registerTooltipIpc, tooltipModule } from './tooltip.js';
 export { registerProjectCreateIpc, projectCreateModule } from './project-create.js';
+export { registerDevicePickerIpc, devicePickerModule } from './device-picker.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';

package/dist/main/ipc/index.js

@@ -3,6 +3,7 @@ export { registerSimulatorIpc } from './simulator.js';
 export { registerPopoverIpc, popoverModule } from './popover.js';
 export { registerTooltipIpc, tooltipModule } from './tooltip.js';
 export { registerProjectCreateIpc, projectCreateModule } from './project-create.js';
+export { registerDevicePickerIpc, devicePickerModule } from './device-picker.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';

package/dist/main/ipc/internal-devtools.d.ts

@@ -1,5 +1,6 @@
 import type { Disposable } from '@dimina-kit/electron-deck/main';
 import { type SenderPolicy } from '../utils/ipc-registry.js';
+import { type IpcInput } from '../utils/ipc-context-source.js';
 import type { InternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
 /**
  * Standalone internal (app-wide) DevTools debug window. The simulator
@@ -11,5 +12,5 @@ export interface InternalDevtoolsIpcDeps {
     internalDevtoolsWindow?: InternalDevtoolsWindow;
     senderPolicy: SenderPolicy;
 }
-export declare function registerInternalDevtoolsIpc(ctx: InternalDevtoolsIpcDeps): Disposable;
+export declare function registerInternalDevtoolsIpc(input: IpcInput<InternalDevtoolsIpcDeps>): Disposable;
 //# sourceMappingURL=internal-devtools.d.ts.map

package/dist/main/ipc/internal-devtools.js

@@ -1,8 +1,9 @@
 import { InternalDevtoolsChannel } from '../../shared/ipc-channels.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-export function registerInternalDevtoolsIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(InternalDevtoolsChannel.Open, () => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerInternalDevtoolsIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(InternalDevtoolsChannel.Open, (ctx) => {
         ctx.internalDevtoolsWindow?.open();
     });
 }

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

@@ -1,6 +1,9 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { WorkbenchModule } from '../services/module.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-export declare function registerPopoverIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy'>): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+type PopoverIpcCtx = Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy' | 'workspace'>;
+export declare function registerPopoverIpc(input: IpcInput<PopoverIpcCtx>): Disposable;
 export declare const popoverModule: WorkbenchModule;
+export {};
 //# sourceMappingURL=popover.d.ts.map

package/dist/main/ipc/popover.js

@@ -1,20 +1,36 @@
 import { PopoverChannel } from '../../shared/ipc-channels-overlays.js';
-import { PopoverShowSchema, PopoverRelaunchSchema, } from '../../shared/ipc-schemas.js';
+import { PopoverShowSchema, PopoverApplySchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-export function registerPopoverIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(PopoverChannel.Show, (_event, ...args) => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerPopoverIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(PopoverChannel.Show, (ctx, _event, ...args) => {
         const [data] = validate(PopoverChannel.Show, PopoverShowSchema, args);
-        ctx.views.showPopover(data);
+        // A stale/misbehaving renderer may still send the old `modes` field —
+        // never trust it. The live state always comes from the currently open
+        // project's store, injected here.
+        const { modes: _modes, ...rest } = data;
+        const { state } = ctx.workspace.getCompileModeState();
+        ctx.views.showPopover({ ...rest, state });
     })
-        .handle(PopoverChannel.Hide, () => {
+        .handleRouted(PopoverChannel.Hide, (ctx) => {
         ctx.views.hidePopover();
     })
-        .on(PopoverChannel.Relaunch, (_event, ...args) => {
-        const [newConfig] = validate(PopoverChannel.Relaunch, PopoverRelaunchSchema, args);
+        .handleRouted(PopoverChannel.Apply, async (ctx, _event, ...args) => {
+        const [payload] = validate(PopoverChannel.Apply, PopoverApplySchema, args);
+        // Hide BEFORE touching the store: a slow or failing apply must never
+        // leave a stale popover window on screen.
         ctx.views.hidePopover();
-        ctx.notify.popoverRelaunch(newConfig);
+        try {
+            return await ctx.workspace.applyCompileModeCommand(payload.command);
+        }
+        catch (err) {
+            ctx.notify.compileModesApplyFailed({
+                message: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
     });
 }
 export const popoverModule = {

package/dist/main/ipc/project-create.d.ts

@@ -3,6 +3,7 @@ import type { ViewManager } from '../services/views/view-manager.js';
 import type { RendererNotifier } from '../services/notifications/renderer-notifier.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
 import { type SenderPolicy } from '../utils/ipc-registry.js';
+import { type IpcInput } from '../utils/ipc-context-source.js';
 /** Module-local narrow deps — deliberately NOT `Pick<WorkbenchContext, ...>`
  * (the gate in eslint.config.* is shrink-only; see its message). */
 export interface ProjectCreateIpcDeps {
@@ -10,6 +11,6 @@ export interface ProjectCreateIpcDeps {
     notify: Pick<RendererNotifier, 'projectCreateSubmitted'>;
     senderPolicy?: SenderPolicy;
 }
-export declare function registerProjectCreateIpc(ctx: ProjectCreateIpcDeps): Disposable;
+export declare function registerProjectCreateIpc(input: IpcInput<ProjectCreateIpcDeps>): Disposable;
 export declare const projectCreateModule: WorkbenchModule;
 //# sourceMappingURL=project-create.d.ts.map

package/dist/main/ipc/project-create.js

@@ -2,16 +2,17 @@ import { ProjectCreateChannel } from '../../shared/ipc-channels-overlays.js';
 import { ProjectCreateShowSchema, ProjectCreateSubmitSchema } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-export function registerProjectCreateIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .on(ProjectCreateChannel.Show, (_event, ...args) => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerProjectCreateIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .onRouted(ProjectCreateChannel.Show, (ctx, _event, ...args) => {
         const [data] = validate(ProjectCreateChannel.Show, ProjectCreateShowSchema, args);
         ctx.views.showProjectCreateDialog(data);
     })
-        .on(ProjectCreateChannel.Cancel, () => {
+        .onRouted(ProjectCreateChannel.Cancel, (ctx) => {
         ctx.views.hideProjectCreateDialog();
     })
-        .on(ProjectCreateChannel.Submit, (_event, ...args) => {
+        .onRouted(ProjectCreateChannel.Submit, (ctx, _event, ...args) => {
         const [input] = validate(ProjectCreateChannel.Submit, ProjectCreateSubmitSchema, args);
         ctx.views.hideProjectCreateDialog();
         ctx.notify.projectCreateSubmitted(input);

package/dist/main/ipc/project-fs.d.ts

@@ -1,5 +1,6 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
+import { type IpcInput } from '../utils/ipc-context-source.js';
 /** Dependency/VCS/build directories invisible to every project-tree consumer:
  * IPC `listFiles`, the `/__fs/readdir` bridge (so the workbench mirror and the
  * WAL ledger seed never walk into them), and the `/__fs/watch` change stream.
@@ -148,7 +149,8 @@ declare function listFiles(root: string, rootArg: string): Promise<string[]>;
  * Register the project-fs IPC channels. Call once during workbench setup;
  * the returned Disposable removes every channel (park on `ctx.registry`).
  */
-export declare function registerProjectFsIpc(ctx: Pick<WorkbenchContext, 'workspace' | 'senderPolicy'>): Disposable;
+type ProjectFsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'senderPolicy'>;
+export declare function registerProjectFsIpc(input: IpcInput<ProjectFsIpcCtx>): Disposable;
 /** Test seams — pure handlers, no Electron needed. */
 export declare const __testing: {
     readFile: typeof readFile;

package/dist/main/ipc/project-fs.js

@@ -45,6 +45,7 @@ import nodeFs from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
 import { IpcRegistry } from '../utils/ipc-registry.js';
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
 import { validate } from '../utils/ipc-schema.js';
 import { ProjectFsChannel } from '../../shared/ipc-channels.js';
 import { WATCH_IGNORE_DIRS } from '@dimina-kit/devkit/watch-ignore';
@@ -552,44 +553,43 @@ async function listFiles(root, rootArg) {
     }
     return out;
 }
-/**
- * Register the project-fs IPC channels. Call once during workbench setup;
- * the returned Disposable removes every channel (park on `ctx.registry`).
- */
-export function registerProjectFsIpc(ctx) {
-    const getRoot = () => ctx.workspace.getProjectPath();
-    const getLastClosedRoot = () => ctx.workspace.getLastClosedProjectPath();
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(ProjectFsChannel.GetRoot, () => getRoot())
-        .handle(ProjectFsChannel.ReadFile, (_event, ...args) => {
+export function registerProjectFsIpc(input) {
+    // Roots are read per call from the CALLING window's workspace: each window
+    // has its own open project, so a captured root would sandbox one window's
+    // file access against another's project.
+    const getRoot = (ctx) => ctx.workspace.getProjectPath();
+    const getLastClosedRoot = (ctx) => ctx.workspace.getLastClosedProjectPath();
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(ProjectFsChannel.GetRoot, (ctx) => getRoot(ctx))
+        .handleRouted(ProjectFsChannel.ReadFile, (ctx, _event, ...args) => {
         const [p] = validate(ProjectFsChannel.ReadFile, ReadFileSchema, args);
         // Reads stay scoped to the CURRENT root only — never widen the read
         // surface to the last-closed project.
-        return readFile(getRoot(), p);
+        return readFile(getRoot(ctx), p);
     })
-        .handle(ProjectFsChannel.WriteFile, (_event, ...args) => {
+        .handleRouted(ProjectFsChannel.WriteFile, (ctx, _event, ...args) => {
         const [p, content] = validate(ProjectFsChannel.WriteFile, WriteFileSchema, args);
         // Accept a write under the current OR the just-closed project root (the
         // latter rescues an in-flight teardown flush after `closeProject`). The
         // selected root then runs the FULL sandbox (realpath containment +
         // ancestor guard + O_NOFOLLOW) inside `writeFile`, so the boundary is
         // never relaxed — only WHICH root is considered.
-        const root = pickWriteRoot(p, { current: getRoot(), lastClosed: getLastClosedRoot() });
+        const root = pickWriteRoot(p, { current: getRoot(ctx), lastClosed: getLastClosedRoot(ctx) });
         return writeFile(root, p, content);
     })
-        .handleSync(ProjectFsChannel.WriteFileSync, (_event, ...args) => {
+        .handleSyncRouted(ProjectFsChannel.WriteFileSync, (ctx, _event, ...args) => {
         // Synchronous twin of WriteFile for the editor's beforeunload flush. Same
         // root selection + same sandbox (`writeFileSync` mirrors `writeFile`); the
         // only difference is the blocking transport. Returns `{ ok: true }`; any
         // throw is converted to `{ ok: false, code, message }` by `handleSync`.
         const [p, content] = validate(ProjectFsChannel.WriteFileSync, WriteFileSchema, args);
-        const root = pickWriteRoot(p, { current: getRoot(), lastClosed: getLastClosedRoot() });
+        const root = pickWriteRoot(p, { current: getRoot(ctx), lastClosed: getLastClosedRoot(ctx) });
         writeFileSync(root, p, content);
         return { ok: true };
     })
-        .handle(ProjectFsChannel.ListFiles, (_event, ...args) => {
+        .handleRouted(ProjectFsChannel.ListFiles, (ctx, _event, ...args) => {
         const [p] = validate(ProjectFsChannel.ListFiles, ListFilesSchema, args);
-        return listFiles(getRoot(), p);
+        return listFiles(getRoot(ctx), p);
     });
 }
 /** Test seams — pure handlers, no Electron needed. */

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

@@ -1,8 +1,8 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { WorkbenchModule } from '../services/module.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-type ProjectsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'windows' | 'senderPolicy' | 'projectsProvider' | 'projectTemplates' | 'customCreateProjectDialog' | 'customEditProjectDialog' | 'notify' | 'views'>;
-export declare function registerProjectsIpc(ctx: ProjectsIpcCtx): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+export type ProjectsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'windows' | 'senderPolicy' | 'projectsProvider' | 'projectTemplates' | 'customCreateProjectDialog' | 'customEditProjectDialog' | 'notify' | 'views'>;
+export declare function registerProjectsIpc(input: IpcInput<ProjectsIpcCtx>): Disposable;
 export declare const projectsModule: WorkbenchModule;
-export {};
 //# sourceMappingURL=projects.d.ts.map

package/dist/main/ipc/projects.js

@@ -4,22 +4,23 @@ import { ProjectsChannel, DialogChannel } from '../../shared/ipc-channels.js';
 import { ProjectsAddSchema, ProjectsOpenEditDialogSchema, ProjectsRemoveSchema, ProjectsUpdateSchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
 import { sanitizeTemplates } from '../services/projects/templates.js';
 import { createProject } from '../services/projects/create-project-service.js';
 import { loadWorkbenchSettings, saveWorkbenchSettings, } from '../services/settings/index.js';
-export function registerProjectsIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(ProjectsChannel.List, () => {
+export function registerProjectsIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(ProjectsChannel.List, (ctx) => {
         return ctx.workspace.listProjects();
     })
-        .handle(DialogChannel.OpenDirectory, async () => {
+        .handleRouted(DialogChannel.OpenDirectory, async (ctx) => {
         const result = await dialog.showOpenDialog(ctx.windows.mainWindow, {
             properties: ['openDirectory'],
             title: '选择小程序项目目录',
         });
         return result.canceled ? null : result.filePaths[0];
     })
-        .handle(ProjectsChannel.Add, async (_event, ...args) => {
+        .handleRouted(ProjectsChannel.Add, async (ctx, _event, ...args) => {
         const [dirPath] = validate(ProjectsChannel.Add, ProjectsAddSchema, args);
         const dirError = await ctx.workspace.validateProjectDir(dirPath);
         if (dirError) {
@@ -56,22 +57,22 @@ export function registerProjectsIpc(ctx) {
         ctx.views.hostSidebar.send('project-category-forced', { category: importedCategory });
         return project;
     })
-        .handle(ProjectsChannel.Remove, (_event, ...args) => {
+        .handleRouted(ProjectsChannel.Remove, (ctx, _event, ...args) => {
         const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
         return ctx.workspace.removeProject(dirPath);
     })
-        .handle(ProjectsChannel.Update, (_event, ...args) => {
+        .handleRouted(ProjectsChannel.Update, (ctx, _event, ...args) => {
         const [dirPath, patch] = validate(ProjectsChannel.Update, ProjectsUpdateSchema, args);
         return ctx.workspace.updateProject(dirPath, patch);
     })
         // ── template catalog + create flow ──
-        .handle(ProjectsChannel.ListTemplates, () => {
+        .handleRouted(ProjectsChannel.ListTemplates, (ctx) => {
         // Sanitize at the IPC boundary: `generate` is a function and the
         // structured-clone algorithm Electron uses for invoke would otherwise
         // throw "could not be cloned" before the renderer ever sees it.
         return sanitizeTemplates(ctx.projectTemplates ?? []);
     })
-        .handle(ProjectsChannel.OpenCreateDialog, async () => {
+        .handleRouted(ProjectsChannel.OpenCreateDialog, async (ctx) => {
         if (!ctx.customCreateProjectDialog)
             return null;
         const sanitized = sanitizeTemplates(ctx.projectTemplates ?? []);
@@ -80,7 +81,7 @@ export function registerProjectsIpc(ctx) {
             templates: sanitized,
         });
     })
-        .handle(ProjectsChannel.OpenEditDialog, async (_event, ...args) => {
+        .handleRouted(ProjectsChannel.OpenEditDialog, async (ctx, _event, ...args) => {
         if (!ctx.customEditProjectDialog)
             return null;
         const [dirPath] = validate(ProjectsChannel.OpenEditDialog, ProjectsOpenEditDialogSchema, args);
@@ -100,7 +101,7 @@ export function registerProjectsIpc(ctx) {
         // fall through into the built-in one right behind it.
         return { result };
     })
-        .handle(ProjectsChannel.Create, async (_event, ...args) => {
+        .handleRouted(ProjectsChannel.Create, async (ctx, _event, ...args) => {
         // We deliberately don't run this through zod yet — the input shape is
         // wide (any template can stash arbitrary `extra` fields) and the
         // service does its own per-field validation. Bound size to keep this
@@ -145,7 +146,7 @@ export function registerProjectsIpc(ctx) {
         }
         return project;
     })
-        .handle(ProjectsChannel.GetCreateDefaults, () => {
+        .handleRouted(ProjectsChannel.GetCreateDefaults, () => {
         // Fallback chain: persisted last parent → user's Documents → home.
         // Documents covers the common "我把项目都放在 Documents/ 下" case for
         // first-time users on macOS; home is just a safe final fallback.

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

@@ -1,6 +1,9 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { WorkbenchModule } from '../services/module.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-export declare function registerSessionIpc(ctx: Pick<WorkbenchContext, 'workspace' | 'senderPolicy'>): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+type SessionIpcCtx = Pick<WorkbenchContext, 'workspace' | 'senderPolicy'>;
+export declare function registerSessionIpc(input: IpcInput<SessionIpcCtx>): Disposable;
 export declare const sessionModule: WorkbenchModule;
+export {};
 //# sourceMappingURL=session.d.ts.map

package/dist/main/ipc/session.js

@@ -1,29 +1,34 @@
 import { ProjectChannel } from '../../shared/ipc-channels.js';
-import { ProjectCaptureThumbnailSchema, ProjectGetCompileConfigSchema, ProjectGetPagesSchema, ProjectGetThumbnailSchema, ProjectOpenSchema, ProjectSaveCompileConfigSchema, } from '../../shared/ipc-schemas.js';
+import { ProjectCaptureThumbnailSchema, ProjectGetCompileConfigSchema, ProjectGetCompileModeStateSchema, ProjectGetPagesSchema, ProjectGetThumbnailSchema, 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) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(ProjectChannel.Open, (_, ...args) => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerSessionIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(ProjectChannel.Open, (ctx, _e, ...args) => {
         const [projectPath] = validate(ProjectChannel.Open, ProjectOpenSchema, args);
         return ctx.workspace.openProject(projectPath);
     })
-        .handle(ProjectChannel.GetPages, (_, ...args) => {
+        .handleRouted(ProjectChannel.GetPages, (ctx, _e, ...args) => {
         const [projectPath] = validate(ProjectChannel.GetPages, ProjectGetPagesSchema, args);
         return ctx.workspace.getProjectPages(projectPath);
     })
-        .handle(ProjectChannel.GetCompileConfig, (_, ...args) => {
+        .handleRouted(ProjectChannel.GetCompileConfig, (ctx, _e, ...args) => {
         const [projectPath] = validate(ProjectChannel.GetCompileConfig, ProjectGetCompileConfigSchema, args);
         return ctx.workspace.getCompileConfig(projectPath);
     })
-        .handle(ProjectChannel.SaveCompileConfig, (_, ...args) => {
+        .handleRouted(ProjectChannel.SaveCompileConfig, (ctx, _e, ...args) => {
         const [projectPath, config] = validate(ProjectChannel.SaveCompileConfig, ProjectSaveCompileConfigSchema, args);
         return ctx.workspace.saveCompileConfig(projectPath, config);
     })
-        .handle(ProjectChannel.Close, () => {
+        .handleRouted(ProjectChannel.GetCompileModeState, (ctx, _e, ...args) => {
+        const [projectPath] = validate(ProjectChannel.GetCompileModeState, ProjectGetCompileModeStateSchema, args);
+        return ctx.workspace.getCompileModeState(projectPath);
+    })
+        .handleRouted(ProjectChannel.Close, (ctx) => {
         return ctx.workspace.closeProject();
     })
-        .handle(ProjectChannel.Rebuild, async () => {
+        .handleRouted(ProjectChannel.Rebuild, async (ctx) => {
         const session = ctx.workspace.getSession();
         if (!session)
             throw new Error('project:rebuild — no active project session');
@@ -34,11 +39,11 @@ export function registerSessionIpc(ctx) {
         await session.rebuild();
         return { supported: true };
     })
-        .handle(ProjectChannel.CaptureThumbnail, (_, ...args) => {
+        .handleRouted(ProjectChannel.CaptureThumbnail, (ctx, _e, ...args) => {
         const [projectPath] = validate(ProjectChannel.CaptureThumbnail, ProjectCaptureThumbnailSchema, args);
         return ctx.workspace.captureThumbnail(projectPath);
     })
-        .handle(ProjectChannel.GetThumbnail, (_, ...args) => {
+        .handleRouted(ProjectChannel.GetThumbnail, (ctx, _e, ...args) => {
         const [projectPath] = validate(ProjectChannel.GetThumbnail, ProjectGetThumbnailSchema, args);
         return ctx.workspace.getThumbnail(projectPath);
     });

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

@@ -1,6 +1,9 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
 import type { WorkbenchModule } from '../services/module.js';
-export declare function registerSettingsIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'workspace' | 'rendererDir' | 'senderPolicy'>): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+type SettingsIpcCtx = Pick<WorkbenchContext, 'views' | 'notify' | 'workspace' | 'rendererDir' | 'senderPolicy'>;
+export declare function registerSettingsIpc(input: IpcInput<SettingsIpcCtx>): Disposable;
 export declare const settingsModule: WorkbenchModule;
+export {};
 //# sourceMappingURL=settings.d.ts.map

package/dist/main/ipc/settings.js

@@ -4,29 +4,30 @@ import { WorkbenchSettingsChannel } from '../../shared/ipc-channels.js';
 import { SettingsChannel } from '../../shared/ipc-channels-overlays.js';
 import { DEFAULT_CDP_PORT } from '../../shared/constants.js';
 import { getMcpStatus } from '../services/mcp/status.js';
-import { SettingsConfigChangedSchema, SettingsProjectSettingsChangedSchema, SettingsSetVisibleSchema, WorkbenchSettingsSaveSchema, WorkbenchSettingsSetThemeSchema, } from '../../shared/ipc-schemas.js';
+import { SettingsProjectSettingsChangedSchema, SettingsSetVisibleSchema, WorkbenchSettingsSaveSchema, WorkbenchSettingsSetThemeSchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-export function registerSettingsIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(WorkbenchSettingsChannel.Get, () => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerSettingsIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(WorkbenchSettingsChannel.Get, () => {
         return loadWorkbenchSettings();
     })
-        .handle(WorkbenchSettingsChannel.Save, (_, ...args) => {
+        .handleRouted(WorkbenchSettingsChannel.Save, (_ctx, _e, ...args) => {
         const [settings] = validate(WorkbenchSettingsChannel.Save, WorkbenchSettingsSaveSchema, args);
         saveWorkbenchSettings(settings);
         applyTheme(settings.theme ?? 'system');
         return { success: true };
     })
-        .handle(WorkbenchSettingsChannel.SetTheme, (_, ...args) => {
+        .handleRouted(WorkbenchSettingsChannel.SetTheme, (_ctx, _e, ...args) => {
         const [theme] = validate(WorkbenchSettingsChannel.SetTheme, WorkbenchSettingsSetThemeSchema, args);
         applyTheme(theme);
     })
-        .handle(WorkbenchSettingsChannel.Restart, () => {
+        .handleRouted(WorkbenchSettingsChannel.Restart, () => {
         app.relaunch();
         app.quit();
     })
-        .handle(WorkbenchSettingsChannel.GetCdpStatus, () => {
+        .handleRouted(WorkbenchSettingsChannel.GetCdpStatus, () => {
         const settings = loadWorkbenchSettings();
         const switchValue = app.commandLine.getSwitchValue('remote-debugging-port');
         const implicitDevDefault = !app.isPackaged && !settings.cdp.enabled && switchValue === String(DEFAULT_CDP_PORT);
@@ -38,7 +39,7 @@ export function registerSettingsIpc(ctx) {
             implicitDevDefault,
         };
     })
-        .handle(WorkbenchSettingsChannel.GetMcpStatus, () => {
+        .handleRouted(WorkbenchSettingsChannel.GetMcpStatus, () => {
         const settings = loadWorkbenchSettings();
         const runtime = getMcpStatus();
         return {
@@ -49,14 +50,13 @@ export function registerSettingsIpc(ctx) {
             error: runtime.error,
         };
     })
-        .handle(SettingsChannel.SetVisible, async (_, ...args) => {
+        .handleRouted(SettingsChannel.SetVisible, async (ctx, _e, ...args) => {
         const [visible] = validate(SettingsChannel.SetVisible, SettingsSetVisibleSchema, args);
         if (visible) {
             await ctx.views.showSettings();
             const projectPath = ctx.workspace.getProjectPath();
             ctx.notify.settingsInit({
                 projectPath,
-                config: await ctx.workspace.getCompileConfig(projectPath),
                 projectSettings: ctx.workspace.getProjectSettings(projectPath),
             });
         }
@@ -64,14 +64,7 @@ export function registerSettingsIpc(ctx) {
             ctx.views.hideSettings();
         }
     })
-        .on(SettingsChannel.ConfigChanged, async (_, ...args) => {
-        const [config] = validate(SettingsChannel.ConfigChanged, SettingsConfigChangedSchema, args);
-        const projectPath = ctx.workspace.getProjectPath();
-        if (projectPath) {
-            await ctx.workspace.saveCompileConfig(projectPath, config);
-        }
-    })
-        .on(SettingsChannel.ProjectSettingsChanged, (_, ...args) => {
+        .onRouted(SettingsChannel.ProjectSettingsChanged, (ctx, _e, ...args) => {
         const [patch] = validate(SettingsChannel.ProjectSettingsChanged, SettingsProjectSettingsChangedSchema, args);
         ctx.workspace.updateProjectSettings(ctx.workspace.getProjectPath(), patch);
     });

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

@@ -10,6 +10,11 @@ import type { WorkbenchModule } from '../services/module.js';
  * window decides whether to actually call dmb:* channels, but the main-side
  * handlers must always be ready or `ipcRenderer.invoke('dmb:spawn')` fails
  * with `No handler registered`.
+ *
+ * The router installs onto a concrete context (it assigns `ctx.bridge`,
+ * `ctx.consoleForwarder` and `ctx.diagnostics`, which the window assembly
+ * reads straight afterwards), so it is per-window wiring rather than
+ * app-level registration.
  */
 export declare const simulatorModule: WorkbenchModule;
 //# sourceMappingURL=simulator-module.d.ts.map

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

@@ -1,4 +1,4 @@
-import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
+import { toDisposable } from '@dimina-kit/electron-deck/main';
 import { registerSimulatorIpc } from './simulator.js';
 import { installBridgeRouter } from './bridge-router.js';
 /**
@@ -12,13 +12,17 @@ import { installBridgeRouter } from './bridge-router.js';
  * window decides whether to actually call dmb:* channels, but the main-side
  * handlers must always be ready or `ipcRenderer.invoke('dmb:spawn')` fails
  * with `No handler registered`.
+ *
+ * The router installs onto a concrete context (it assigns `ctx.bridge`,
+ * `ctx.consoleForwarder` and `ctx.diagnostics`, which the window assembly
+ * reads straight afterwards), so it is per-window wiring rather than
+ * app-level registration.
  */
 export const simulatorModule = {
-    setup: (ctx) => {
-        const reg = new DisposableRegistry();
-        reg.add(registerSimulatorIpc(ctx));
+    setup: (source) => registerSimulatorIpc(source),
+    setupWindow: (ctx) => {
         installBridgeRouter(ctx);
-        return reg;
+        return toDisposable(() => { });
     },
 };
 //# sourceMappingURL=simulator-module.js.map

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

@@ -1,4 +1,7 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-export declare function registerSimulatorIpc(ctx: Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy' | 'simulatorApis' | 'bridge'>): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+type SimulatorIpcCtx = Pick<WorkbenchContext, 'views' | 'notify' | 'senderPolicy' | 'simulatorApis' | 'bridge'>;
+export declare function registerSimulatorIpc(input: IpcInput<SimulatorIpcCtx>): Disposable;
+export {};
 //# sourceMappingURL=simulator.d.ts.map