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

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

@@ -1,150 +1,179 @@
 import { WebContentsView } from 'electron';
-import path from 'path';
+import { createOverlayPanel } from '@dimina-kit/electron-deck/main';
 import { mainPreloadPath } from '../../utils/paths.js';
 import { applyNavigationHardening } from '../../windows/navigation-hardening.js';
 import * as layout from '../layout/index.js';
 import { HEADER_H } from '../../../shared/constants.js';
 import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
-import { destroyChildView } from './destroy-child-view.js';
 export function createOverlayPanelsView(ctx, reconciler, deps) {
-    let settingsView = null;
-    let popoverView = null;
     function overlayHeaderHeight() {
         return HEADER_H + deps.getHostToolbarHeight();
     }
-    // settings/popover bounds are main-computed; publish them into overlayDesired
-    // and let the reconciler place them (they are top-tier layers, so a reorder
-    // keeps them above every base overlay — the old raiseTopOverlays is gone).
-    function applySettingsBounds() {
-        if (!settingsView || ctx.windows.mainWindow.isDestroyed())
-            return;
-        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        reconciler.setOverlayDesired(VIEW_ID.settings, {
-            viewId: VIEW_ID.settings,
-            placement: {
-                visible: true,
-                bounds: layout.computeSettingsBounds(w, h, overlayHeaderHeight()),
-            },
-            layer: VIEW_LAYER.settings,
-        });
-        reconciler.reconcileNow();
-    }
-    function applyPopoverBounds() {
-        if (!popoverView || ctx.windows.mainWindow.isDestroyed())
-            return;
-        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        reconciler.setOverlayDesired(VIEW_ID.popover, {
-            viewId: VIEW_ID.popover,
-            placement: {
-                visible: true,
-                bounds: layout.computePopoverBounds(w, h, overlayHeaderHeight()),
-            },
-            layer: VIEW_LAYER.popover,
-        });
-        reconciler.reconcileNow();
+    function overlayDesiredSetter(viewId, layer) {
+        return (bounds) => {
+            if (bounds === null) {
+                reconciler.deleteOverlayDesired(viewId);
+            }
+            else {
+                reconciler.setOverlayDesired(viewId, {
+                    viewId,
+                    placement: { visible: true, bounds },
+                    layer,
+                });
+            }
+            reconciler.reconcileNow();
+        };
     }
-    async function showSettings() {
-        if (!settingsView) {
-            settingsView = new WebContentsView({
-                webPreferences: {
-                    nodeIntegration: false,
-                    contextIsolation: true,
-                    sandbox: false,
-                    preload: mainPreloadPath,
-                },
+    const settingsPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/settings/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.settings, VIEW_LAYER.settings),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.settings, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.settings, view),
+        readyMode: 'manual',
+    });
+    const popoverPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/popover/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.popover, VIEW_LAYER.popover),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.popover, { getView }),
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.popover, view),
+        pushData: (view, data) => ctx.notify.popoverInit(view, data),
+        readyMode: 'manual',
+    });
+    const tooltipPanel = createOverlayPanel({
+        electron: { createWebContentsView: (opts) => new WebContentsView(opts) },
+        rendererDir: ctx.rendererDir,
+        entry: 'entries/tooltip/index.html',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: false,
+            preload: mainPreloadPath,
+        },
+        hardenNavigation: (wc) => applyNavigationHardening(wc, ctx.rendererDir),
+        setDesired: overlayDesiredSetter(VIEW_ID.tooltip, VIEW_LAYER.tooltip),
+        registerView: (getView) => reconciler.registerView(VIEW_ID.tooltip, { getView }),
+        prepareView: (view) => {
+            const [width = 0, height = 0] = ctx.windows.mainWindow.getContentSize();
+            reconciler.prepareView(VIEW_ID.tooltip, view, {
+                x: 0,
+                y: 0,
+                width: Math.max(1, width),
+                height: Math.max(1, height),
             });
-            // Overlay loads mainPreloadPath, so the same navigation rules as the
-            // main window apply — see navigation-hardening.ts.
-            applyNavigationHardening(settingsView.webContents, ctx.rendererDir);
-            // Transparent backing: the settings view now spans the whole content area
-            // (computeSettingsBounds) and its renderer paints a transparent backdrop +
-            // an opaque right-side panel, so the underlying editor/simulator show
-            // through and a backdrop click closes the overlay (mirrors the popover).
-            settingsView.setBackgroundColor('#00000000');
-            await settingsView.webContents.loadFile(path.join(ctx.rendererDir, 'entries/settings/index.html'));
-        }
-        applySettingsBounds();
+        },
+        destroyView: (view) => reconciler.destroyView(VIEW_ID.tooltip, view),
+        pushData: (view, data) => ctx.notify.tooltipInit(view, data),
+        readyMode: 'manual',
+    });
+    let tooltipRequestId = 0;
+    let activeTooltip = null;
+    async function showSettings() {
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        settingsPanel.show(undefined, layout.computeSettingsBounds(w, h, overlayHeaderHeight()));
+        await settingsPanel.whenReady();
     }
     function hideSettings() {
-        reconciler.deleteOverlayDesired(VIEW_ID.settings);
-        reconciler.reconcileNow();
+        settingsPanel.hide();
     }
     function showPopover(data) {
+        // Popover carries no state across opens (always fresh init data) — force a
+        // brand-new instance rather than reusing/repositioning a live one (and
+        // notify like any other close, via the shared hidePopover()).
         hidePopover();
-        const popover = new WebContentsView({
-            webPreferences: {
-                nodeIntegration: false,
-                contextIsolation: true,
-                sandbox: false,
-                preload: mainPreloadPath,
-            },
-        });
-        // Popover overlay loads mainPreloadPath — same navigation rules apply.
-        applyNavigationHardening(popover.webContents, ctx.rendererDir);
-        popoverView = popover;
-        popover.setBackgroundColor('#00000000');
-        applyPopoverBounds();
-        popover.webContents.once('did-finish-load', () => {
-            ctx.notify.popoverInit(popover, data);
-        });
-        popover.webContents.loadFile(path.join(ctx.rendererDir, 'entries/popover/index.html'));
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        popoverPanel.show(data, layout.computePopoverBounds(w, h, overlayHeaderHeight()));
     }
     function hidePopover() {
-        if (!popoverView)
+        if (!popoverPanel.isPresent())
             return;
+        popoverPanel.destroy();
         reconciler.deleteOverlayDesired(VIEW_ID.popover);
-        // Destroy the WCV first (removeChildView + close), THEN reconcile: the detach
-        // op then finds the view already gone and does not double-removeChildView.
-        destroyChildView(ctx.windows.mainWindow, popoverView);
-        popoverView = null;
         reconciler.reconcileNow();
         ctx.notify.popoverClosed();
     }
