@dimina-kit/devtools 0.4.0 → 0.5.0

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

@@ -0,0 +1,184 @@
+/**
+ * Shared harness for the simulator-DevTools host suites
+ * (`view-manager-devtools-host-repoint.test.ts` +
+ * `view-manager-service-host-ready.test.ts`), split out so each test file
+ * stays under the repo's 500-line-per-file ratchet. Pure test scaffolding,
+ * not code under test — same pattern as
+ * network-forward/global-mirror-test-fixtures.ts.
+ *
+ * Consumers register the module mocks themselves (vi.mock factories are
+ * hoisted per test file, so they live there, thin):
+ *   vi.mock('electron', async () =>
+ *     (await import('./view-manager-devtools-host-test-fixtures.js')).electronModuleMock())
+ *   vi.mock('../../utils/paths.js', async () =>
+ *     (await import('./view-manager-devtools-host-test-fixtures.js')).pathsModuleMock())
+ * The electron factory closes over this module's `constructed` /
+ * `serviceWcRegistry` registries, so test assertions and the mock see the
+ * same objects (vitest gives each test FILE its own instance of this module —
+ * no cross-file bleed).
+ */
+import { vi } from 'vitest';
+import { createConnectionRegistry } from '@dimina-kit/electron-deck/main';
+/** Every WebContentsView ever constructed by the code under test, in
+ * construction order: attachNativeSimulator builds [0] = the native simulator
+ * content view, then attachNativeSimulatorDevtoolsHost builds [1] = the
+ * DevTools front-end host view. Reset in each file's beforeEach. */
+export const constructed = [];
+/** Service-host wcs registered by `makeServiceWc`, looked up by
+ * `electron.webContents.fromId` — mirrors real Electron's global wc registry
+ * so `onNativeServiceHostReady`'s `webContents.fromId(event.serviceWcId)`
+ * resolution has something real to find. */
+export const serviceWcRegistry = new Map();
+/** One stub wc surface shared by BOTH stub flavors (the constructed
+ * WebContentsView host wcs and the standalone service-host wcs) — a single
+ * factory instead of two hand-maintained near-identical literals. */
+function makeStubWc(id, overrides = {}) {
+    return {
+        destroyed: false,
+        id,
+        isDestroyed() { return this.destroyed; },
+        close: vi.fn(),
+        loadURL: vi.fn(() => Promise.resolve()),
+        loadFile: vi.fn(() => Promise.resolve()),
+        on: vi.fn(),
+        once: vi.fn(),
+        removeListener: vi.fn(),
+        setWindowOpenHandler: vi.fn(),
+        setZoomFactor: vi.fn(),
+        send: vi.fn(),
+        setMaxListeners: vi.fn(),
+        getMaxListeners: vi.fn(() => 10),
+        // DevTools front-end host wc surface (the WebContentsView flavor is used
+        // for `simulatorView.webContents`, i.e. the right-panel DevTools host).
+        isLoading: vi.fn(() => false),
+        executeJavaScript: vi.fn(() => Promise.resolve()),
+        setDevToolsWebContents: vi.fn(),
+        openDevTools: vi.fn(),
+        isDevToolsOpened: vi.fn(() => false),
+        closeDevTools: vi.fn(),
+        getURL: vi.fn(() => ''),
+        ...overrides,
+    };
+}
+/** The `electron` module surface view-manager and its injectors touch. */
+export function electronModuleMock() {
+    let nextId = 1;
+    class WebContentsView {
+        webContents;
+        setBounds = vi.fn();
+        setBackgroundColor = vi.fn();
+        constructor(_opts) {
+            this.webContents = makeStubWc(nextId++, {
+                close: vi.fn(function () { this.destroyed = true; }),
+            });
+            constructed.push(this);
+        }
+    }
+    const ipcMain = {
+        on: vi.fn(),
+        removeListener: vi.fn(),
+        handle: vi.fn(),
+        removeHandler: vi.fn(),
+    };
+    return {
+        WebContentsView,
+        ipcMain,
+        shell: { openExternal: vi.fn() },
+        nativeTheme: { shouldUseDarkColors: false, on: vi.fn(), removeListener: vi.fn() },
+        webContents: {
+            fromId: vi.fn((id) => serviceWcRegistry.get(id)),
+            getAllWebContents: vi.fn(() => []),
+        },
+        default: { ipcMain },
+    };
+}
+export function pathsModuleMock() {
+    return {
+        mainPreloadPath: '/stub/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',
+    };
+}
+export const SIM_URL = 'http://localhost:7788/simulator.html?appId=repoint';
+/** A hidden SERVICE-HOST BrowserWindow wc (top-level, can host DevTools). */
+export function makeServiceWc(id) {
+    const wc = makeStubWc(id, { isDevToolsOpened: vi.fn(() => true) });
+    serviceWcRegistry.set(id, wc);
+    return wc;
+}
+export function makeContext() {
+    const addChildView = vi.fn();
+    const removeChildView = vi.fn();
+    const contentView = { addChildView, removeChildView, children: [] };
+    const mainWindow = {
+        destroyed: false,
+        contentView,
+        isDestroyed() { return this.destroyed; },
+        getContentSize: () => [1280, 980],
+    };
+    const notify = {
+        popoverInit: vi.fn(),
+        popoverClosed: vi.fn(),
+        hostToolbarHeightChanged: vi.fn(),
+    };
+    // ── ctx.bridge stub ───────────────────────────────────────────────────────
+    // Minimal `BridgeRouterHandle`: `getServiceWc` resolves to whatever the test
+    // currently points `currentServiceWc` at (simulating a pre-warm-pool swap
+    // between render events), and `onRenderEvent` fans a manually-driven
+    // `RenderEvent` out to every subscriber (view-manager's own follow-path AND
+    // elements-forward's internal subscription both register here).
+    let currentServiceWc = null;
+    const renderEventListeners = new Set();
+    const serviceHostReadyListeners = new Set();
+    const bridge = {
+        isNativeHost: () => true,
+        resolveRenderWc: () => null,
+        getServiceWc: vi.fn(() => currentServiceWc),
+        getServiceWcForBridge: () => null,
+        getActiveRenderWc: () => null,
+        getActiveBridgeId: () => null,
+        onRenderEvent: (listener) => {
+            renderEventListeners.add(listener);
+            return () => renderEventListeners.delete(listener);
+        },
+        onServiceHostReady: (listener) => {
+            serviceHostReadyListeners.add(listener);
+            return () => serviceHostReadyListeners.delete(listener);
+        },
+        getDevice: () => null,
+        setDevice: () => { },
+        disposeSessionsForSimulator: () => Promise.resolve(),
+    };
+    function setActiveServiceWc(wc) {
+        currentServiceWc = wc;
+    }
+    function emitRenderEvent(event) {
+        for (const l of [...renderEventListeners])
+            l(event);
+    }
+    function emitServiceHostReady(event) {
+        for (const l of [...serviceHostReadyListeners])
+            l(event);
+    }
+    return {
+        addChildView,
+        removeChildView,
+        setActiveServiceWc,
+        emitRenderEvent,
+        emitServiceHostReady,
+        ctx: {
+            windows: {
+                mainWindow: mainWindow,
+            },
+            rendererDir: '/stub/renderer',
+            notify: notify,
+            connections: createConnectionRegistry(),
+            preloadPath: '/stub/sim-preload.js',
+            bridge: bridge,
+        },
+    };
+}
+//# sourceMappingURL=view-manager-devtools-host-test-fixtures.js.map

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
@@ -20,6 +24,15 @@ export interface ViewManagerContext {
      * `createWorkbenchContext` always supplies it.
      */
     connections: WorkbenchContext['connections'];
+    /**
+     * Shared CDP session broker (see cdp-session/index.ts). safe-area acquires
+     * render-guest debugger leases through it instead of attaching directly, so
+     * it shares sessions with elements-forward/render-inspect/network-forward
+     * rather than fighting them for exclusive ownership. Optional so partial
+     * test contexts compile (safe-area falls back to a private broker
+     * instance); `createWorkbenchContext` always supplies the real one.
+     */
+    cdpSessionBroker?: WorkbenchContext['cdpSessionBroker'];
     /** Active project root used to validate/open console source locations. */
     workspace?: WorkbenchContext['workspace'];
     /**
@@ -55,6 +68,11 @@ export interface ViewManagerContext {
      * Optional so partial test contexts compile.
      */
     simulatorApis?: WorkbenchContext['simulatorApis'];
+    /**
+     * Host-registered UI extensions that follow the native simulator WCV.
+     * Optional only for focused view-manager test doubles.
+     */
+    simulatorUiExtensions?: WorkbenchContext['simulatorUiExtensions'];
 }
 /**
  * Unified lifecycle manager for Electron WebContentsView overlays.
@@ -75,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' | 'showDevicePicker' | 'hideDevicePicker' | 'getProjectCreateDialogWebContentsId' | 'getUpdateDialogWebContentsId' | 'getDevicePickerWebContentsId'>, HostSidebarViewManagerMembers, HostDialogViewManagerMembers {
     /**
      * NATIVE-HOST ONLY. Create the simulator itself as a top-level
      * WebContentsView (not a renderer `<webview>` guest) loading `simulatorUrl`,
@@ -104,6 +122,13 @@ export interface ViewManager {
      * back to the hard attachNativeSimulator rebuild.
      */
     softReloadNativeSimulator(simulatorUrl: string): boolean;
