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

package/dist/main/services/views/overlay-panels-view.js

@@ -5,6 +5,7 @@ import { applyNavigationHardening } from '../../windows/navigation-hardening.js'
 import * as layout from '../layout/index.js';
 import { HEADER_H } from '../../../shared/constants.js';
 import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
+import { UpdateChannel } from '../../../shared/ipc-channels-overlays.js';
 export function createOverlayPanelsView(ctx, reconciler, deps) {
     function overlayHeaderHeight() {
         return HEADER_H + deps.getHostToolbarHeight();
@@ -83,6 +84,50 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         pushData: (view, data) => ctx.notify.tooltipInit(view, data),
         readyMode: 'manual',
     });
+    /**
+     * Both devtools-owned dialog panels occupy the full main-window content
+     * rect (they render their own centered card + backdrop), so unlike
+     * settings/popover/tooltip they need no anchor-derived bounds computation —
+     * just the window's current content size, recomputed on every show/resize.
+     */
+    function fullWindowBounds() {
+        const [width = 0, height = 0] = ctx.windows.mainWindow.getContentSize();
+        return { x: 0, y: 0, width: Math.max(1, width), height: Math.max(1, height) };
+    }
+    const projectCreateDialogPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/project-create-dialog/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.projectCreateDialog, VIEW_LAYER.dialog),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.projectCreateDialog, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.projectCreateDialog, view),
+        pushData: (view, data) => ctx.notify.projectCreateInit(view, data),
+        readyMode: 'manual',
+    });
+    const updateDialogPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/update-dialog/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.updateDialog, VIEW_LAYER.dialog),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.updateDialog, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.updateDialog, view),
+        pushData: (view, data) => ctx.notify.updateAvailable(view, data),
+        readyMode: 'manual',
+    });
     let tooltipRequestId = 0;
     let activeTooltip = null;
     async function showSettings() {
@@ -126,10 +171,30 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         activeTooltip = null;
         tooltipPanel.hide();
     }
+    function showProjectCreateDialog(data) {
+        projectCreateDialogPanel.show(data, fullWindowBounds());
+    }
+    function hideProjectCreateDialog() {
+        projectCreateDialogPanel.hide();
+    }
+    function showUpdateDialog(data) {
+        updateDialogPanel.show(data, fullWindowBounds());
+    }
+    function hideUpdateDialog() {
+        updateDialogPanel.hide();
+    }
+    function notifyUpdateDownloadProgress(percent) {
+        const wc = updateDialogPanel.getWebContents();
+        if (!wc)
+            return;
+        wc.send(UpdateChannel.DownloadProgress, { percent });
+    }
     function markOverlayReady(webContentsId) {
         settingsPanel.markReady(webContentsId);
         popoverPanel.markReady(webContentsId);
         tooltipPanel.markReady(webContentsId);
+        projectCreateDialogPanel.markReady(webContentsId);
+        updateDialogPanel.markReady(webContentsId);
     }
     function applyTooltipMeasurement(webContentsId, measurement) {
         const active = activeTooltip;
@@ -141,22 +206,38 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         tooltipPanel.reposition(layout.computeTooltipBounds(active.anchor, w, h, measurement));
     }
     function reapplyPresentOverlays() {
-        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings))
-            void showSettings();
+        // Fire-and-forget re-trigger — a crash between this call and the panel
+        // becoming ready now rejects whenReady() (see overlay-panel.ts teardown);
+        // handleViewBroken() already logs it, nothing more to do here.
+        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) {
+            showSettings().catch(() => { });
+        }
         if (popoverPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.popover)) {
             const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
             popoverPanel.reposition(layout.computePopoverBounds(w, h, overlayHeaderHeight()));
         }
