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

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

@@ -13,9 +13,36 @@ interface SnapshotSink {
         views: DesiredView<DevtoolsExtra>[];
     }): void;
 }
+interface OverlaySink {
+    showSettings(): Promise<void>;
+    showPopover(data: unknown): void;
+    showTooltip(data: {
+        anchor: Rect;
+        text: string;
+    }): void;
+    getSettingsWebContentsId(): number | null;
+    getPopoverWebContentsId(): number | null;
+    getTooltipWebContentsId(): number | null;
+    markOverlayReady(webContentsId: number): void;
+    applyTooltipMeasurement(webContentsId: number, measurement: {
+        requestId: number;
+        width: number;
+        height: number;
+    }): 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>;
+export declare function showPopoverReady(mgr: OverlaySink, data: unknown): void;
+export declare function showTooltipReady(mgr: OverlaySink, data: {
+    anchor: Rect;
+    text: string;
+}, size?: {
+    width: number;
+    height: number;
+}): void;
 export declare function simulatorBounds(mgr: SnapshotSink, params: Rect & {
     zoom: number;
 }): void;

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

@@ -12,6 +12,7 @@ import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
 // pushes on one manager never look stale.
 let globalEpoch = 0;
 const desiredByMgr = new WeakMap();
+const tooltipRequestByMgr = new WeakMap();
 function toPlacement(r) {
     return r.width > 0 && r.height > 0 ? { visible: true, bounds: r } : { visible: false };
 }
@@ -27,12 +28,40 @@ 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 });
 }
 export function workbenchBounds(mgr, rect) {
     pushView(mgr, { viewId: VIEW_ID.workbench, placement: toPlacement(rect), layer: VIEW_LAYER.base });
 }