+    function prepareTooltip() {
+        tooltipPanel.prepare();
+    }
+    function showTooltip(data) {
+        const requestId = ++tooltipRequestId;
+        activeTooltip = { requestId, anchor: data.anchor };
+        const [contentWidth = 0] = ctx.windows.mainWindow.getContentSize();
+        tooltipPanel.show({
+            requestId,
+            text: data.text,
+            maxWidth: layout.computeTooltipMaxWidth(contentWidth),
+        }, null);
+    }
+    function hideTooltip() {
+        activeTooltip = null;
+        tooltipPanel.hide();
+    }
+    function markOverlayReady(webContentsId) {
+        settingsPanel.markReady(webContentsId);
+        popoverPanel.markReady(webContentsId);
+        tooltipPanel.markReady(webContentsId);
+    }
+    function applyTooltipMeasurement(webContentsId, measurement) {
+        const active = activeTooltip;
+        if (!active || active.requestId !== measurement.requestId)
+            return;
+        if (tooltipPanel.getWebContentsId() !== webContentsId)
+            return;
+        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+        tooltipPanel.reposition(layout.computeTooltipBounds(active.anchor, w, h, measurement));
+    }
     function reapplyPresentOverlays() {
-        if (reconciler.hasOverlayDesired(VIEW_ID.settings))
-            applySettingsBounds();
-        if (reconciler.hasOverlayDesired(VIEW_ID.popover))
-            applyPopoverBounds();
+        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings))
+            void showSettings();
+        if (popoverPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.popover)) {
+            const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
+            popoverPanel.reposition(layout.computePopoverBounds(w, h, overlayHeaderHeight()));
+        }
     }
     function applySettingsBoundsIfPresent() {
-        if (reconciler.hasOverlayDesired(VIEW_ID.settings))
-            applySettingsBounds();
+        if (settingsPanel.isPresent() && reconciler.hasOverlayDesired(VIEW_ID.settings))
+            void showSettings();
     }
     function destroySettings() {
-        destroyChildView(ctx.windows.mainWindow, settingsView);
-        settingsView = null;
+        activeTooltip = null;
+        settingsPanel.destroy();
+        tooltipPanel.destroy();
     }