+        if (projectCreateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.projectCreateDialog)) {
+            projectCreateDialogPanel.reposition(fullWindowBounds());
+        }
+        if (updateDialogPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.updateDialog)) {
+            updateDialogPanel.reposition(fullWindowBounds());
+        }
     }
     function applySettingsBoundsIfPresent() {
-        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings))
-            void showSettings();
+        // See reapplyPresentOverlays() above for why this swallows a rejection.
+        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings)) {
+            showSettings().catch(() => { });
+        }
     }
     function destroySettings() {
         activeTooltip = null;
         settingsPanel.destroy();
         tooltipPanel.destroy();
     }
+    function destroyDialogs() {
+        projectCreateDialogPanel.destroy();
+        updateDialogPanel.destroy();
+    }
     return {
         showSettings,
         hideSettings,
@@ -167,13 +248,21 @@ export function createOverlayPanelsView(ctx, reconciler, deps) {
         hideTooltip,
         markOverlayReady,
         applyTooltipMeasurement,
+        showProjectCreateDialog,
+        hideProjectCreateDialog,
+        showUpdateDialog,
+        hideUpdateDialog,
+        notifyUpdateDownloadProgress,
         reapplyPresentOverlays,
         applySettingsBoundsIfPresent,
         destroySettings,
+        destroyDialogs,
         getSettingsWebContents: () => settingsPanel.getWebContents(),
         getSettingsWebContentsId: () => settingsPanel.getWebContentsId(),
         getPopoverWebContentsId: () => popoverPanel.getWebContentsId(),
         getTooltipWebContentsId: () => tooltipPanel.getWebContentsId(),
+        getProjectCreateDialogWebContentsId: () => projectCreateDialogPanel.getWebContentsId(),
+        getUpdateDialogWebContentsId: () => updateDialogPanel.getWebContentsId(),
     };
 }
 //# sourceMappingURL=overlay-panels-view.js.map

package/dist/main/services/views/placement-reconciler.d.ts