+export async function showSettingsReady(mgr) {
+    const shown = mgr.showSettings();
+    const webContentsId = mgr.getSettingsWebContentsId();
+    if (webContentsId === null)
+        throw new Error('settings view was not created');
+    mgr.markOverlayReady(webContentsId);
+    await shown;
+}
+export function showPopoverReady(mgr, data) {
+    mgr.showPopover(data);
+    const webContentsId = mgr.getPopoverWebContentsId();
+    if (webContentsId === null)
+        throw new Error('popover view was not created');
+    mgr.markOverlayReady(webContentsId);
+}
+export function showTooltipReady(mgr, data, size = { width: 80, height: 28 }) {
+    mgr.showTooltip(data);
+    const webContentsId = mgr.getTooltipWebContentsId();
+    if (webContentsId === null)
+        throw new Error('tooltip view was not created');
+    mgr.markOverlayReady(webContentsId);
+    const requestId = (tooltipRequestByMgr.get(mgr) ?? 0) + 1;
+    tooltipRequestByMgr.set(mgr, requestId);
+    mgr.applyTooltipMeasurement(webContentsId, { requestId, ...size });
+}
 export function simulatorBounds(mgr, params) {
     const { zoom, ...rect } = params;
     pushView(mgr, { viewId: VIEW_ID.simulator, placement: toPlacement(rect), layer: VIEW_LAYER.base, extra: { zoom } });

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,13 @@
 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';
 /**
  * Context surface used by the ViewManager. We only need a small slice of the
@@ -89,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 {
+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`,
@@ -132,14 +136,6 @@ export interface ViewManager {
      * `windows/views.ts` module, which every detach call relied on.
      */
     detachSimulator(): void;
-    /** Lazy-create and show the settings overlay view. */
-    showSettings(): Promise<void>;
-    /** Remove the settings overlay view (kept around for next open). */
-    hideSettings(): void;
-    /** Create and show the popover overlay with the given init payload. */
-    showPopover(data: unknown): void;
-    /** Destroy the popover overlay and notify the renderer. */
-    hidePopover(): void;
     /** Re-apply layout for every currently visible overlay (on window resize). */
     repositionAll(): void;
     /**
@@ -170,6 +166,8 @@ export interface ViewManager {
     getSettingsWebContentsId(): number | null;
     /** Return the webContents ID of the popover overlay if alive, else null. */
     getPopoverWebContentsId(): number | null;
+    /** Return the webContents ID of the tooltip overlay if alive, else null. */
+    getTooltipWebContentsId(): number | null;
     /**
      * Return the webContents ID of the host-toolbar overlay if alive, else null.
      * The host-toolbar WCV is the one overlay whose OWN renderer drives an IPC
@@ -206,6 +204,12 @@ export interface ViewManager {
      * 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
@@ -265,82 +269,6 @@ export interface ViewManager {
      */
     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,7 +3,9 @@ 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 { createOverlayPanelsView } from './overlay-panels-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,
@@ -77,7 +90,22 @@ export function createViewManager(ctx) {
         hideSettings: overlayPanels.hideSettings,
         showPopover: overlayPanels.showPopover,
         hidePopover: overlayPanels.hidePopover,
-        repositionAll: () => overlayPanels.reapplyPresentOverlays(),
+        prepareTooltip: overlayPanels.prepareTooltip,
+        showTooltip: overlayPanels.showTooltip,
+        hideTooltip: overlayPanels.hideTooltip,
+        markOverlayReady: overlayPanels.markOverlayReady,
+        applyTooltipMeasurement: overlayPanels.applyTooltipMeasurement,
+        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,
@@ -86,10 +114,12 @@ export function createViewManager(ctx) {
         getSettingsWebContents: overlayPanels.getSettingsWebContents,
         getSettingsWebContentsId: overlayPanels.getSettingsWebContentsId,
         getPopoverWebContentsId: overlayPanels.getPopoverWebContentsId,
+        getTooltipWebContentsId: overlayPanels.getTooltipWebContentsId,
         getHostToolbarWebContentsId: hostToolbar.getHostToolbarWebContentsId,
         getHostToolbarHeight: hostToolbar.getHostToolbarHeight,
         resize: () => overlayPanels.applySettingsBoundsIfPresent(),
         setPlacementSnapshot: reconciler.setPlacementSnapshot,
+        allocatePlacementGeneration: reconciler.allocateGeneration,
         attachWorkbench: workbench.attachWorkbench,
         setWorkbenchSource: workbench.setWorkbenchSource,
         detachWorkbench: workbench.detachWorkbench,
@@ -98,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/views/workbench-view.js

@@ -1,7 +1,7 @@
 import { nativeTheme, WebContentsView } from 'electron';
 import { handleWindowOpenExternal } from '../../windows/navigation-hardening.js';
+import { themeBg } from '../../utils/theme.js';
 import { VIEW_ID } from '../../../shared/view-ids.js';
-import { destroyChildView } from './destroy-child-view.js';
 /**
  * Upper bound on how long a hold may defer the workbench attach. A hung or
  * very slow first compile (or a lost release on some open path) degrades to a
@@ -45,6 +45,14 @@ export function createWorkbenchView(ctx, reconciler) {
         if (!workbenchView || workbenchView.webContents.isDestroyed())
             return;
         const wc = workbenchView.webContents;
+        // Keep the WCV surface in sync with the active color scheme: the workbench
+        // page can only recolor its own inner #workbench, never the html/body
+        // backdrop, so the native surface must follow the theme flip too.
+        try {
+            if (typeof workbenchView.setBackgroundColor === 'function')
+                workbenchView.setBackgroundColor(themeBg());
+        }
+        catch { /* view/wc gone mid-flip */ }
         if (typeof wc.executeJavaScript !== 'function')
             return;
         const script = `window.__WB_SET_THEME && window.__WB_SET_THEME(${JSON.stringify(workbenchThemeScheme())})`;
@@ -61,6 +69,17 @@ export function createWorkbenchView(ctx, reconciler) {
             },
         });
         workbenchView = view;
+        // Paint the WCV surface the themed window background (themeBg(): dark
+        // #1a1a1a / light #fafafa) so the boot screen ("booting workbench…") and
+        // any layout gap never flash a mismatched white strip before the workbench
+        // CSS loads. The workbench is a plain WebContentsView (not a BrowserWindow),
+        // so the process-wide installThemeBackgroundSync() never reaches it — match
+        // the main window's own backgroundColor here, and re-sync on every theme
+        // flip below.
+        try {
+            view.setBackgroundColor(themeBg());
+        }
+        catch { /* view not ready for a bg yet */ }
         // Track devtools theme flips for the lifetime of the workbench view only —
         // registered here (not at construction) so test electron mocks that omit
         // `nativeTheme` and never open the editor stay unaffected. Removed in