+    /**
+     * Style-only fast path after a watcher rebuild: hot-swap the render-host
+     * stylesheets in place (no shell respawn), preserving the page stack / form
+     * state / focus. Returns false when no live+ready guest exists so the caller
+     * falls back to the full soft reload.
+     */
+    refreshSimulatorStyles(): boolean;
     /**
      * Destroy and null out the simulator view (e.g. on simulator detach).
      * Also destroys the cached settings view and hides the popover —
@@ -111,17 +136,23 @@ 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;
-    /** Destroy all overlay webContents and null out the cached views. */
+    /**
+     * Destroy the PROJECT-scoped views: the simulator (with its devtools host
+     * and settings/popover overlays), the embedded workbench editor, and the
+     * per-guest safe-area sessions. Deliberately does NOT touch the host
+     * toolbar — its webContents lifecycle belongs to the HOST, so it survives
+     * closing a project. This is what `workspace.closeProject()` calls.
+     */
+    disposeProjectViews(): void;
+    /**
+     * Destroy ALL managed views: everything `disposeProjectViews()` covers PLUS
+     * the host toolbar (its view, port channel, and the ref-counted
+     * session-runtime preload registration). App/window teardown only — the
+     * context's DisposableRegistry runs this so the toolbar's session-level
+     * resources are released exactly once, at the end of the manager's life.
+     */
     disposeAll(): void;
     /** Return the webContents ID of the currently attached simulator. */
     getSimulatorWebContentsId(): number | null;