@@ -36,8 +36,10 @@ export interface ViewSlot {
  * settings/popover are main-owned and live in `overlayDesired`. Any change
  * merges the two, runs the pure reconcile core, and applies the ordered ops
  * through `viewTarget`. `epochCounter` is a single monotonic tick — main is the
- * only (serial) reconcile caller, so the core's stale guard passes by
- * construction; `rendererGeneration` still drives the reset on renderer restart.
+ * only (serial) reconcile caller, so the core's stale-epoch guard passes by
+ * construction; `rendererGeneration` is the high-water mark that drives both
+ * the reset on a genuinely newer generation and the hard rejection of a
+ * snapshot from behind it (see `setPlacementSnapshot`).
  */
 export interface PlacementReconciler {
     registerView(viewId: string, slot: ViewSlot): void;
@@ -56,6 +58,16 @@ export interface PlacementReconciler {
     setOverlayDesired(viewId: string, desired: DesiredView<DevtoolsExtra>): void;
     deleteOverlayDesired(viewId: string): void;
     hasOverlayDesired(viewId: string): boolean;
+    /**
+     * Hand out a fresh generation seed for a renderer bootstrap (see
+     * renderer-placement-generation.ts). Strictly exceeds both the current
+     * high-water mark (`rendererGeneration`, which a full renderer reload does
+     * NOT reset — this reconciler lives in the long-lived main process) and
+     * every previously allocated seed, so a reload that races ahead of its own
+     * previous session's accepted snapshots can never be handed a value that
+     * `setPlacementSnapshot` would reject as stale.
+     */
+    allocateGeneration(): number;
 }
 export declare function createPlacementReconciler(ctx: ViewManagerContext): PlacementReconciler;
 //# sourceMappingURL=placement-reconciler.d.ts.map

package/dist/main/services/views/placement-reconciler.js

@@ -5,6 +5,7 @@ export function createPlacementReconciler(ctx) {
     let placementState = createInitialState();
     let epochCounter = 0;
     let rendererGeneration = 0;
+    let allocatedGeneration = 0;
     const appliedActual = new Map();
     const baseDesired = new Map();
     const overlayDesired = new Map();
@@ -119,6 +120,28 @@ export function createPlacementReconciler(ctx) {
         placementState = { ...placementState, actual: cloneAppliedActual() };
     }
     function setPlacementSnapshot(snapshot) {
+        // Hard reject a snapshot from BEHIND the current high-water mark — a
+        // complete no-op, touching neither `rendererGeneration` nor
+        // `baseDesired`. The renderer hands out one shared, strictly monotonic
+        // sequence across every screen (see renderer-placement-generation.ts),
+        // so under normal operation a lower generation can only be a LATE
+        // arrival from an already-superseded source (e.g. a dead screen's
+        // delayed `dispose()` empty-snapshot flush racing a successor screen's
+        // mount). The previous version of this guard clamped
+        // `rendererGeneration` to never regress but still unconditionally
+        // applied the stale snapshot's CONTENT into `baseDesired` under the
+        // clamped (i.e. current) generation number — which defeated the
+        // reconcile core's own generation-regression guard
+        // (placement-reconcile.ts: `snapshot.generation < prev.generation`) by
+        // never letting it see the snapshot's real, lower generation. That let a
+        // dead screen's stale/empty view list silently overwrite a currently
+        // active screen's real views. Dropping it here, before it ever reaches
+        // `baseDesired`, is what actually gives the stale snapshot zero side
+        // effects.
+        if (snapshot.generation < rendererGeneration) {
+            console.warn(`[placement-reconciler] snapshot generation ${snapshot.generation} is behind the current ${rendererGeneration}; dropping without applying its content`);
+            return;
+        }
         rendererGeneration = snapshot.generation;
         baseDesired.clear();
         for (const v of snapshot.views)
@@ -150,6 +173,10 @@ export function createPlacementReconciler(ctx) {
         setOverlayDesired: (viewId, desired) => { overlayDesired.set(viewId, desired); },
         deleteOverlayDesired: (viewId) => { overlayDesired.delete(viewId); },
         hasOverlayDesired: (viewId) => overlayDesired.has(viewId),
+        allocateGeneration: () => {
+            allocatedGeneration = Math.max(allocatedGeneration, rendererGeneration) + 1;
+            return allocatedGeneration;
+        },
     };
 }
 //# sourceMappingURL=placement-reconciler.js.map

package/dist/main/services/views/placement-test-driver.d.ts

@@ -31,6 +31,7 @@ interface OverlaySink {
     }): void;
 }
 export declare function hostToolbarBounds(mgr: SnapshotSink, rect: Rect): void;
+export declare function hostSidebarBounds(mgr: SnapshotSink, rect: Rect): void;
 export declare function simulatorDevtoolsBounds(mgr: SnapshotSink, rect: Rect): void;
 export declare function workbenchBounds(mgr: SnapshotSink, rect: Rect): void;
 export declare function showSettingsReady(mgr: OverlaySink): Promise<void>;

package/dist/main/services/views/placement-test-driver.js

@@ -28,6 +28,9 @@ function pushView(mgr, view, generation = 1) {
 export function hostToolbarBounds(mgr, rect) {
     pushView(mgr, { viewId: VIEW_ID.hostToolbar, placement: toPlacement(rect), layer: VIEW_LAYER.hostToolbar });
 }
+export function hostSidebarBounds(mgr, rect) {
+    pushView(mgr, { viewId: VIEW_ID.hostSidebar, placement: toPlacement(rect), layer: VIEW_LAYER.hostSidebar });
+}
 export function simulatorDevtoolsBounds(mgr, rect) {
     pushView(mgr, { viewId: VIEW_ID.simulatorDevtools, placement: toPlacement(rect), layer: VIEW_LAYER.base });
 }

package/dist/main/services/views/view-manager-devtools-host-test-fixtures.js

@@ -95,7 +95,9 @@ export function electronModuleMock() {
 export function pathsModuleMock() {
     return {
         mainPreloadPath: '/stub/preload.js',
-        hostToolbarPreloadPath: '/stub/host-toolbar-preload.js',
+        hostToolbarRuntimePreloadPath: '/stub/host-toolbar-preload.js',
+        hostSidebarRuntimePreloadPath: '/stub/host-sidebar-preload.js',
+        hostDialogRuntimePreloadPath: '/stub/host-dialog-preload.js',
         cjsSiblingPreloadPath: (p) => p.replace(/\.js$/, '.cjs'),
         devtoolsPackageRoot: '/stub/devtools-pkg-root',
     };

package/dist/main/services/views/view-manager.d.ts

@@ -1,9 +1,11 @@
 import type { WebContents } from 'electron';
 import type { NativeDeviceInfo } from '../../../shared/ipc-channels.js';
 import { type WorkbenchContext } from '../workbench-context.js';
-import type { HostToolbarMessageSubscription } from './host-toolbar-port-channel.js';
 import type { PlacementSnapshot } from '@dimina-kit/electron-deck/layout';
 import type { DevtoolsExtra } from '../../../shared/view-ids.js';
+import { type HostToolbarControl } from './host-toolbar-view.js';
+import { type HostSidebarViewManagerMembers } from './host-sidebar-view.js';
+import { type HostDialogViewManagerMembers } from './host-dialog-view.js';
 import { type OverlayPanelsView, type TooltipShowPayload } from './overlay-panels-view.js';
 export type { TooltipShowPayload };
 export { resolveProjectEditorTarget, type ProjectEditorTarget, } from './resolve-project-editor-target.js';
@@ -91,7 +93,7 @@ export interface ViewManagerContext {
  * panels) and shares a single injected placement reconciler; this file wires
  * them together and exposes their combined method surface.
  */
-export interface ViewManager extends Pick<OverlayPanelsView, 'showSettings' | 'hideSettings' | 'showPopover' | 'hidePopover' | 'prepareTooltip' | 'showTooltip' | 'hideTooltip' | 'markOverlayReady' | 'applyTooltipMeasurement'> {
+export interface ViewManager extends Pick<OverlayPanelsView, 'showSettings' | 'hideSettings' | 'showPopover' | 'hidePopover' | 'prepareTooltip' | 'showTooltip' | 'hideTooltip' | 'markOverlayReady' | 'applyTooltipMeasurement' | 'showProjectCreateDialog' | 'hideProjectCreateDialog' | 'showUpdateDialog' | 'hideUpdateDialog' | 'notifyUpdateDownloadProgress' | 'getProjectCreateDialogWebContentsId' | 'getUpdateDialogWebContentsId'>, HostSidebarViewManagerMembers, HostDialogViewManagerMembers {
     /**
      * NATIVE-HOST ONLY. Create the simulator itself as a top-level
      * WebContentsView (not a renderer `<webview>` guest) loading `simulatorUrl`,
@@ -202,6 +204,12 @@ export interface ViewManager extends Pick<OverlayPanelsView, 'showSettings' | 'h
      * view tree.
      */
     setPlacementSnapshot(snapshot: PlacementSnapshot<DevtoolsExtra>): void;
+    /**
+     * Hand out a fresh generation seed for a renderer bootstrap. See
+     * `PlacementReconciler.allocateGeneration`'s doc-comment for why this
+     * replaces a wall-clock (`Date.now()`) seed.
+     */
+    allocatePlacementGeneration(): number;
     /**
      * Lazily create the workbench WebContentsView, load `<url>index.html`, and
      * add it to the contentView. `url` is the COI server's base URL (trailing
@@ -261,82 +269,6 @@ export interface ViewManager extends Pick<OverlayPanelsView, 'showSettings' | 'h
      */
     readonly hostToolbar: HostToolbarControl;
 }
-/**
- * Height mode for the host-toolbar placeholder strip. `'auto'` (default): the
- * session-resident advertiser's reports drive the height. `{ fixed }`: the
- * host pins the height; advertiser reports are ignored until `'auto'` again.
- */
-export type HostToolbarHeightMode = 'auto' | {
-    fixed: number;
-};
-/**
- * The control object the downstream host uses to own the toolbar
- * WebContentsView. Lazily backed by the view-manager's `hostToolbarView`.
- */
-export interface HostToolbarControl {
-    /** Load a URL into the toolbar view (lazy-creates the view). */
-    loadURL(url: string): Promise<void>;
-    /** Load a local file into the toolbar view (lazy-creates the view). */
-    loadFile(path: string): Promise<void>;
-    /** The toolbar view's live WebContents, or null if not yet created/destroyed. */
-    readonly webContents: WebContents | null;
-    /** Remove the toolbar view from the contentView and reset it (kept alive). */
-    hide(): void;
-    /**
-     * The HOST's own `webPreferences.preload` for the toolbar view (purely
-     * additive). The framework's height-advertiser runtime does NOT ride
-     * `webPreferences.preload` — it is session-resident (registered on
-     * `session.defaultSession`, self-guarded by the `--dimina-host-toolbar`
-     * marker + `isMainFrame`), so a host preload set here coexists with it and
-     * never replaces it. Must be set before the view is (re)created (first
-     * `loadURL`/`loadFile`, or the next one after the host closed the
-     * webContents); `null` (default) means "no host preload" — it does not and
-     * cannot restore any built-in preload.
-     */
-    setPreloadPath(path: string | null): void;
-    /**
-     * Register a host-side handler for messages the toolbar PAGE sends via
-     * `window.diminaHostToolbar.send(channel, payload)`. Control-level: may be
-     * called before the view exists and survives page reloads / wc rebuilds
-     * (each per-load MessagePort handshake re-attaches the registry to the new
-     * port). Throws on an empty / non-string channel. `dispose()` detaches
-     * (idempotent).
-     */
-    onMessage(channel: string, handler: (payload: unknown) => void): HostToolbarMessageSubscription;
-    /**
-     * Observe handshake readiness — the push counterpart to polling `send()`
-     * for `true`. Fires the handler once per load generation, exactly when
-     * that load's MessagePort handshake completes; registering while the
-     * channel is ALREADY ready fires once asynchronously on a microtask
-     * (missed-signal race guard, re-validated at fire time). A reload /
-     * re-handshake fires registered handlers again; a host-initiated
-     * `loadURL`/`loadFile` invalidates readiness at initiation, so handlers
-     * registered in that window wait for the NEW document's handshake.
-     * `dispose()` detaches (idempotent); `disposeAll` sweeps everything.
-     */
-    onReady(handler: () => void): HostToolbarMessageSubscription;
-    /**
-     * Post `{ channel, payload }` to the toolbar page (received via
-     * `window.diminaHostToolbar.onMessage(channel, handler)`). Gated and
-     * non-queueing: returns false — delivering nothing, creating no view —
-     * while there is no live toolbar webContents, the current load's
-     * MessagePort handshake hasn't completed, or a document-replacing
-     * navigation is in flight (`loadURL`/`loadFile` was issued, or the page
-     * itself started a main-frame cross-document navigation, and the new
-     * document hasn't handshaked yet); true once the envelope went out.
-     * No manual `getHostToolbarWebContentsId` gating needed: the false/true
-     * result IS the readiness signal.
-     */
-    send(channel: string, payload: unknown): boolean;
-    /**
-     * Pin or unpin the toolbar strip height. `{ fixed }` notifies the renderer
-     * placeholder with that height immediately (so a preload-less/static toolbar
-     * is visible without any advertiser report) and ignores subsequent advertiser
-     * reports. `'auto'` (default) re-enables advertiser-driven height starting
-     * from the NEXT report — it does not synthesize/replay a stale height.
-     */
-    setHeightMode(mode: HostToolbarHeightMode): void;
-}
 /**
  * Build a ViewManager bound to the given context. The returned object is the
  * only component allowed to instantiate or add/remove overlay WebContentsViews.

package/dist/main/services/views/view-manager.js

@@ -3,6 +3,8 @@ import { createPlacementReconciler } from './placement-reconciler.js';
 import { createWorkbenchView } from './workbench-view.js';
 import { createDevtoolsHost } from './native-simulator-devtools-host.js';
 import { createHostToolbarView } from './host-toolbar-view.js';
+import { createHostSidebarView } from './host-sidebar-view.js';
+import { createHostDialogView } from './host-dialog-view.js';
 import { createOverlayPanelsView, } from './overlay-panels-view.js';
 import { createNativeSimulatorView } from './native-simulator-view.js';
 export { resolveProjectEditorTarget, } from './resolve-project-editor-target.js';
@@ -34,6 +36,11 @@ export function createViewManager(ctx) {
     const hostToolbar = createHostToolbarView(ctx, reconciler, {
         reapplyPresentOverlays: () => reapplyToolbarDependentOverlays(),
     });
+    // Sidebar and dialog are host-scoped like the toolbar (survive project
+    // close/reopen) but carry no height-cycle dependency on the overlay panels,
+    // so unlike hostToolbar they need no thunk into this scope.
+    const hostSidebar = createHostSidebarView(ctx, reconciler);
+    const hostDialog = createHostDialogView(ctx, reconciler);
     const overlayPanels = createOverlayPanelsView(ctx, reconciler, {
         getHostToolbarHeight: hostToolbar.getHostToolbarHeight,
     });
@@ -63,9 +70,15 @@ export function createViewManager(ctx) {
         // a release/cap replay to rebuild.
         workbench.cancelWorkbenchAttachHold();
         disposeProjectViews();
-        // Host-scoped teardown: the toolbar view, its port channel, and the
-        // ref-counted session-runtime preload registration.
+        // Host-scoped teardown: the toolbar/sidebar/dialog views, their port
+        // channels, and their ref-counted session-runtime preload registrations.
         hostToolbar.dispose();
+        hostSidebar.dispose();
+        hostDialog.dispose();
+        // Devtools-owned overlay-panel dialogs (project-create/update) — never
+        // torn down by disposeProjectViews(), they'd otherwise outlive every
+        // other view once the app tears down.
+        overlayPanels.destroyDialogs();
     }
     return {
         attachNativeSimulator: nativeSimulator.attachNativeSimulator,
@@ -82,7 +95,17 @@ export function createViewManager(ctx) {
         hideTooltip: overlayPanels.hideTooltip,
         markOverlayReady: overlayPanels.markOverlayReady,
         applyTooltipMeasurement: overlayPanels.applyTooltipMeasurement,
-        repositionAll: () => overlayPanels.reapplyPresentOverlays(),
+        showProjectCreateDialog: overlayPanels.showProjectCreateDialog,
+        hideProjectCreateDialog: overlayPanels.hideProjectCreateDialog,
+        showUpdateDialog: overlayPanels.showUpdateDialog,
+        hideUpdateDialog: overlayPanels.hideUpdateDialog,
+        notifyUpdateDownloadProgress: overlayPanels.notifyUpdateDownloadProgress,
+        getProjectCreateDialogWebContentsId: overlayPanels.getProjectCreateDialogWebContentsId,
+        getUpdateDialogWebContentsId: overlayPanels.getUpdateDialogWebContentsId,
+        repositionAll: () => {
+            overlayPanels.reapplyPresentOverlays();
+            hostDialog.reposition();
+        },
         disposeProjectViews,
         disposeAll,
         getSimulatorWebContentsId: nativeSimulator.getSimulatorWebContentsId,
@@ -96,6 +119,7 @@ export function createViewManager(ctx) {
         getHostToolbarHeight: hostToolbar.getHostToolbarHeight,
         resize: () => overlayPanels.applySettingsBoundsIfPresent(),
         setPlacementSnapshot: reconciler.setPlacementSnapshot,
+        allocatePlacementGeneration: reconciler.allocateGeneration,
         attachWorkbench: workbench.attachWorkbench,
         setWorkbenchSource: workbench.setWorkbenchSource,
         detachWorkbench: workbench.detachWorkbench,
@@ -104,6 +128,13 @@ export function createViewManager(ctx) {
         cancelWorkbenchAttachHold: workbench.cancelWorkbenchAttachHold,
         setHostToolbarHeight: hostToolbar.setHostToolbarHeight,
         hostToolbar: hostToolbar.control,
+        getHostSidebarWebContentsId: hostSidebar.getHostSidebarWebContentsId,
+        getHostSidebarWidth: hostSidebar.getHostSidebarWidth,
+        setHostSidebarWidth: hostSidebar.setHostSidebarWidth,
+        hostSidebar: hostSidebar.control,
+        getHostDialogWebContentsId: hostDialog.getHostDialogWebContentsId,
+        reportHostDialogMeasuredExtent: hostDialog.reportMeasuredExtent,
+        hostDialog: hostDialog.control,
     };
 }
 //# sourceMappingURL=view-manager.js.map

package/dist/main/utils/paths.d.ts

@@ -31,6 +31,10 @@ export declare const mainPreloadPath: string;
  * npm/pnpm node_modules and ASAR packaging alike get an absolute, correct path.
  */
 export declare const hostToolbarRuntimePreloadPath: string;
+/** Session-registered sidebar-runtime preload bundle, mirroring {@link hostToolbarRuntimePreloadPath}. */
+export declare const hostSidebarRuntimePreloadPath: string;
+/** Session-registered dialog-runtime preload bundle, mirroring {@link hostToolbarRuntimePreloadPath}. */
+export declare const hostDialogRuntimePreloadPath: string;
 export declare const simulatorDir: string;
 /**
  * DevTools builds its own copy of every native mini-app runtime asset. Pin the

package/dist/main/utils/paths.js

@@ -59,6 +59,10 @@ export const mainPreloadPath = path.join(devtoolsPackageRoot, 'dist/preload/wind
  * npm/pnpm node_modules and ASAR packaging alike get an absolute, correct path.
  */
 export const hostToolbarRuntimePreloadPath = path.join(devtoolsPackageRoot, 'dist/preload/windows/host-toolbar-runtime.cjs');
+/** Session-registered sidebar-runtime preload bundle, mirroring {@link hostToolbarRuntimePreloadPath}. */
+export const hostSidebarRuntimePreloadPath = path.join(devtoolsPackageRoot, 'dist/preload/windows/host-sidebar-runtime.cjs');
+/** Session-registered dialog-runtime preload bundle, mirroring {@link hostToolbarRuntimePreloadPath}. */
+export const hostDialogRuntimePreloadPath = path.join(devtoolsPackageRoot, 'dist/preload/windows/host-dialog-runtime.cjs');
 export const simulatorDir = path.join(devtoolsPackageRoot, 'dist/simulator');
 /**
  * DevTools builds its own copy of every native mini-app runtime asset. Pin the

package/dist/main/utils/sender-policy.js

@@ -54,6 +54,16 @@ export function createWorkbenchSenderPolicy(ctx) {
         const tooltipViewId = ctx.views.getTooltipWebContentsId();
         if (tooltipViewId != null && sender.id === tooltipViewId)
             return true;
+        // Project-create-dialog overlay view. Devtools-owned bundled renderer
+        // (the WCV that replaced the Radix DOM-portal dialog), same trust level
+        // as settings/popover/tooltip.
+        const projectCreateDialogViewId = ctx.views.getProjectCreateDialogWebContentsId();
+        if (projectCreateDialogViewId != null && sender.id === projectCreateDialogViewId)
+            return true;
+        // Update-available overlay view. Same devtools-owned trust level.
+        const updateDialogViewId = ctx.views.getUpdateDialogWebContentsId();
+        if (updateDialogViewId != null && sender.id === updateDialogViewId)
+            return true;
         // The host-toolbar overlay is DELIBERATELY NOT trusted here. The host loads
         // arbitrary content into it, so granting it the global white-list would open
         // all ~72 IpcRegistry channels to that content. Its one channel (the reverse