@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/main/ipc/session-listener-bag.js

@@ -1,40 +1,2 @@
-/**
- * Session-scoped listener bookkeeping. An app session hangs lifecycle hooks on
- * emitters it does NOT own — the shared simulator WebContentsView, a pooled
- * service-host window — and those emitters outlive the session (one simulator
- * wc soft-reloads through many sessions). Every such hook is registered
- * through this bag so the session's single teardown chokepoint can detach them
- * all with one `dispose()`; a hook left behind survives as a dead listener on
- * the shared emitter, growing by one per soft reload until Node's MaxListeners
- * warning fires.
- */
-export function createSessionListenerBag() {
-    const records = [];
-    let disposed = false;
-    return {
-        on(emitter, event, fn) {
-            if (disposed)
-                return;
-            emitter.on(event, fn);
-            records.push({ emitter, event, fn });
-        },
-        once(emitter, event, fn) {
-            if (disposed)
-                return;
-            emitter.once(event, fn);
-            records.push({ emitter, event, fn });
-        },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            for (const { emitter, event, fn } of records) {
-                if (emitter.isDestroyed?.())
-                    continue;
-                emitter.removeListener(event, fn);
-            }
-            records.length = 0;
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/session-listener-bag';
 //# sourceMappingURL=session-listener-bag.js.map

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,51 +1,51 @@
 import { ProjectChannel } from '../../shared/ipc-channels.js';
-import { ProjectCaptureThumbnailSchema, ProjectGetCompileConfigSchema, ProjectGetPagesSchema, ProjectGetThumbnailSchema, ProjectOpenSchema, ProjectSaveCompileConfigSchema, ProjectGetLaunchConfigsSchema, ProjectSaveLaunchConfigsSchema, ProjectGetActiveLaunchConfigIdSchema, ProjectSaveActiveLaunchConfigIdSchema, } 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.CaptureThumbnail, (_, ...args) => {
+        .handleRouted(ProjectChannel.Rebuild, async (ctx) => {
+        const session = ctx.workspace.getSession();
+        if (!session)
+            throw new Error('project:rebuild — no active project session');
+        // A host CompilationAdapter predating session.rebuild must not break:
+        // degrade discernibly so the renderer falls back to reattach-only.
+        if (typeof session.rebuild !== 'function')
+            return { supported: false };
+        await session.rebuild();
+        return { supported: true };
+    })
+        .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);
-    })
-        .handle(ProjectChannel.GetLaunchConfigs, (_, ...args) => {
-        const [projectPath] = validate(ProjectChannel.GetLaunchConfigs, ProjectGetLaunchConfigsSchema, args);
-        return ctx.workspace.getLaunchConfigs(projectPath);
-    })
-        .handle(ProjectChannel.SaveLaunchConfigs, (_, ...args) => {
-        const [projectPath, configs] = validate(ProjectChannel.SaveLaunchConfigs, ProjectSaveLaunchConfigsSchema, args);
-        return ctx.workspace.saveLaunchConfigs(projectPath, configs);
-    })
-        .handle(ProjectChannel.GetActiveLaunchConfigId, (_, ...args) => {
-        const [projectPath] = validate(ProjectChannel.GetActiveLaunchConfigId, ProjectGetActiveLaunchConfigIdSchema, args);
-        return ctx.workspace.getActiveLaunchConfigId(projectPath);
-    })
-        .handle(ProjectChannel.SaveActiveLaunchConfigId, (_, ...args) => {
-        const [projectPath, id] = validate(ProjectChannel.SaveActiveLaunchConfigId, ProjectSaveActiveLaunchConfigIdSchema, args);
-        return ctx.workspace.saveActiveLaunchConfigId(projectPath, id);
     });
 }
 export const sessionModule = {

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

@@ -1,27 +1,33 @@
 import { app } from 'electron';
 import { loadWorkbenchSettings, saveWorkbenchSettings, applyTheme, } from '../services/settings/index.js';
-import { WorkbenchSettingsChannel, SettingsChannel } from '../../shared/ipc-channels.js';
+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.GetCdpStatus, () => {
+        .handleRouted(WorkbenchSettingsChannel.Restart, () => {
+        app.relaunch();
+        app.quit();
+    })
+        .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);
@@ -33,7 +39,7 @@ export function registerSettingsIpc(ctx) {
             implicitDevDefault,
         };
     })
