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

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/services/workbench-context.d.ts

@@ -21,8 +21,8 @@ import { type WorkspaceService } from './workspace/workspace-service.js';
 import { type SimulatorApiRegistry } from './simulator/custom-apis.js';
 import { type SimulatorUiExtensionRegistry } from './simulator/ui-extensions.js';
 import { sanitizeTemplates } from './projects/templates.js';
-import type { ProjectsProvider, ProjectTemplate } from './projects/types.js';
-import type { CustomCreateProjectDialogResult } from '../../shared/types.js';
+import type { Project, ProjectsProvider, ProjectTemplate } from './projects/types.js';
+import type { CustomCreateProjectDialogResult, CustomEditProjectDialogResult } from '../../shared/types.js';
 /**
  * Shared mutable state for the workbench application.
  * Passed to each IPC module so they can read/write shared state without closures.
@@ -96,6 +96,17 @@ export interface WorkbenchContext extends RuntimeContext {
         parentWindow: BrowserWindow;
         templates: ProjectTemplate[];
     }) => Promise<CustomCreateProjectDialogResult>;
+    /**
+     * Optional host hook for the "编辑项目" dialog. When present, the
+     * `projects:openEditDialog` IPC runs it and wraps whatever it resolves to
+     * as `{ result }`; when absent, the IPC returns `null` and the renderer
+     * shows the built-in dialog. `project` comes from `workspace.listProjects`,
+     * not the renderer's IPC args.
+     */
+    customEditProjectDialog?: (ctx: {
+        parentWindow: BrowserWindow;
+        project: Project;
+    }) => Promise<CustomEditProjectDialogResult>;
     /**
      * Host permission gate consulted by `workspace.openProject` BEFORE any side
      * effect. Throwing vetoes the open (see `WorkbenchAppConfig.onBeforeOpenProject`).
@@ -239,8 +250,9 @@ export interface WorkbenchContext extends RuntimeContext {
  * because their shapes intentionally differ from the config:
  *  - `preloadPath` / `rendererDir` are REQUIRED here (the caller resolves the
  *    defaults before constructing the context) but optional in the config;
- *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` use
- *    the main-process types, not the structural mirrors in `shared/types`.
+ *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` /
+ *    `customEditProjectDialog` use the main-process types, not the structural
+ *    mirrors in `shared/types`.
  */
 export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' | 'apiNamespaces' | 'appName' | 'fileTypes'> {
     mainWindow: BrowserWindow;
@@ -255,6 +267,8 @@ export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' |
     builtinTemplates?: 'all' | 'none' | readonly string[];
     /** Host-supplied "新建项目" dialog hook. */
     customCreateProjectDialog?: WorkbenchContext['customCreateProjectDialog'];
+    /** Host-supplied "编辑项目" dialog hook. */
+    customEditProjectDialog?: WorkbenchContext['customEditProjectDialog'];
     /** Host permission gate run before a project opens (throw to veto). */
     onBeforeOpenProject?: WorkbenchContext['onBeforeOpenProject'];
 }

package/dist/main/services/workbench-context.js

@@ -74,6 +74,7 @@ export function createWorkbenchContext(opts) {
     ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();
     ctx.projectTemplates = resolveTemplates(BUILTIN_TEMPLATES, opts.projectTemplates ?? [], opts.builtinTemplates ?? 'all');
     ctx.customCreateProjectDialog = opts.customCreateProjectDialog;
+    ctx.customEditProjectDialog = opts.customEditProjectDialog;
     ctx.onBeforeOpenProject = opts.onBeforeOpenProject;
     ctx.workspace = createWorkspaceService(ctx);
     ctx.senderPolicy = createWorkbenchSenderPolicy(ctx);

package/dist/main/services/workspace/workspace-service.d.ts

@@ -1,6 +1,7 @@
 import type { AppInfo, CompileConfig, ProjectSession } from '../../../shared/types.js';
 import type { WorkbenchContext } from '../workbench-context.js';
 import type { Project, ProjectPages, ProjectSettings } from '../projects/project-repository.js';
+import type { ProjectPatch } from '../projects/types.js';
 /**
  * Result returned to the renderer after `project:open` finishes.
  * Mirrors the previous inline shape in ipc/session.ts so no
@@ -28,6 +29,7 @@ export interface WorkspaceService {
     listProjects(): Promise<Project[]>;
     addProject(dirPath: string): Promise<Project>;
     removeProject(dirPath: string): Promise<void>;
+    updateProject(dirPath: string, patch: ProjectPatch): Promise<Project>;
     hasProject(dirPath: string): Promise<boolean>;
     validateProjectDir(dirPath: string): Promise<string | null>;
     openProject(projectPath: string): Promise<OpenProjectResult>;

package/dist/main/services/workspace/workspace-service.js

@@ -158,6 +158,20 @@ export function createWorkspaceService(ctx) {
         removeProject: async (dirPath) => {
             await provider.removeProject(dirPath);
         },
+        updateProject: async (dirPath, patch) => {
+            const projects = await provider.listProjects();
+            const existing = projects.find((p) => p.path === dirPath);
+            if (!existing)
+                throw new Error(`No such project: ${dirPath}`);
+            // A provider without `updateProject` cannot persist the edit. Returning
+            // the record unchanged would look like a successful save to the
+            // renderer (dialog closes, list reloads) while silently discarding the
+            // user's input, so this must fail loudly instead.
+            if (!provider.updateProject) {
+                throw new Error('当前宿主不支持编辑项目');
+            }
+            return provider.updateProject(dirPath, patch);
+        },
         hasProject: async (dirPath) => {
             const projects = await provider.listProjects();
             return projects.some((p) => p.path === dirPath);

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