@@ -135,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
@@ -171,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
@@ -181,11 +220,29 @@ export interface ViewManager {
     /**
      * Store the workbench COI base URL without loading it. The heavy
      * WebContentsView load is deferred to the first visible
-     * `setWorkbenchBounds`, keeping it off the app boot critical path.
+     * `setWorkbenchBounds` — and further deferred while `holdWorkbenchAttach`
+     * is in force — keeping it off the app boot critical path.
      */
     setWorkbenchSource(url: string): void;
     /** Destroy the workbench editor view (teardown). No-op if never attached. */
     detachWorkbench(): void;
+    /**
+     * Close the workbench attach gate: while held (and the view does not exist
+     * yet), the lazy attach is deferred so the editor's heavy load stays out of
+     * a project open's boot-critical window (teardown + first compile). Returns
+     * an idempotent release fn bound to this hold; a newer hold supersedes it
+     * (its release becomes a no-op), explicit user intent (openFileInWorkbench)
+     * opens the gate, and a 3s cap self-releases with a warn so the editor is
+     * never deferred unboundedly. The gate never hides or destroys a live view.
+     */
+    holdWorkbenchAttach(): () => void;
+    /**
+     * Void the current workbench attach hold WITHOUT the release replay. For
+     * teardown paths that preempt an in-flight open (closeProject, disposeAll):
+     * the superseded open's late release or its cap firing must not rebuild the
+     * editor view after the project is gone. No-op when nothing is held.
+     */
+    cancelWorkbenchAttachHold(): void;
     /**
      * Reveal a project file in the embedded workbench at a 1-based line/column
      * (the open-in-editor target coordinate convention). Drives the workbench's
@@ -212,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';
 /**
@@ -17,7 +19,7 @@ export function createViewManager(ctx) {
     // CSS env(safe-area-inset-*) simulation for render-host guests (per device).
     // Driven from did-attach-webview in the simulator domain and re-pushed on
     // device change via reapplySafeArea. Torn down in disposeAll.
-    const safeArea = createSafeAreaController({ connections: ctx.connections });
+    const safeArea = createSafeAreaController({ connections: ctx.connections, broker: ctx.cdpSessionBroker });
     // The single level-triggered placement reconciler every view domain shares —
     // the sole owner of placement state (docs/view-placement-reconciler.md). Each
     // domain registers exactly one view slot with it.
@@ -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,
     });
@@ -45,27 +52,64 @@ export function createViewManager(ctx) {
     function reapplyToolbarDependentOverlays() {
         overlayPanels.reapplyPresentOverlays();
     }
-    function disposeAll() {
+    function disposeProjectViews() {
         // Aggregate simulator detach first (native simulator + devtools host +
-        // settings/popover), then the workbench, the host toolbar, and the
-        // per-guest safe-area sessions.
+        // settings/popover), then the workbench, then the per-guest safe-area
+        // sessions. The host toolbar is exempt: it is HOST-scoped (the host loads
+        // and drives it; the height-replay machinery exists precisely for the
+        // close-project → reopen flow), so a project's teardown must not kill it.
         nativeSimulator.detachSimulator();
         // Embedded workbench editor view (no-op when the host never opted in;
         // also removes the devtools-theme sync listener).
         workbench.detachWorkbench();
-        hostToolbar.dispose();
         safeArea.dispose();
     }
+    function disposeAll() {
+        // App-level teardown invalidates any in-flight open's attach hold first,
+        // so the held-detach preserve path below can't keep a desired around for
+        // a release/cap replay to rebuild.
+        workbench.cancelWorkbenchAttachHold();
+        disposeProjectViews();
+        // 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,
         softReloadNativeSimulator: nativeSimulator.softReloadNativeSimulator,
+        refreshSimulatorStyles: nativeSimulator.refreshSimulatorStyles,
         detachSimulator: nativeSimulator.detachSimulator,
         reapplySafeArea: (device) => safeArea.reapplyAll(device),
         showSettings: overlayPanels.showSettings,
         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,
+        showDevicePicker: overlayPanels.showDevicePicker,
+        hideDevicePicker: overlayPanels.hideDevicePicker,
+        getProjectCreateDialogWebContentsId: overlayPanels.getProjectCreateDialogWebContentsId,
+        getUpdateDialogWebContentsId: overlayPanels.getUpdateDialogWebContentsId,
+        getDevicePickerWebContentsId: overlayPanels.getDevicePickerWebContentsId,
+        repositionAll: () => {
+            overlayPanels.reapplyPresentOverlays();
+            hostDialog.reposition();
+        },
+        disposeProjectViews,
         disposeAll,
         getSimulatorWebContentsId: nativeSimulator.getSimulatorWebContentsId,
         getSimulatorWebContents: nativeSimulator.getSimulatorWebContents,
@@ -73,16 +117,27 @@ 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,
         openFileInWorkbench: workbench.openFileInWorkbench,
+        holdWorkbenchAttach: workbench.holdWorkbenchAttach,
+        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.d.ts

@@ -10,6 +10,8 @@ export interface WorkbenchView {
     setWorkbenchSource(url: string): void;
     detachWorkbench(): void;
     openFileInWorkbench(relPath: string, line: number, column: number): boolean;
+    holdWorkbenchAttach(): () => void;
+    cancelWorkbenchAttachHold(): void;
 }
 export declare function createWorkbenchView(ctx: ViewManagerContext, reconciler: PlacementReconciler): WorkbenchView;
 //# sourceMappingURL=workbench-view.d.ts.map