@dimina-kit/devtools 0.4.0-dev.20260803105710 → 0.4.0-dev.20260828092243

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

@@ -1,9 +1,12 @@
 export { registerAppIpc } from './app.js';
 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 { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';
 export { registerInternalDevtoolsIpc } from './internal-devtools.js';
+export { registerViewsIpc } from './views.js';
 export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/main/ipc/index.js

@@ -1,9 +1,12 @@
 export { registerAppIpc } from './app.js';
 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 { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';
 export { registerInternalDevtoolsIpc } from './internal-devtools.js';
+export { registerViewsIpc } from './views.js';
 export { simulatorModule } from './simulator-module.js';
 //# sourceMappingURL=index.js.map

package/dist/main/ipc/popover.js

@@ -1,4 +1,4 @@
-import { PopoverChannel } from '../../shared/ipc-channels.js';
+import { PopoverChannel } from '../../shared/ipc-channels-overlays.js';
 import { PopoverShowSchema, PopoverRelaunchSchema, } from '../../shared/ipc-schemas.js';
 import { validate } from '../utils/ipc-schema.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';

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

@@ -0,0 +1,15 @@
+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';
+/** Module-local narrow deps — deliberately NOT `Pick<WorkbenchContext, ...>`
+ * (the gate in eslint.config.* is shrink-only; see its message). */
+export interface ProjectCreateIpcDeps {
+    views: Pick<ViewManager, 'showProjectCreateDialog' | 'hideProjectCreateDialog'>;
+    notify: Pick<RendererNotifier, 'projectCreateSubmitted'>;
+    senderPolicy?: SenderPolicy;
+}
+export declare function registerProjectCreateIpc(ctx: ProjectCreateIpcDeps): Disposable;
+export declare const projectCreateModule: WorkbenchModule;
+//# sourceMappingURL=project-create.d.ts.map

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

@@ -0,0 +1,26 @@
+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) => {
+        const [data] = validate(ProjectCreateChannel.Show, ProjectCreateShowSchema, args);
+        ctx.views.showProjectCreateDialog(data);
+    })
+        .on(ProjectCreateChannel.Cancel, () => {
+        ctx.views.hideProjectCreateDialog();
+    })
+        .on(ProjectCreateChannel.Submit, (_event, ...args) => {
+        const [input] = validate(ProjectCreateChannel.Submit, ProjectCreateSubmitSchema, args);
+        ctx.views.hideProjectCreateDialog();
+        ctx.notify.projectCreateSubmitted(input);
+    });
+    // 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 projectCreateModule = {
+    setup: (ctx) => registerProjectCreateIpc(ctx),
+};
+//# sourceMappingURL=project-create.js.map

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

@@ -1,7 +1,7 @@
 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'>;
+type ProjectsIpcCtx = Pick<WorkbenchContext, 'workspace' | 'windows' | 'senderPolicy' | 'projectsProvider' | 'projectTemplates' | 'customCreateProjectDialog' | 'notify' | 'views'>;
 export declare function registerProjectsIpc(ctx: ProjectsIpcCtx): Disposable;
 export declare const projectsModule: WorkbenchModule;
 export {};

package/dist/main/ipc/projects.js

@@ -43,6 +43,17 @@ export function registerProjectsIpc(ctx) {
                 buttons: ['确定'],
             });
         }