-        .handle(WorkbenchSettingsChannel.GetMcpStatus, () => {
+        .handleRouted(WorkbenchSettingsChannel.GetMcpStatus, () => {
         const settings = loadWorkbenchSettings();
         const runtime = getMcpStatus();
         return {
@@ -44,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),
             });
         }
@@ -59,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

@@ -1,14 +1,20 @@
 import type { WorkbenchModule } from '../services/module.js';
 /**
- * The 'simulator' built-in module fans out into the simulator + views IPC
- * registrars. Bundle them under a single module so app.ts only sees one
- * entry per BuiltinModuleId.
+ * The 'simulator' built-in module. views.ts's `registerViewsIpc` is NOT
+ * bundled in here — it's registered unconditionally by app.ts (see that call
+ * site's comment for why: host-sidebar/host-toolbar placement has no real
+ * dependency on the simulator module).
  *
  * Bridge router (native-host PAGE_OPEN / NAV_ACTION / TAB_ACTION etc.) hooks
  * up unconditionally — the `__diminaNativeHost.enabled` flag in the simulator
  * 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,25 +1,28 @@
-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';
-import { registerViewsIpc } from './views.js';
 /**
- * The 'simulator' built-in module fans out into the simulator + views IPC
- * registrars. Bundle them under a single module so app.ts only sees one
- * entry per BuiltinModuleId.
+ * The 'simulator' built-in module. views.ts's `registerViewsIpc` is NOT
+ * bundled in here — it's registered unconditionally by app.ts (see that call
+ * site's comment for why: host-sidebar/host-toolbar placement has no real
+ * dependency on the simulator module).
  *
  * Bridge router (native-host PAGE_OPEN / NAV_ACTION / TAB_ACTION etc.) hooks
  * up unconditionally — the `__diminaNativeHost.enabled` flag in the simulator
  * 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));
-        reg.add(registerViewsIpc(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

package/dist/main/ipc/simulator.js

@@ -1,41 +1,35 @@
-import { ServiceHostChannel, SimulatorChannel, SimulatorCustomApiChannel } from '../../shared/ipc-channels.js';
+import { SimulatorChannel, SimulatorCustomApiChannel } from '../../shared/ipc-channels.js';
 import { SimulatorAttachNativeSchema, SimulatorCustomApiInvokeSchema, SimulatorSetDeviceInfoSchema, SimulatorSoftReloadSchema, } from '../../shared/ipc-schemas.js';
-import { deviceInfoToHostEnv } from '../../shared/bridge-channels.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-export function registerSimulatorIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(SimulatorChannel.AttachNative, (_, ...args) => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerSimulatorIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(SimulatorChannel.AttachNative, (ctx, _e, ...args) => {
         const [simulatorUrl, simWidth] = validate(SimulatorChannel.AttachNative, SimulatorAttachNativeSchema, args);
         return ctx.views.attachNativeSimulator(simulatorUrl, simWidth);
     })
-        .handle(SimulatorChannel.SoftReload, (_, ...args) => {
+        .handleRouted(SimulatorChannel.SoftReload, (ctx, _e, ...args) => {
         const [simulatorUrl] = validate(SimulatorChannel.SoftReload, SimulatorSoftReloadSchema, args);
         return ctx.views.softReloadNativeSimulator(simulatorUrl);
     })
-        .handle(SimulatorChannel.Detach, () => {
+        .handleRouted(SimulatorChannel.Detach, (ctx) => {
         ctx.views.detachSimulator();
     })
-        .handle(SimulatorChannel.SetDeviceInfo, (_, ...args) => {
+        .handleRouted(SimulatorChannel.SetDeviceInfo, (ctx, _e, ...args) => {
         const [device] = validate(SimulatorChannel.SetDeviceInfo, SimulatorSetDeviceInfoSchema, args);
         // Cache the selection (rides the next NATIVE_HOST_ENABLED reply for a
         // race-free DeviceShell init) and push DEVICE_CHANGE to the live simulator
         // WCV so the DeviceShell resizes the bezel + re-renders status bar / notch.
+        // `setDevice` also pushes `hostEnvUpdate` + `pageResize` to every running
+        // service host, so `wx.getSystemInfoSync()` and `Page.onResize` follow
+        // the selection without a relaunch.
         ctx.bridge?.setDevice(device);
         // Re-push the CSS env(safe-area-inset-*) override to attached render-host
         // guests so notch-aware page layout updates without a reload.
         ctx.views.reapplySafeArea(device);
-        // Live-update the running service-host window's host-env snapshot so
-        // `wx.getSystemInfoSync()` reflects the selected device without a relaunch.
-        // The service-host preload mutates `__diminaSpawnContext` in place;
-        // `getSystemInfoSync` reads it fresh on each call. No service window yet
-        // (pre-spawn) → no-op.
-        const serviceWc = ctx.bridge?.getServiceWc();
-        if (serviceWc && !serviceWc.isDestroyed()) {
-            serviceWc.send(ServiceHostChannel.HostEnvUpdate, deviceInfoToHostEnv(device));
-        }
     })
-        .handle(SimulatorCustomApiChannel.Invoke, (_, ...args) => {
+        .handleRouted(SimulatorCustomApiChannel.Invoke, (ctx, _e, ...args) => {
         const [name, params] = validate(SimulatorCustomApiChannel.Invoke, SimulatorCustomApiInvokeSchema, args);
         return ctx.simulatorApis.invoke(name, params);
     });

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

@@ -0,0 +1,14 @@
+import type { WorkbenchModule } from '../services/module.js';
+import type { ViewManager } from '../services/views/view-manager.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 TooltipIpcDeps {
+    views: Pick<ViewManager, 'prepareTooltip' | 'showTooltip' | 'hideTooltip' | 'markOverlayReady' | 'applyTooltipMeasurement'>;
+    senderPolicy?: SenderPolicy;
+}
+export declare function registerTooltipIpc(input: IpcInput<TooltipIpcDeps>): Disposable;
+export declare const tooltipModule: WorkbenchModule;
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/main/ipc/tooltip.js

@@ -0,0 +1,29 @@
+import { OverlayChannel, TooltipChannel } from '../../shared/ipc-channels-overlays.js';
+import { TooltipMeasuredSchema, TooltipShowSchema } 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 registerTooltipIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .onRouted(TooltipChannel.Prepare, (ctx) => {
+        ctx.views.prepareTooltip();
+    })
+        .onRouted(TooltipChannel.Show, (ctx, _event, ...args) => {
+        const [data] = validate(TooltipChannel.Show, TooltipShowSchema, args);
+        ctx.views.showTooltip(data);
+    })
+        .onRouted(TooltipChannel.Hide, (ctx) => {
+        ctx.views.hideTooltip();
+    })
+        .onRouted(OverlayChannel.Ready, (ctx, event) => {
+        ctx.views.markOverlayReady(event.sender.id);
+    })
+        .onRouted(TooltipChannel.Measured, (ctx, event, ...args) => {
+        const [measurement] = validate(TooltipChannel.Measured, TooltipMeasuredSchema, args);
+        ctx.views.applyTooltipMeasurement(event.sender.id, measurement);
+    });
+}
+export const tooltipModule = {
+    setup: (ctx) => registerTooltipIpc(ctx),
+};
+//# sourceMappingURL=tooltip.js.map

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

@@ -1,7 +1,10 @@
 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';
+type ViewsIpcCtx = Pick<WorkbenchContext, 'views' | 'senderPolicy'>;
 /**
- * Renderer-driven overlay bounds.
+ * Renderer-driven overlay bounds, plus the renderer bootstrap's
+ * placement-generation seed pull.
  *
  * The main window's React layout is the source of truth for where the
  * editor view and the simulator's Chromium DevTools overlay live on
@@ -14,6 +17,20 @@ import type { Disposable } from '@dimina-kit/electron-deck/main';
  * panel is collapsed or the tab is not selected. The view manager removes
  * the child view from the contentView but keeps the WebContents alive so
  * subsequent re-shows skip the OpenSumi DI bootstrap.
+ *
+ * Registered UNCONDITIONALLY by app.ts — NOT gated behind `modules.simulator`
+ * (`WorkbenchAppConfig.modules`). None of `ctx.views` (`ViewManager`) is
+ * itself conditional on that toggle — it's constructed unconditionally in
+ * `createContext` and used unconditionally elsewhere (onResize, the
+ * update-dialog panel, workbench detach) — and host-sidebar in particular
+ * lives on the project-list page, wholly unrelated to the mini-program
+ * simulator webview a disabled `modules.simulator` would actually skip. Every
+ * renderer entry point also blocks its first render on
+ * `AllocatePlacementGeneration` (see renderer-placement-generation.ts) —
+ * gating any of this behind the simulator toggle would strand a host that
+ * disables it on the fatal boot-failure page, or leave placement silently
+ * non-functional. See disabled-module.test.ts for the end-to-end guard.
  */
-export declare function registerViewsIpc(ctx: Pick<WorkbenchContext, 'views' | 'senderPolicy'>): Disposable;
+export declare function registerViewsIpc(input: IpcInput<ViewsIpcCtx>): Disposable;
+export {};
 //# sourceMappingURL=views.d.ts.map

package/dist/main/ipc/views.js

@@ -1,10 +1,12 @@
 import { ipcMain } from 'electron';
-import { ViewChannel } from '../../shared/ipc-channels.js';
-import { PlacementSnapshotSchema, HostToolbarAdvertiseHeightSchema, } from '../../shared/ipc-schemas.js';
+import { ViewChannel } from '../../shared/ipc-channels-overlays.js';
+import { PlacementSnapshotSchema, HostToolbarAdvertiseHeightSchema, HostSidebarAdvertiseWidthSchema, HostDialogAdvertiseSizeSchema, } 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';
 /**
- * Renderer-driven overlay bounds.
+ * Renderer-driven overlay bounds, plus the renderer bootstrap's
+ * placement-generation seed pull.
  *
  * The main window's React layout is the source of truth for where the
  * editor view and the simulator's Chromium DevTools overlay live on
@@ -17,14 +19,37 @@ import { IpcRegistry } from '../utils/ipc-registry.js';
  * panel is collapsed or the tab is not selected. The view manager removes
  * the child view from the contentView but keeps the WebContents alive so
  * subsequent re-shows skip the OpenSumi DI bootstrap.
+ *
+ * Registered UNCONDITIONALLY by app.ts — NOT gated behind `modules.simulator`
+ * (`WorkbenchAppConfig.modules`). None of `ctx.views` (`ViewManager`) is
+ * itself conditional on that toggle — it's constructed unconditionally in
+ * `createContext` and used unconditionally elsewhere (onResize, the
+ * update-dialog panel, workbench detach) — and host-sidebar in particular
+ * lives on the project-list page, wholly unrelated to the mini-program
+ * simulator webview a disabled `modules.simulator` would actually skip. Every
+ * renderer entry point also blocks its first render on
+ * `AllocatePlacementGeneration` (see renderer-placement-generation.ts) —
+ * gating any of this behind the simulator toggle would strand a host that
+ * disables it on the fatal boot-failure page, or leave placement silently
+ * non-functional. See disabled-module.test.ts for the end-to-end guard.
  */
-export function registerViewsIpc(ctx) {
-    const registry = new IpcRegistry(ctx.senderPolicy)
+export function registerViewsIpc(input) {
+    const source = toIpcContextSource(input);
+    // The raw listeners below trust an exact wc id, and each window mounts its
+    // own host slots — so the id itself names the owning window. Scanning the
+    // live contexts for the one whose slot holds this sender is both the trust
+    // gate and the routing decision; no match means the message came from
+    // somewhere that is not a host slot at all, and is dropped.
+    const ownerOfSlot = (event, slotWebContentsId) => source.list().find((ctx) => slotWebContentsId(ctx) === event.sender.id) ?? null;
+    const registry = new IpcRegistry(source)
+        // Renderer bootstrap: allocate this session's placement-generation seed
+        // (see renderer-placement-generation.ts / PlacementReconciler.allocateGeneration).
+        .handleRouted(ViewChannel.AllocatePlacementGeneration, (ctx) => ctx.views.allocatePlacementGeneration())
         // Window-level placement snapshot: the single source of truth for every
         // managed native view's bounds/visibility/z-order. The renderer's central
         // publisher coalesces one snapshot per frame; the reconciler diffs it
         // against the actual view tree. Supersedes the per-view bounds channels.
-        .handle(ViewChannel.PlacementSnapshot, (_event, ...args) => {
+        .handleRouted(ViewChannel.PlacementSnapshot, (ctx, _event, ...args) => {
         const [snapshot] = validate(ViewChannel.PlacementSnapshot, PlacementSnapshotSchema, args);
         ctx.views.setPlacementSnapshot(snapshot);
     })
@@ -36,7 +61,10 @@ export function registerViewsIpc(ctx) {
         // senderPolicy-gated registry as HostToolbarBounds: the toolbar WCV's
         // arbitrary host content must not reach this — only the trusted main
         // renderer pulls. Live delegation, not a registration-time snapshot.
-        .handle(ViewChannel.HostToolbarGetHeight, () => ctx.views.getHostToolbarHeight());
+        .handleRouted(ViewChannel.HostToolbarGetHeight, (ctx) => ctx.views.getHostToolbarHeight())
+        // Same mount-time replay role as HostToolbarGetHeight, on the sidebar's
+        // inline (width) axis.
+        .handleRouted(ViewChannel.HostSidebarGetWidth, (ctx) => ctx.views.getHostSidebarWidth());
     // Reverse size-advertiser: the toolbar WCV's OWN renderer sends this, and the
     // host loads ARBITRARY content into that WCV. We DELIBERATELY do NOT add the
     // toolbar wc to the global sender policy — that would trust it for ALL ~72
@@ -48,7 +76,8 @@ export function registerViewsIpc(ctx) {
     // The host content can reach ONLY this one channel, carrying only a
     // non-negative integer height.
     const onAdvertiseHeight = (event, ...args) => {
-        if (event.sender.id !== ctx.views.getHostToolbarWebContentsId())
+        const ctx = ownerOfSlot(event, (c) => c.views.getHostToolbarWebContentsId());
+        if (!ctx)
             return;
         let extent;
         try {
@@ -61,10 +90,49 @@ export function registerViewsIpc(ctx) {
         ctx.views.setHostToolbarHeight(extent);
     };
     ipcMain.on(ViewChannel.HostToolbarAdvertiseHeight, onAdvertiseHeight);
+    // Same precise-sender-id trust model as onAdvertiseHeight, on the
+    // sidebar's inline (width) axis.
+    const onAdvertiseWidth = (event, ...args) => {
+        const ctx = ownerOfSlot(event, (c) => c.views.getHostSidebarWebContentsId());
+        if (!ctx)
+            return;
+        let extent;
+        try {
+            ;
+            [{ extent }] = validate(ViewChannel.HostSidebarAdvertiseWidth, HostSidebarAdvertiseWidthSchema, args);
+        }
+        catch {
+            return; // malformed payload from the host's own content — drop it
+        }
+        ctx.views.setHostSidebarWidth(extent);
+    };
+    ipcMain.on(ViewChannel.HostSidebarAdvertiseWidth, onAdvertiseWidth);
+    // Same precise-sender-id trust model as onAdvertiseHeight/onAdvertiseWidth,
+    // but the dialog is a single by-demand overlay rather than a persistent
+    // slot: either axis may arrive, and the view manager re-centers using
+    // whichever axes it has measured so far.
+    const onAdvertiseDialogSize = (event, ...args) => {
+        const ctx = ownerOfSlot(event, (c) => c.views.getHostDialogWebContentsId());
+        if (!ctx)
+            return;
+        let axis;
+        let extent;
+        try {
+            ;
+            [{ axis, extent }] = validate(ViewChannel.HostDialogAdvertiseSize, HostDialogAdvertiseSizeSchema, args);
+        }
+        catch {
+            return; // malformed payload from the host's own content — drop it
+        }
+        ctx.views.reportHostDialogMeasuredExtent(axis, extent);
+    };
+    ipcMain.on(ViewChannel.HostDialogAdvertiseSize, onAdvertiseDialogSize);
     return {
         dispose() {
             void registry.dispose();
             ipcMain.removeListener(ViewChannel.HostToolbarAdvertiseHeight, onAdvertiseHeight);
+            ipcMain.removeListener(ViewChannel.HostSidebarAdvertiseWidth, onAdvertiseWidth);
+            ipcMain.removeListener(ViewChannel.HostDialogAdvertiseSize, onAdvertiseDialogSize);
         },
     };
 }

package/dist/main/runtime/devtools-backend-before-quit.harness.d.ts

@@ -0,0 +1,43 @@
+import type { WorkbenchAppConfig } from '../../shared/types.js';
+import type { RuntimeBackend } from '@dimina-kit/electron-deck';
+declare const viewManagerStubs: {
+    createdManagers: Array<{
+        disposeAll: () => void;
+    }>;
+};
+export { stubs, devkitStubs } from './devtools-runtime-mock.harness.js';
+export { viewManagerStubs };
+/**
+ * Shared per-test setup both `devtools-backend-before-quit.test.ts` and
+ * `devtools-backend-shutdown-race.test.ts` need identically: reset modules
+ * (fresh `let`-scoped module-level state in `devtools-backend.ts` each
+ * test), reset the mock harness above, and dynamically re-import `electron`
+ * + `createDevtoolsBackend` — dynamic, not a static top-level import,
+ * because it must happen AFTER `vi.resetModules()` picks up a fresh module
+ * instance each test. Registers its own `beforeEach`; call once per
+ * describing test file. Returns a mutable state object (not individual
+ * values) because `beforeEach` reassigns its fields once per test, after
+ * this function itself has already returned.
+ */
+export interface BackendTestState {
+    createDevtoolsBackend: typeof import('./devtools-backend.js').createDevtoolsBackend;
+    electron: typeof import('electron');
+}
+export declare function registerBackendTestLifecycle(): BackendTestState;
+/**
+ * Shared setup for the two tests (one in `devtools-backend-before-quit.test.ts`,
+ * one in `devtools-backend-shutdown-race.test.ts`) that need to observe
+ * `assemble()` PAUSED mid-flight, inside a still-pending `config.onSetup`:
+ * builds the backend with a gated `onSetup`, runs `beforeReady`/`assemble`,
+ * and waits until the assembled `ViewManager` is actually reachable (proof
+ * `createDevtoolsRuntime` has progressed past instance construction) before
+ * handing control back — the caller then fires whatever quit-path event it's
+ * testing while `onSetup` is still gated, and is responsible for calling
+ * `releaseOnSetup()` + awaiting `assemblePromise` itself.
+ */
+export declare function startAssemblingWithGatedOnSetup(createDevtoolsBackend: BackendTestState['createDevtoolsBackend'], extraConfig?: Omit<WorkbenchAppConfig, 'onSetup'>): Promise<{
+    backend: RuntimeBackend;
+    assemblePromise: Promise<void>;
+    releaseOnSetup: () => void;
+}>;
+//# sourceMappingURL=devtools-backend-before-quit.harness.d.ts.map