@@ -76,9 +95,13 @@ export function createWorkbenchView(ctx, reconciler) {
             view.webContents.setWindowOpenHandler(({ url: target }) => handleWindowOpenExternal(target));
         }
         catch { /* stub may lack it */ }
-        ctx.windows.mainWindow.contentView.addChildView(view);
         // Hand the workbench the current devtools scheme as a URL query so its very
         // first paint already matches (the runtime setter only exists post-init).
+        // The project identity deliberately does NOT ride this URL: the attach can
+        // happen before the open commits a session (the gate self-releases after
+        // ATTACH_HOLD_CAP_MS on a slow compile, and the release fires just ahead of
+        // the commit), so the page polls it from the COI server's `/__project`
+        // instead — see workbench-coi-server.ts.
         const loadUrl = `${url}index.html?theme=${workbenchThemeScheme()}`;
         await view.webContents.loadURL(loadUrl).catch((err) => {
             console.error('[workbench] attachWorkbench — loadURL failed', err);
@@ -140,17 +163,9 @@ export function createWorkbenchView(ctx, reconciler) {
             nativeTheme.removeListener('updated', pushWorkbenchTheme);
             workbenchThemeSyncBound = false;
         }
-        destroyChildView(ctx.windows.mainWindow, workbenchView);
+        reconciler.destroyView(VIEW_ID.workbench, workbenchView);
         workbenchView = null;
-        if (attachHeld) {
-            // A held detach is a project-switch teardown: the renderer published the
-            // incoming project's placement before the open started, so that desired
-            // is the ONLY thing the release replay can rebuild the view from — keep
-            // it (gateHidden hides it while held) and just forget the destroyed
-            // instance so the rebuilt view is treated as a fresh attach.
-            reconciler.forgetActual(VIEW_ID.workbench);
-        }
-        else {
+        if (!attachHeld) {
             reconciler.deleteBaseDesired(VIEW_ID.workbench);
         }
         reconciler.reconcileNow();
@@ -232,14 +247,6 @@ export function createWorkbenchView(ctx, reconciler) {
     reconciler.registerView(VIEW_ID.workbench, {
         getView: () => workbenchView,
         gateHidden: () => !workbenchView && (!workbenchUrl || attachHeld),
-        beforeAttach: () => {
-            if (!workbenchView && workbenchUrl && !attachHeld) {
-                // Lazy-load the workbench; attachWorkbench adds it to the contentView.
-                void attachWorkbench(workbenchUrl);
-                return true;
-            }
-            return false;
-        },
         ensureLazy: (desired) => {
             if (desired?.placement.visible && !workbenchView && workbenchUrl && !attachHeld)
                 void attachWorkbench(workbenchUrl);

package/dist/main/services/workbench-coi-server.d.ts

@@ -21,6 +21,17 @@ export interface WorkbenchCoiServerOptions {
      * for none (built-in `wx*` associations only).
      */
     getFileTypes?: () => unknown;
+    /**
+     * Reads the active project's identity — `appId` (null until the open commits
+     * a session) plus its root path — served at `/__project` as the workspace id
+     * the editor names its VS Code workspace after. Read per-request, because the
+     * editor page can load BEFORE the project commits (see `/__project` below).
+     * Omit when the host has no project identity to offer.
+     */
+    getProjectIdentity?: () => {
+        appId: string | null;
+        projectPath: string;
+    };
 }
 export declare function startWorkbenchCoiServer(options: WorkbenchCoiServerOptions): Promise<WorkbenchCoiServer>;
 //# sourceMappingURL=workbench-coi-server.d.ts.map

package/dist/main/services/workbench-coi-server.js

@@ -39,6 +39,7 @@ import path from 'node:path';
 import { readFileBufferWithin, writeFileWithin, statWithin, readdirWithin, mkdirWithin, deleteWithin, renameWithin, SKIP_DIRS, } from '../ipc/project-fs.js';
 import { handleFsWatchRequest } from './fs-watch-sse.js';
 import { jsonRes } from './http-json.js';
+import { miniappPartitionKey } from './views/miniapp-partition.js';
 /** Max `/__fs/write` body; enough to save large source files without OOM. */
 const MAX_FS_WRITE_BYTES = 32 * 1024 * 1024;
 const MIME = {
@@ -337,6 +338,21 @@ async function readContributedExtensions(extensionsDir) {
     }
     return out;
 }
+/**
+ * The `/__project` workspace id: the miniapp partition key of the active
+ * project, or null when there is no committed project identity yet.
+ *
+ * Reuses `miniappPartitionKey` (the same derivation the per-project Electron
+ * session partition uses) so the editor's storage bucket and the runtime's
+ * storage partition are named off the same project identity: the `appId`,
+ * disambiguated by the project path because `appId` comes from the manifest and
+ * two checkouts can declare the same one.
+ */
+function workspaceIdOf(identity) {
+    if (!identity?.appId)
+        return null;
+    return miniappPartitionKey(identity.appId, identity.projectPath || null);
+}
 export async function startWorkbenchCoiServer(options) {
     const root = path.resolve(options.rootDir);
     const contribRoot = options.extensionsDir ? path.resolve(options.extensionsDir) : null;
@@ -362,6 +378,22 @@ export async function startWorkbenchCoiServer(options) {
             jsonRes(res, 200, options.getFileTypes?.() ?? {});
             return;
         }
+        // Identity of the active project, as the id the editor names its VS Code
+        // workspace after. Every project is mirrored at the same constant
+        // `file:///workspace` root, and VS Code keys WORKSPACE-scope storage (open
+        // editors, view state, explorer expansion) off the workspace identity — so
+        // without a distinct id per project, one project's tabs are restored into
+        // the next, stranded behind "the file was not found".
+        //
+        // Served here rather than baked into the editor's load URL because the
+        // editor view can attach BEFORE the open commits its session (its attach
+        // gate self-releases on a slow compile), when there is no identity to hand
+        // it; `null` then tells the page to keep polling, the same way its disk
+        // mirror already polls `/__fs` for the project root to appear.
+        if (url.pathname === '/__project') {
+            jsonRes(res, 200, { workspaceId: workspaceIdOf(options.getProjectIdentity?.()) });
+            return;
+        }
         // Host-contributed web extensions: manifest + static files (same-origin so
         // they satisfy the workbench's COEP require-corp).
         if (url.pathname.startsWith('/__contrib/')) {

package/dist/main/services/workspace/rebuild-status.d.ts

@@ -1,15 +1,28 @@
 /**
- * Decide and emit the post-rebuild status for one watcher rebuild. Style-only
- * rebuild fast path: hot-swap the render-host stylesheets in place instead of
- * respawning the DeviceShell — page stack / form state / scroll / focus survive
- * (no jitter, no focus steal); `hotReload: false` keeps the renderer from bumping
- * its reload token (the respawn signal). Falls through to the full reload when
- * the swap can't run (no live render guest yet) so an edit is never dropped.
- * `getProjectPages` never throws; empty pages are withheld so the renderer keeps
- * its previous launch dropdown.
+ * Decide and emit the post-rebuild status for one completed rebuild.
+ *
+ * Explicit rebuild (`info.explicit` — the 重新编译 button, via
+ * `session.rebuild()`): the renderer's own relaunch drives a hard re-attach
+ * once the rebuild IPC resolves, and that re-attach is the run's ONLY
+ * reflection. Emitting `hotReload: true` here as well would race a soft
+ * reload against it — the two arrive through different channels with no
+ * ordering guarantee, so the soft reload can land AFTER the hard re-attach
+ * and drag the simulator back to the drifted page. The style fast path is a
+ * soft-update path too and is skipped for the same reason.
+ *
+ * Watcher rebuild (explicit absent/false) — style-only fast path: hot-swap the
+ * render-host stylesheets in place instead of respawning the DeviceShell —
+ * page stack / form state / scroll / focus survive (no jitter, no focus
+ * steal); `hotReload: false` keeps the renderer from bumping its reload token
+ * (the respawn signal). Falls through to the full reload when the swap can't
+ * run (no live render guest yet) so an edit is never dropped.
+ *
+ * `getProjectPages` never throws; empty pages are withheld so the renderer
+ * keeps its previous launch dropdown.
  */
 export declare function reportRebuildStatus(info: {
     styleOnly?: boolean;
+    explicit?: boolean;
 } | undefined, deps: {
     projectPath: string;
     repo: {

package/dist/main/services/workspace/rebuild-status.js

@@ -1,16 +1,32 @@
 /**
- * Decide and emit the post-rebuild status for one watcher rebuild. Style-only
- * rebuild fast path: hot-swap the render-host stylesheets in place instead of
- * respawning the DeviceShell — page stack / form state / scroll / focus survive
- * (no jitter, no focus steal); `hotReload: false` keeps the renderer from bumping
- * its reload token (the respawn signal). Falls through to the full reload when
- * the swap can't run (no live render guest yet) so an edit is never dropped.
- * `getProjectPages` never throws; empty pages are withheld so the renderer keeps
- * its previous launch dropdown.
+ * Decide and emit the post-rebuild status for one completed rebuild.
+ *
+ * Explicit rebuild (`info.explicit` — the 重新编译 button, via
+ * `session.rebuild()`): the renderer's own relaunch drives a hard re-attach
+ * once the rebuild IPC resolves, and that re-attach is the run's ONLY
+ * reflection. Emitting `hotReload: true` here as well would race a soft
+ * reload against it — the two arrive through different channels with no
+ * ordering guarantee, so the soft reload can land AFTER the hard re-attach
+ * and drag the simulator back to the drifted page. The style fast path is a
+ * soft-update path too and is skipped for the same reason.
+ *
+ * Watcher rebuild (explicit absent/false) — style-only fast path: hot-swap the
+ * render-host stylesheets in place instead of respawning the DeviceShell —
+ * page stack / form state / scroll / focus survive (no jitter, no focus
+ * steal); `hotReload: false` keeps the renderer from bumping its reload token
+ * (the respawn signal). Falls through to the full reload when the swap can't
+ * run (no live render guest yet) so an edit is never dropped.
+ *
+ * `getProjectPages` never throws; empty pages are withheld so the renderer
+ * keeps its previous launch dropdown.
  */
 export function reportRebuildStatus(info, deps) {
     const { pages } = deps.repo.getProjectPages(deps.projectPath);
     const pageList = pages.length ? pages : undefined;
+    if (info?.explicit) {
+        deps.sendStatus('ready', '编译完成', false, pageList);
+        return;
+    }
     if (info?.styleOnly && deps.autoReload && deps.refreshSimulatorStyles()) {
         deps.sendStatus('ready', '样式已热更新', false, pageList);
         return;

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.d.ts

@@ -8,7 +8,7 @@ import type { SenderPolicy } from './ipc-registry.js';
  * - the main window's renderer
  * - the optional workbench settings BrowserWindow's renderer (when open)
  * - the settings overlay view (when open)
- * - the popover overlay view (when open)
+ * - the popover and tooltip overlay views (when open)
  *
  * The simulator webview is intentionally NOT on this list. Anything it
  * needs from main (currently just the custom-apis bridge — see

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

@@ -6,7 +6,7 @@
  * - the main window's renderer
  * - the optional workbench settings BrowserWindow's renderer (when open)
  * - the settings overlay view (when open)
- * - the popover overlay view (when open)
+ * - the popover and tooltip overlay views (when open)
  *
  * The simulator webview is intentionally NOT on this list. Anything it
  * needs from main (currently just the custom-apis bridge — see
@@ -49,6 +49,21 @@ export function createWorkbenchSenderPolicy(ctx) {
         const popoverViewId = ctx.views.getPopoverWebContentsId();
         if (popoverViewId != null && sender.id === popoverViewId)
             return true;
+        // Tooltip overlay view. It loads only the bundled local renderer and needs
+        // the shared overlay-ready + intrinsic-measurement channels.
+        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