+        // Imported project's own detected type wins over whatever category the
+        // sidebar happened to be showing — the list would otherwise stay on
+        // the old category and hide the project that was just added. Drives
+        // both halves: the main-window list filter (existing notify channel,
+        // same one the sidebar's own click uses) and the sidebar rail's own
+        // highlight (a push down through its narrow bridge — the rail has no
+        // other way to learn about a selection that didn't originate from its
+        // own click).
+        const importedCategory = project.type ?? 'miniprogram';
+        ctx.notify.hostSidebarCategorySelected(importedCategory);
+        ctx.views.hostSidebar.send('project-category-forced', { category: importedCategory });
         return project;
     })
         .handle(ProjectsChannel.Remove, (_event, ...args) => {

package/dist/main/ipc/session.js

@@ -22,6 +22,17 @@ export function registerSessionIpc(ctx) {
     })
         .handle(ProjectChannel.Close, () => {
         return ctx.workspace.closeProject();
+    })
+        .handle(ProjectChannel.Rebuild, async () => {
+        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 };
     })
         .handle(ProjectChannel.CaptureThumbnail, (_, ...args) => {
         const [projectPath] = validate(ProjectChannel.CaptureThumbnail, ProjectCaptureThumbnailSchema, args);

package/dist/main/ipc/settings.js

@@ -1,6 +1,7 @@
 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';

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

@@ -1,8 +1,9 @@
 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

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

@@ -1,11 +1,11 @@
 import { DisposableRegistry } 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
@@ -17,7 +17,6 @@ export const simulatorModule = {
     setup: (ctx) => {
         const reg = new DisposableRegistry();
         reg.add(registerSimulatorIpc(ctx));
-        reg.add(registerViewsIpc(ctx));
         installBridgeRouter(ctx);
         return reg;
     },

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

@@ -0,0 +1,13 @@
+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';
+/** 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(ctx: TooltipIpcDeps): Disposable;
+export declare const tooltipModule: WorkbenchModule;
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/main/ipc/tooltip.js

@@ -0,0 +1,28 @@
+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';
+export function registerTooltipIpc(ctx) {
+    return new IpcRegistry(ctx.senderPolicy)
+        .on(TooltipChannel.Prepare, () => {
+        ctx.views.prepareTooltip();
+    })
+        .on(TooltipChannel.Show, (_event, ...args) => {
+        const [data] = validate(TooltipChannel.Show, TooltipShowSchema, args);
+        ctx.views.showTooltip(data);
+    })
+        .on(TooltipChannel.Hide, () => {
+        ctx.views.hideTooltip();
+    })
+        .on(OverlayChannel.Ready, (event) => {
+        ctx.views.markOverlayReady(event.sender.id);
+    })
+        .on(TooltipChannel.Measured, (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,8 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
 /**
- * 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 +15,19 @@ 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;
 //# sourceMappingURL=views.d.ts.map

package/dist/main/ipc/views.js

@@ -1,10 +1,11 @@
 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';
 /**
- * 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,9 +18,25 @@ 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)
+        // Renderer bootstrap: allocate this session's placement-generation seed
+        // (see renderer-placement-generation.ts / PlacementReconciler.allocateGeneration).
+        .handle(ViewChannel.AllocatePlacementGeneration, () => 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
@@ -36,7 +53,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());
+        .handle(ViewChannel.HostToolbarGetHeight, () => ctx.views.getHostToolbarHeight())
+        // Same mount-time replay role as HostToolbarGetHeight, on the sidebar's
+        // inline (width) axis.
+        .handle(ViewChannel.HostSidebarGetWidth, () => 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
@@ -61,10 +81,47 @@ 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) => {
+        if (event.sender.id !== ctx.views.getHostSidebarWebContentsId())
+            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) => {
+        if (event.sender.id !== ctx.views.getHostDialogWebContentsId())
+            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/miniapp-runtime.d.ts

@@ -73,6 +73,25 @@ export interface DiminaHostToolbarPageBridge {
     send: (channel: string, payload: unknown) => void;
     onMessage: (channel: string, handler: (payload: unknown) => void) => () => void;
 }
+/**
+ * The page-side bridge injected into the host-sidebar WCV as
+ * `window.diminaHostSidebar` (see src/preload/runtime/host-sidebar-port.ts).
+ * Shape identical to `DiminaHostToolbarPageBridge` — the port-channel
+ * envelope and queueing/guard behaviour don't vary by slot.
+ */
+export interface DiminaHostSidebarPageBridge {
+    send: (channel: string, payload: unknown) => void;
+    onMessage: (channel: string, handler: (payload: unknown) => void) => () => void;
+}
+/**
+ * The page-side bridge injected into the host-dialog WCV as
+ * `window.diminaHostDialog` (see src/preload/runtime/host-dialog-port.ts).
+ * Shape identical to `DiminaHostToolbarPageBridge`.
+ */
+export interface DiminaHostDialogPageBridge {
+    send: (channel: string, payload: unknown) => void;
+    onMessage: (channel: string, handler: (payload: unknown) => void) => () => void;
+}
 declare global {
     interface Window {
         /**
@@ -81,51 +100,68 @@ declare global {
          * else, so page code must runtime-guard before use.
          */
         diminaHostToolbar?: DiminaHostToolbarPageBridge;
+        /**
+         * Present ONLY inside the host-sidebar WebContentsView's main frame
+         * (guarded injection — see host-sidebar-runtime.ts); optional everywhere
+         * else, so page code must runtime-guard before use.
+         */
+        diminaHostSidebar?: DiminaHostSidebarPageBridge;
+        /**
+         * Present ONLY inside the host-dialog WebContentsView's main frame
+         * (guarded injection — see host-dialog-runtime.ts); optional everywhere
+         * else, so page code must runtime-guard before use.
+         */
+        diminaHostDialog?: DiminaHostDialogPageBridge;
     }
 }
 /**
- * Host-facing control surface for the toolbar WebContentsView — a
- * message-channel surface (`send`/`onMessage`), with no `webContents` escape
- * hatch (that would put Electron types on the contract).
+ * Shared message-channel surface for every downstream-controllable host slot
+ * (toolbar/sidebar/dialog) — `send`/`onMessage`/`onReady` plus preload and
+ * content loading, with no `webContents` escape hatch (that would put
+ * Electron types on the contract). Each slot extends this with its own
+ * extent/visibility members.
  */
-export interface MiniappHostToolbar {
+export interface MiniappHostSlotChannel {
     /**
-     * The host's own `webPreferences.preload` for the toolbar view (purely
-     * additive — never replaces the framework's session-resident height
+     * The host's own `webPreferences.preload` for this slot's view (purely
+     * additive — never replaces the framework's session-resident size
      * advertiser). Must be set before the view is (re)created; `null` (default)
      * means "no host preload".
      */
     setPreloadPath: (path: string | null) => void;
-    /** Load a local file into the toolbar view (lazy-creates the view). */
+    /** Load a local file into the slot's view (lazy-creates the view). */
     loadFile: (path: string) => Promise<void>;
-    /** Load a URL into the toolbar view (lazy-creates the view). */
+    /** Load a URL into the slot's view (lazy-creates the view). */
     loadURL: (url: string) => Promise<void>;
     /**
-     * Post `{ channel, payload }` to the toolbar page. Gated and non-queueing:
+     * Post `{ channel, payload }` to the slot's page. Gated and non-queueing:
      * returns false (delivering nothing, creating no view) while there is no
-     * live toolbar webContents or the current load's MessagePort handshake
-     * hasn't completed; true once the envelope went out.
+     * live webContents or the current load's MessagePort handshake hasn't
+     * completed; true once the envelope went out.
      */
     send: (channel: string, payload: unknown) => boolean;
     /**
-     * Register a host-side handler for messages the toolbar page sends via
-     * `window.diminaHostToolbar.send(channel, payload)`. May be called before
-     * the view exists; survives page reloads. `dispose()` detaches (idempotent).
+     * Register a host-side handler for messages the slot's page sends via
+     * `window.dimina*.send(channel, payload)`. May be called before the view
+     * exists; survives page reloads. `dispose()` detaches (idempotent).
      */
     onMessage: (channel: string, handler: (payload: unknown) => void) => {
         dispose: () => void;
     };
     /**
      * Observe handshake readiness. Fires the handler once per load generation,
-     * exactly when the toolbar page's MessagePort handshake completes (i.e.
-     * when `send` flips to true). Registering while the channel is already
-     * ready fires once asynchronously on a microtask (missed-signal guard);
-     * a reload / re-handshake fires registered handlers again. `dispose()`
+     * exactly when the slot page's MessagePort handshake completes (i.e. when
+     * `send` flips to true). Registering while the channel is already ready
+     * fires once asynchronously on a microtask (missed-signal guard); a
+     * reload / re-handshake fires registered handlers again. `dispose()`
      * detaches (idempotent).
      */
     onReady: (handler: () => void) => {
         dispose: () => void;
     };
+}
+/** Host-facing control surface for the toolbar WebContentsView. */
+export interface MiniappHostToolbar extends MiniappHostSlotChannel {
     /**
      * Pin (`{ fixed }`) or unpin (`'auto'`) the toolbar strip height. `'auto'`
      * (default) lets the in-page height advertiser drive the placeholder.
@@ -136,6 +172,36 @@ export interface MiniappHostToolbar {
         fixed: number;
     }) => void;
 }
+/** Host-facing control surface for the sidebar WebContentsView. */
+export interface MiniappHostSidebar extends MiniappHostSlotChannel {
+    /**
+     * Pin (`{ fixed }`) or unpin (`'auto'`) the sidebar strip width. `'auto'`
+     * (default) lets the in-page width advertiser drive the placeholder.
+     * `{ fixed }` values must be finite and non-negative — anything else throws
+     * a `TypeError` synchronously and leaves the standing mode untouched.
+     */
+    setWidthMode: (mode: 'auto' | {
+        fixed: number;
+    }) => void;
+}
+/**
+ * Host-facing control surface for the by-demand, dual-axis-autosized dialog
+ * WebContentsView. Unlike the persistent toolbar/sidebar strips, the dialog
+ * is shown/hidden explicitly — there is no extent-mode setter (both axes
+ * always self-size from the page's own measured content).
+ */
+export interface MiniappHostDialog extends MiniappHostSlotChannel {
+    /**
+     * Show the dialog, centered in the main window using its self-advertised
+     * size on both axes. Creates the view's placement if needed; does not
+     * (re)load content — the host must `loadURL`/`loadFile` first.
+     */
+    show: () => void;
+    /** Hide the dialog (kept alive, content preserved) without destroying the view. */
+    hide: () => void;
+    /** Whether the dialog is currently shown. */
+    isVisible: () => boolean;
+}
 /**
  * The audited workspace surface: project list membership, session lifecycle,
  * and minimal session state. Thumbnails / per-project settings / providers
@@ -177,9 +243,11 @@ export interface MiniappWorkspace {
  * plumbing is a deliberate semver decision, not an accident of projection.
  */
 export interface MiniappRuntime {
-    /** View layer — only the host-owned toolbar control is public. */
+    /** View layer — only the host-owned slot controls are public. */
     views: {
         readonly hostToolbar: MiniappHostToolbar;
+        readonly hostSidebar: MiniappHostSidebar;
+        readonly hostDialog: MiniappHostDialog;
     };
     /** Project + session workspace (see {@link MiniappWorkspace}). */
     workspace: MiniappWorkspace;

package/dist/main/services/layout/index.d.ts

@@ -41,4 +41,15 @@ export declare const SETTINGS_W = 320;
  */
 export declare function computeSettingsBounds(contentWidth: number, contentHeight: number, headerHeight: number): Bounds;
 export declare function computePopoverBounds(contentWidth: number, contentHeight: number, headerHeight: number): Bounds;
+export declare function computeTooltipMaxWidth(contentWidth: number): number;
+/**
+ * Position the tooltip overlay relative to its trigger's own bounding rect
+ * (both in main-window content coordinates). Prefers directly below the
+ * anchor, flips above when there isn't room; always clamped horizontally
+ * inside the content area.
+ */
+export declare function computeTooltipBounds(anchor: Bounds, contentWidth: number, contentHeight: number, measured: {
+    width: number;
+    height: number;
+}): Bounds;
 //# sourceMappingURL=index.d.ts.map

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

@@ -52,4 +52,27 @@ export function computePopoverBounds(contentWidth, contentHeight, headerHeight)
         height: contentHeight - headerHeight,
     };
 }
+const TOOLTIP_GAP = 6;
+const TOOLTIP_EDGE_MARGIN = 4;
+export function computeTooltipMaxWidth(contentWidth) {
+    return Math.max(1, contentWidth - TOOLTIP_EDGE_MARGIN * 2);
+}
+/**
+ * Position the tooltip overlay relative to its trigger's own bounding rect
+ * (both in main-window content coordinates). Prefers directly below the
+ * anchor, flips above when there isn't room; always clamped horizontally
+ * inside the content area.
+ */
+export function computeTooltipBounds(anchor, contentWidth, contentHeight, measured) {
+    const availableWidth = computeTooltipMaxWidth(contentWidth);
+    const width = Math.min(availableWidth, Math.max(1, Math.ceil(measured.width)));
+    const height = Math.max(1, Math.ceil(measured.height));
+    const below = anchor.y + anchor.height + TOOLTIP_GAP;
+    const fitsBelow = below + height <= contentHeight;
+    const y = fitsBelow ? below : Math.max(0, anchor.y - TOOLTIP_GAP - height);
+    const centeredX = anchor.x + anchor.width / 2 - width / 2;
+    const maxX = Math.max(TOOLTIP_EDGE_MARGIN, contentWidth - width - TOOLTIP_EDGE_MARGIN);
+    const x = Math.min(maxX, Math.max(TOOLTIP_EDGE_MARGIN, centeredX));
+    return { x, y, width, height };
+}
 //# sourceMappingURL=index.js.map

package/dist/main/services/network-forward/frontend-dispatch.js

@@ -113,7 +113,8 @@ export function createFrontendReplyChannel(hostWc, isDisposed) {
 export function drainOutboundBatch(batch, handle) {
     if (!Array.isArray(batch))
         return;
-    for (const raw of batch) {
+    const entries = batch;
+    for (const raw of entries) {
         if (!raw || typeof raw !== 'object')
             continue;
         const cmd = raw;

package/dist/main/services/notifications/renderer-notifier.d.ts

@@ -2,7 +2,8 @@ import type { BrowserWindow, WebContents, WebContentsView } from 'electron';
 import type { CompileConfig } from '../../../shared/types.js';
 import { type EditorOpenFilePayload } from '../../../shared/ipc-channels.js';
 import type { WorkbenchSettings } from '../settings/index.js';
-import type { ProjectSettings } from '../projects/project-repository.js';
+import type { ProjectSettings, ProjectType } from '../projects/project-repository.js';
+import type { UpdateInfo } from '../../../shared/types.js';
 /**
  * Payload for the `project:status` event sent whenever compile status changes.
  */
@@ -114,15 +115,45 @@ export interface RendererNotifier {
      * placeholder div resizes (closes the host-toolbar dynamic-height loop).
      */
     hostToolbarHeightChanged(height: number): void;
+    /**
+     * Push the reserved host-sidebar width to the main renderer so its sidebar
+     * placeholder div resizes, mirroring `hostToolbarHeightChanged` on the
+     * inline axis.
+     */
+    hostSidebarWidthChanged(width: number): void;
+    /**
+     * Push the project category selected in the host-sidebar's content to the
+     * main renderer so `ProjectListScreen` filters `ProjectList` accordingly.
+     */
+    hostSidebarCategorySelected(category: ProjectType): void;
     /**
      * Ask the main renderer's Monaco editor to open a project file at a position.
      * Drives the "click a console file link → open in editor" pipeline.
      */
     editorOpenFile(payload: EditorOpenFilePayload): void;
+    /**
+     * Relay a project-create-dialog submission from the overlay panel back to
+     * the main renderer, which owns the scaffold flow (createProject + list
+     * refresh) — the panel only collects the form and hands it off.
+     */
+    projectCreateSubmitted(payload: {
+        name: string;
+        path: string;
+        templateId: string;
+    }): void;
     /** Initialise the currently shown compile popover overlay. */
     popoverInit(popoverView: WebContentsView, payload: unknown): void;
     /** Initialise the currently shown settings overlay (no-op if hidden). */
     settingsInit(payload: SettingsInitPayload): void;
+    /** Push the label text (+ anchor) into the tooltip overlay's own renderer. */
+    tooltipInit(tooltipView: WebContentsView, payload: unknown): void;
+    /** Push the template catalog + base-dir defaults into the project-create overlay. */
+    projectCreateInit(dialogView: WebContentsView, payload: {
+        templates: unknown[];
+        defaultBaseDir: string;
+    }): void;
+    /** Push a discovered update's info into the update overlay. */
+    updateAvailable(dialogView: WebContentsView, payload: UpdateInfo): void;
     /** Initialise the standalone workbench-settings window. */
     workbenchSettingsInit(window: BrowserWindow, payload: WorkbenchSettingsInitPayload): void;
 }