-    reconciler.registerView(VIEW_ID.settings, { getView: () => settingsView });
-    reconciler.registerView(VIEW_ID.popover, { getView: () => popoverView });
     return {
         showSettings,
         hideSettings,
         showPopover,
         hidePopover,
+        prepareTooltip,
+        showTooltip,
+        hideTooltip,
+        markOverlayReady,
+        applyTooltipMeasurement,
         reapplyPresentOverlays,
         applySettingsBoundsIfPresent,
         destroySettings,
-        getSettingsWebContents: () => {
-            if (!settingsView)
-                return null;
-            if (settingsView.webContents.isDestroyed())
-                return null;
-            return settingsView.webContents;
-        },
-        getSettingsWebContentsId: () => {
-            if (!settingsView)
-                return null;
-            if (settingsView.webContents.isDestroyed())
-                return null;
-            return settingsView.webContents.id;
-        },
-        getPopoverWebContentsId: () => {
-            if (!popoverView)
-                return null;
-            if (popoverView.webContents.isDestroyed())
-                return null;
-            return popoverView.webContents.id;
-        },
+        getSettingsWebContents: () => settingsPanel.getWebContents(),
+        getSettingsWebContentsId: () => settingsPanel.getWebContentsId(),
+        getPopoverWebContentsId: () => popoverPanel.getWebContentsId(),
+        getTooltipWebContentsId: () => tooltipPanel.getWebContentsId(),
     };
 }
 //# sourceMappingURL=overlay-panels-view.js.map

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

@@ -12,8 +12,6 @@ import type { ViewManagerContext } from './view-manager.js';
 export interface ViewSlot {
     /** The live WebContentsView for this slot, or null when not yet created. */
     getView(): WebContentsView | null;
-    /** Record whether the view is currently added to the contentView. */
-    setAdded?(added: boolean): void;
     /**
      * When true, force the desired placement to hidden — the view-creation site
      * has not produced the WCV yet, so the reconciler must never record an attach
@@ -21,12 +19,6 @@ export interface ViewSlot {
      * to re-open the gate.
      */
     gateHidden?(): boolean;
-    /**
-     * Run before the generic attach. Return true when the slot fully handled the
-     * attach itself (e.g. a lazy async load that adds the view on completion), so
-     * the reconciler must NOT addChildView here.
-     */
-    beforeAttach?(): boolean;
     /** Lazily create the view on attach (host-toolbar); used instead of getView. */
     ensureView?(): WebContentsView | null;
     /** Domain-specific setBounds (simulator zoom rides here). */
@@ -55,14 +47,10 @@ export interface PlacementReconciler {
      * truth for every managed native view's bounds/visibility/z-order.
      */
     setPlacementSnapshot(snapshot: PlacementSnapshot<DevtoolsExtra>): void;
-    /**
-     * Forget a view's reconciled mount state so the NEXT rebuilt view is treated
-     * as a fresh attach. Required wherever a view instance is replaced/destroyed
-     * via a manual removeChildView that bypasses the reconciler (otherwise the
-     * level-triggered core still records the old instance as attached and never
-     * emits the attach op for the replacement — a sticky invisible view).
-     */
-    forgetActual(viewId: string): void;
+    /** Size a detached view for renderer-side intrinsic measurement. */
+    prepareView(viewId: string, view: WebContentsView, bounds: layout.Bounds): void;
+    /** Detach and close one concrete view instance through the native-tree owner. */
+    destroyView(viewId: string, view: WebContentsView | null): void;
     setBaseDesired(viewId: string, desired: DesiredView<DevtoolsExtra>): void;
     deleteBaseDesired(viewId: string): void;
     setOverlayDesired(viewId: string, desired: DesiredView<DevtoolsExtra>): void;

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

@@ -1,12 +1,17 @@
 import { reconcile, createInitialState } from '@dimina-kit/electron-deck/layout';
 import { applyViewOps } from './apply-view-ops.js';
+import { createNativeViewTreeHost } from './native-view-tree.js';
 export function createPlacementReconciler(ctx) {
     let placementState = createInitialState();
     let epochCounter = 0;
     let rendererGeneration = 0;
+    const appliedActual = new Map();
     const baseDesired = new Map();
     const overlayDesired = new Map();
     const slots = new Map();
+    // Sole owner of the main window's native child tree. Every attach, detach,
+    // reorder and hard destroy passes through this ledger-backed adapter.
+    const contentViewHost = createNativeViewTreeHost(ctx, slots);
     function gateReadiness(v) {
         const slot = slots.get(v.viewId);
         if (slot?.gateHidden?.())
@@ -20,59 +25,67 @@ export function createPlacementReconciler(ctx) {
             const slot = slots.get(viewId);
             if (!slot)
                 return;
-            if (slot.beforeAttach?.())
-                return;
             const view = slot.ensureView ? slot.ensureView() : slot.getView();
             if (!view)
                 return;
-            ctx.windows.mainWindow.contentView.addChildView(view);
-            slot.setAdded?.(true);
+            if (!contentViewHost.addChildView({ id: viewId }))
+                return;
+            const previous = appliedActual.get(viewId);
+            appliedActual.set(viewId, {
+                attached: true,
+                visible: true,
+                bounds: previous?.bounds,
+                extra: previous?.extra,
+            });
         },
         detach(viewId) {
-            const slot = slots.get(viewId);
-            const view = slot?.getView() ?? null;
-            if (view && !ctx.windows.mainWindow.isDestroyed()) {
-                try {
-                    ctx.windows.mainWindow.contentView.removeChildView(view);
-                }
-                catch { /* already removed */ }
-            }
-            slot?.setAdded?.(false);
+            if (!contentViewHost.removeChildView({ id: viewId }))
+                return;
+            appliedActual.delete(viewId);
         },
         setBounds(viewId, bounds, extra) {
             const slot = slots.get(viewId);
             const view = slot?.getView() ?? null;
             if (!view || view.webContents.isDestroyed())
                 return;
-            if (slot?.applyBounds) {
-                slot.applyBounds(view, bounds, extra);
+            try {
+                if (slot?.applyBounds)
+                    slot.applyBounds(view, bounds, extra);
+                else
+                    view.setBounds(bounds);
+            }
+            catch {
                 return;
             }
-            view.setBounds(bounds);
+            const previous = appliedActual.get(viewId);
+            appliedActual.set(viewId, {
+                attached: previous?.attached ?? false,
+                visible: previous?.visible ?? false,
+                bounds,
+                extra,
+            });
         },
         setVisible(viewId, visible) {
             const view = slots.get(viewId)?.getView() ?? null;
-            if (!view)
+            if (!view || view.webContents.isDestroyed())
                 return;
             try {
                 view.setVisible(visible);
             }
-            catch { /* stub may lack setVisible */ }
+            catch {
+                return;
+            }
+            const previous = appliedActual.get(viewId);
+            if (!previous)
+                return;
+            appliedActual.set(viewId, { ...previous, visible });
         },
         reorder(order) {
             // A single attached view is already in place — nothing to reorder.
             if (order.length <= 1 || ctx.windows.mainWindow.isDestroyed())
                 return;
-            const cv = ctx.windows.mainWindow.contentView;
-            for (const viewId of order) {
-                const view = slots.get(viewId)?.getView() ?? null;
-                if (view) {
-                    try {
-                        cv.addChildView(view);
-                    }
-                    catch { /* already attached */ }
-                }
-            }
+            for (const viewId of order)
+                contentViewHost.addChildView({ id: viewId });
         },
     };
     // Create the lazily-built views (host-toolbar, workbench) BEFORE reconcile so
@@ -83,6 +96,9 @@ export function createPlacementReconciler(ctx) {
             slot.ensureLazy?.(baseDesired.get(viewId));
         }
     }
+    function cloneAppliedActual() {
+        return new Map([...appliedActual].map(([viewId, actual]) => [viewId, { ...actual }]));
+    }
     function reconcileNow() {
         ensureLazyViews();
         const views = [];
@@ -90,6 +106,7 @@ export function createPlacementReconciler(ctx) {
             views.push(gateReadiness(v));
         for (const v of overlayDesired.values())
             views.push(v);
+        placementState = { ...placementState, actual: cloneAppliedActual() };
         const result = reconcile(placementState, {
             generation: rendererGeneration,
             epoch: ++epochCounter,
@@ -97,6 +114,9 @@ export function createPlacementReconciler(ctx) {
         });
         placementState = result.state;
         applyViewOps(result.ops, viewTarget);
+        // The planner's next state is optimistic. Keep only desired/epoch metadata;
+        // appliedActual is updated by successful native effects above.
+        placementState = { ...placementState, actual: cloneAppliedActual() };
     }
     function setPlacementSnapshot(snapshot) {
         rendererGeneration = snapshot.generation;
@@ -109,7 +129,22 @@ export function createPlacementReconciler(ctx) {
         registerView: (viewId, slot) => { slots.set(viewId, slot); },
         reconcileNow,
         setPlacementSnapshot,
-        forgetActual: (viewId) => { placementState.actual.delete(viewId); },
+        prepareView: (viewId, view, bounds) => {
+            if (slots.get(viewId)?.getView() !== view || view.webContents.isDestroyed())
+                return;
+            try {
+                view.setBounds(bounds);
+            }
+            catch {
+                return;
+            }
+            appliedActual.set(viewId, { attached: false, visible: false, bounds });
+        },
+        destroyView: (viewId, view) => {
+            contentViewHost.destroyView(viewId, view);
+            appliedActual.delete(viewId);
+            placementState.actual.delete(viewId);
+        },
         setBaseDesired: (viewId, desired) => { baseDesired.set(viewId, desired); },
         deleteBaseDesired: (viewId) => { baseDesired.delete(viewId); },
         setOverlayDesired: (viewId, desired) => { overlayDesired.set(viewId, desired); },

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

@@ -13,9 +13,35 @@ 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 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 };
 }
@@ -33,6 +34,31 @@ export function simulatorDevtoolsBounds(mgr, rect) {
 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.d.ts

@@ -4,6 +4,8 @@ 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 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 +91,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'> {
     /**
      * NATIVE-HOST ONLY. Create the simulator itself as a top-level
      * WebContentsView (not a renderer `<webview>` guest) loading `simulatorUrl`,
@@ -132,14 +134,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 +164,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

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

@@ -3,7 +3,7 @@ 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 { createOverlayPanelsView, } from './overlay-panels-view.js';
 import { createNativeSimulatorView } from './native-simulator-view.js';
 export { resolveProjectEditorTarget, } from './resolve-project-editor-target.js';
 /**
@@ -77,6 +77,11 @@ export function createViewManager(ctx) {
         hideSettings: overlayPanels.hideSettings,
         showPopover: overlayPanels.showPopover,
         hidePopover: overlayPanels.hidePopover,
+        prepareTooltip: overlayPanels.prepareTooltip,
+        showTooltip: overlayPanels.showTooltip,
+        hideTooltip: overlayPanels.hideTooltip,
+        markOverlayReady: overlayPanels.markOverlayReady,
+        applyTooltipMeasurement: overlayPanels.applyTooltipMeasurement,
         repositionAll: () => overlayPanels.reapplyPresentOverlays(),
         disposeProjectViews,
         disposeAll,
@@ -86,6 +91,7 @@ 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(),