@dimina-kit/devtools 0.4.0-dev.20260701155140 → 0.4.0-dev.20260702164903

package/dist/main/services/views/native-simulator-view.js

@@ -0,0 +1,428 @@
+import { ipcMain, nativeTheme, shell, WebContentsView, webContents } from 'electron';
+import { cjsSiblingPreloadPath } from '../../utils/paths.js';
+import { simDeskBg } from '../../utils/theme.js';
+import { handleWindowOpenExternal } from '../../windows/navigation-hardening.js';
+import { SimulatorCustomApiBridgeChannel } from '../../../shared/ipc-channels.js';
+import * as layout from '../layout/index.js';
+import { handleCustomApiBridgeRequest, } from '../simulator/custom-apis.js';
+import { configureMiniappSession, miniappPartition } from './miniapp-partition.js';
+import { parseRoute } from '../../../shared/simulator-route.js';
+import { SIMULATOR_EVENTS } from '../../../shared/bridge-channels.js';
+import { VIEW_ID } from '../../../shared/view-ids.js';
+export function createNativeSimulatorView(ctx, reconciler, deps) {
+    const { safeArea, devtoolsHost, overlayPanels } = deps;
+    let nativeSimulatorView = null;
+    let nativeSimulatorViewAdded = false;
+    let nativeSimulatorProjectPath = null;
+    let settleNativeSimulatorReady = null;
+    // Whether the CURRENT simulator view's shell finished its first boot (first
+    // render guest did-finish-load) — the precondition for a soft reload: only a
+    // fully-booted shell has the RELAUNCH listener installed, so sending earlier
+    // would silently drop the event and strand the renderer (it was told
+    // "accepted" but nothing reloads). Reset on teardown/re-attach — readiness
+    // never carries over to a rebuilt view.
+    let nativeSimulatorShellReady = false;
+    // The `ipcMain.on` listener that services the `__diminaCustomApis` bridge for
+    // the current native simulator webContents (see `attachNativeCustomApiBridge`).
+    // Tracked so we can remove it before tearing down / re-attaching the view
+    // (otherwise listeners leak across relaunch cycles).
+    let nativeCustomApiBridgeHandler = null;
+    // The current device zoom as a factor (zoomPercent/100), last reported by the
+    // renderer via setNativeSimulatorViewBounds. Stored so nested render-host
+    // `<webview>` guests attached AFTER a zoom change still pick up the correct
+    // scale in `did-attach-webview`. Defaults to 1 (100%).
+    let currentZoomFactor = 1;
+    let simulatorWebContentsId = null;
+    // simulator zoom rides in `extra`: setBounds also drives the WCV zoomFactor and
+    // propagates it to nested render-host guests.
+    function applyNativeSimulatorBounds(view, bounds, zoom) {
+        const p = layout.computeNativeSimulatorViewParams(bounds, zoom);
+        currentZoomFactor = p.zoomFactor;
+        view.setBounds(p.bounds);
+        const simWc = view.webContents;
+        if (!simWc.isDestroyed())
+            simWc.setZoomFactor(p.zoomFactor);
+        try {
+            for (const wc of webContents.getAllWebContents()) {
+                if (wc.isDestroyed())
+                    continue;
+                if (wc.hostWebContents === simWc)
+                    wc.setZoomFactor(p.zoomFactor);
+            }
+        }
+        catch { /* hostWebContents unavailable; guests get zoom on attach */ }
+    }
+    /**
+     * The single teardown path for the live native-host simulator WCV, shared by
+     * relaunch (attachNativeSimulator replacing the view) and project close
+     * (detachSimulator). Detaches the view from the window, then synchronously
+     * clears its bridge sessions (render guests + service host + mappings) BEFORE
+     * the WCV's own async close(), so the next project never re-resolves,
+     * re-renders, or screenshots the outgoing guest. The sync prefix clears the
+     * maps immediately; the async tail (pool / resource-server release) is observed
+     * so a rejection is logged rather than swallowed. The simulatorWc 'destroyed'
+     * hook in bridge-router stays as an idempotent fallback. No-op when no view is
+     * live; idempotent (disposeSessionsForSimulator early-returns once a session is
+     * gone), so the eager teardown here and the 'destroyed' fallback never
+     * double-dispose. `label` only tags the diagnostic on the async-tail failure.
+     */
+    function tearDownNativeSimulatorView(label) {
+        if (!nativeSimulatorView)
+            return;
+        if (nativeSimulatorViewAdded && !ctx.windows.mainWindow.isDestroyed()) {
+            try {
+                ctx.windows.mainWindow.contentView.removeChildView(nativeSimulatorView);
+            }
+            catch { /* already removed */ }
+        }
+        try {
+            if (!nativeSimulatorView.webContents.isDestroyed()) {
+                ctx.bridge?.disposeSessionsForSimulator?.(nativeSimulatorView.webContents.id)
+                    ?.catch((err) => console.warn(`[view-manager] dispose sessions (${label}) failed:`, err));
+                nativeSimulatorView.webContents.close();
+            }
+        }
+        catch { /* ignore */ }
+        nativeSimulatorView = null;
+        nativeSimulatorViewAdded = false;
+        nativeSimulatorShellReady = false;
+        // The instance is being replaced/destroyed — forget its reconciled mount
+        // state so the NEXT rebuilt view is treated as a fresh attach. Without this,
+        // the level-triggered reconciler still records `simulator` as `attached`
+        // (the manual removeChildView above bypasses it), so the next reconcile
+        // classifies the freshly-built WebContentsView as already-attached, never
+        // emits the `attach` op, and the new view is never addChildView'd — a sticky
+        // 100%-invisible simulator after every recompile. Mirrors the hostToolbar
+        // instance-replacement handling in ensureHostToolbarView.
+        reconciler.forgetActual(VIEW_ID.simulator);
+        // The view is gone: gateReadiness now hides it, so reconcile detaches it.
+        reconciler.reconcileNow();
+    }
+    /**
+     * Remove the custom-apis bridge `ipcMain.on` listener, if any. Idempotent.
+     */
+    function detachNativeCustomApiBridge() {
+        if (nativeCustomApiBridgeHandler) {
+            ipcMain.removeListener(SimulatorCustomApiBridgeChannel.Request, nativeCustomApiBridgeHandler);
+            nativeCustomApiBridgeHandler = null;
+        }
+    }
+    /**
+     * NATIVE-HOST ONLY. The native simulator is a top-level WebContentsView with
+     * NO embedder renderer, so the simulator-side `__diminaCustomApis` bridge
+     * (`src/preload/runtime/custom-apis.ts`) cannot reach the host via
+     * `ipcRenderer.sendToHost` — that only delivers to a `<webview>`'s embedder,
+     * which is how the default path's `useCustomApiProxy` answered it. A
+     * top-level WebContentsView has no embedder, and `sendToHost` does NOT loop
+     * back as `ipc-message-host` on itself, so that channel never fires here.
+     *
+     * Under native-host the bridge instead talks to `ipcMain` directly (the same
+     * way `installNativeHostBridge` issues SPAWN/PAGE_OPEN): the preload sends
+     * `SimulatorCustomApiBridgeChannel.Request` via `ipcRenderer.send`, this
+     * `ipcMain.on` listener answers it. We do NOT route through `IpcRegistry` /
+     * the sender-policy white-list (the simulator is deliberately kept off it);
+     * instead we accept the message ONLY when `event.sender` is THIS precise
+     * simWc — the same trust model bridge-router uses for the simulator's own
+     * SPAWN messages. The result is dispatched through the shared
+     * `ctx.simulatorApis` registry and the id-correlated `Response` is posted
+     * back via `simWc.send`, which the preload's `ipcRenderer.on(Response)`
+     * listener settles.
+     */
+    function attachNativeCustomApiBridge(simWc) {
+        // Re-attach defensively: a stale listener from a prior simWc must never
+        // linger. (attachNativeSimulator already tears the old view down first.)
+        detachNativeCustomApiBridge();
+        const apis = ctx.simulatorApis;
+        if (!apis)
+            return;
+        const simWcId = simWc.id;
+        const handler = (event, req) => {
+            // Trust gate: only the exact native simulator webContents may drive this.
+            if (event.sender.id !== simWcId)
+                return;
+            const r = req;
+            if (!r || typeof r.id !== 'number')
+                return;
+            void handleCustomApiBridgeRequest(apis, r).then((response) => {
+                if (simWc.isDestroyed())
+                    return;
+                simWc.send(SimulatorCustomApiBridgeChannel.Response, response);
+            }).catch(() => { });
+        };
+        nativeCustomApiBridgeHandler = handler;
+        ipcMain.on(SimulatorCustomApiBridgeChannel.Request, handler);
+        // Consolidate this per-webContents teardown onto the connection layer:
+        // acquiring the simWc connection makes the
+        // registry track this trusted webContents, and `own()`-ing the detach ties
+        // the ipcMain listener's lifetime to the connection so it's torn down
+        // deterministically when the wc is destroyed (or the connection is reset),
+        // instead of a bespoke `once('destroyed')`. The detach stays idempotent, so
+        // the defensive re-attach path calling it directly remains safe.
+        ctx.connections.acquire(simWc).own(detachNativeCustomApiBridge);
+    }
+    function attachNativeSimulator(simulatorUrl, _simWidth) {
+        if (!ctx.preloadPath) {
+            console.error('[workbench] attachNativeSimulator — preloadPath unset; cannot mount native simulator');
+            return Promise.resolve();
+        }
+        // Unblock a superseded IPC invocation. Its renderer effect cleanup marks
+        // that generation cancelled, so this cannot schedule a stale capture.
+        settleNativeSimulatorReady?.();
+        settleNativeSimulatorReady = null;
+        // Tear down any previous native simulator view (relaunch / re-open) through
+        // the shared single teardown path. detachNativeCustomApiBridge stays here
+        // (the bridge dispatcher is re-installed per attach below).
+        if (nativeSimulatorView) {
+            detachNativeCustomApiBridge();
+            tearDownNativeSimulatorView('relaunch');
+        }
+        nativeSimulatorProjectPath = null;
+        const ready = new Promise((resolve) => {
+            settleNativeSimulatorReady = resolve;
+        });
+        // Derive THIS project's session partition from the simulator URL's appId so
+        // its cookies/localStorage/cache are isolated from every other project.
+        // Same project → same partition (storage survives a relaunch);
+        // unknown appId → the shared fallback. Configure the partition's session
+        // (protocol handlers + CORS/referer policy) before any project content loads
+        // on it — idempotent per partition.
+        const route = parseRoute(simulatorUrl);
+        // Include the project path so two projects that declare the same appId at
+        // different paths get isolated partitions. The service-host window for THIS
+        // project derives its partition from the same (appId, projectPath) pair so
+        // render guests + service host still share one session.
+        const partition = miniappPartition(route?.appId, ctx.workspace?.getProjectPath());
+        configureMiniappSession(partition);
+        // The simulator preload is a CJS bundle; webPreferences.preload obeys the
+        // `.js` + "type":"module" ESM rule (require would be undefined), so hand the
+        // top-level WebContentsView the `.cjs` sibling. contextIsolation:false +
+        // sandbox:false + webviewTag:true mirror what the default `<webview>` guest
+        // runs with, and the per-project `persist:miniapp-<key>` partition shares
+        // storage + the session-registered preload/CORS rules with the rest of THIS
+        // project's simulator (render guests + service host), never other projects'.
+        const view = new WebContentsView({
+            webPreferences: {
+                nodeIntegration: false,
+                contextIsolation: false,
+                sandbox: false,
+                webviewTag: true,
+                preload: cjsSiblingPreloadPath(ctx.preloadPath),
+                partition,
+            },
+        });
+        nativeSimulatorView = view;
+        nativeSimulatorProjectPath = ctx.workspace?.getProjectPath() || null;
+        // Paint the WCV surface the themed desk color (simDeskBg(): dark #121212 /
+        // light #e8e8e8) so a height-resize that grows the region never flashes a
+        // mismatched strip before DeviceShell's desk repaints — the WCV, the desk,
+        // and the renderer placeholder behind it are all the same color.
+        view.setBackgroundColor(simDeskBg());
+        const simWc = view.webContents;
+        // Keep the WCV surface in sync with the active color scheme. The
+        // process-wide installThemeBackgroundSync() re-syncs BrowserWindows on a
+        // theme switch, but this top-level WebContentsView is not a window, so its
+        // creation-time backgroundColor would otherwise freeze. Mirror simDeskBg()
+        // here on every nativeTheme `updated`; the listener is owned by the wc's
+        // connection so it detaches when the simulator view is torn down.
+        const syncDeskBg = () => {
+            try {
+                if (!simWc.isDestroyed())
+                    view.setBackgroundColor(simDeskBg());
+            }
+            catch { /* view/wc gone */ }
+        };
+        nativeTheme.on('updated', syncDeskBg);
+        ctx.connections.acquire(simWc).own(() => nativeTheme.removeListener('updated', syncDeskBg));
+        // Service the simulator-side `__diminaCustomApis` bridge: this top-level
+        // WebContentsView has no embedder renderer to proxy through, so dispatch its
+        // `sendToHost` requests straight to `ctx.simulatorApis` from main.
+        attachNativeCustomApiBridge(simWc);
+        // DeviceShell mounts per-page render-host `<webview>`s INSIDE this view.
+        // Pin them onto the SAME per-project partition as their host WCV (so render
+        // and the rest of this project share one localStorage/cookie jar) and run
+        // them with contextIsolation/sandbox off so the render runtime + its preload
+        // share the page realm. (A top-level WebContentsView can host these guests; a
+        // `<webview>` guest cannot — that's the whole point of Option A.)
+        // Page type (`isTab`) of each attaching guest, captured from its render-host
+        // URL in will-attach (where `params.src` carries the full URL) and consumed
+        // FIFO in the matching did-attach — `guestWc.getURL()` is still empty there.
+        // Per-attach scope: a fresh simWc + handlers are built on every (re)attach.
+        const pendingGuestIsTab = [];
+        simWc.on('will-attach-webview', (_event, webPreferences, params) => {
+            ;
+            webPreferences.partition = partition;
+            params.partition = partition;
+            webPreferences.contextIsolation = false;
+            webPreferences.sandbox = false;
+            let isTab = false;
+            try {
+                isTab = new URL(params.src).searchParams.get('isTab') === '1';
+            }
+            catch { /* keep false */ }
+            pendingGuestIsTab.push(isTab);
+        });
+        simWc.on('did-attach-webview', (_event, guestWc) => {
+            // Scale the nested render-host page with the device zoom. The host WCV is
+            // sized to the SCALED bezel rect and runs at `currentZoomFactor`, so the
+            // guest must run at the same factor to lay the page out at the logical
+            // device width and paint at the right scale. At 100% (default) this is a
+            // no-op identity (factor 1). Newly-attached guests pick up the latest
+            // zoom here; live zoom changes re-apply via setNativeSimulatorViewBounds.
+            try {
+                guestWc.setZoomFactor(currentZoomFactor);
+            }
+            catch { /* guest not ready; setNativeSimulatorViewBounds re-applies */ }
+            // Simulate this device's CSS env(safe-area-inset-*) on the fresh guest
+            // before it paints, so notch-aware page layout resolves correctly. The
+            // bottom inset is page-type-dependent (see services/safe-area): a tab
+            // page's content sits above the shell tabBar (bottom 0); a non-tab page
+            // is full-bleed (real bottom inset). The page type was captured from the
+            // render-host URL in will-attach (FIFO).
+            const isTabGuest = pendingGuestIsTab.shift() ?? false;
+            safeArea.applyToGuest(guestWc, ctx.bridge?.getDevice() ?? null, isTabGuest);
+            guestWc.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
+            guestWc.on('will-navigate', (e, url) => {
+                try {
+                    const u = new URL(url);
+                    if (u.protocol === 'about:')
+                        return;
+                    if ((u.protocol === 'http:' || u.protocol === 'https:')
+                        && (u.hostname === 'localhost' || u.hostname === '127.0.0.1')) {
+                        return;
+                    }
+                    if (u.protocol === 'file:')
+                        return;
+                    e.preventDefault();
+                    if (u.protocol === 'http:' || u.protocol === 'https:') {
+                        void shell.openExternal(url);
+                    }
+                }
+                catch {
+                    e.preventDefault();
+                }
+            });
+            // The outer DeviceShell loading is insufficient: slow projects attach a
+            // render guest later. Resolve the renderer's attach IPC only after that
+            // first mini-app page has completed its own document load.
+            guestWc.once('did-finish-load', () => {
+                if (nativeSimulatorView !== view || simWc.isDestroyed())
+                    return;
+                // A loaded render guest means the shell booted end-to-end — from here
+                // on a soft reload (RELAUNCH into this live shell) is deliverable.
+                nativeSimulatorShellReady = true;
+                settleNativeSimulatorReady?.();
+                settleNativeSimulatorReady = null;
+            });
+            // A render-host guest only attaches after a spawn, so the service window
+            // exists by now — (re)point the right-panel DevTools at it. Belt-and-braces
+            // with the `onRenderEvent` path in case its emit lost the attach race.
+            devtoolsHost.followServiceHost();
+        });
+        // The simulator loads http://localhost:<port>/simulator.html. Harden popups
+        // + in-place navigation: allow the dev server origin (and about:blank /
+        // file:// render hosts), route everything else to the OS browser.
+        simWc.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
+        simWc.on('will-navigate', (e, url) => {
+            try {
+                const u = new URL(url);
+                if (u.protocol === 'about:')
+                    return;
+                if (u.protocol === 'file:')
+                    return;
+                if ((u.protocol === 'http:' || u.protocol === 'https:')
+                    && (u.hostname === 'localhost' || u.hostname === '127.0.0.1')) {
+                    return;
+                }
+                e.preventDefault();
+                if (u.protocol === 'http:' || u.protocol === 'https:') {
+                    void shell.openExternal(url);
+                }
+            }
+            catch {
+                e.preventDefault();
+            }
+        });
+        void simWc.loadURL(simulatorUrl).catch((err) => {
+            console.error('[workbench] attachNativeSimulator — loadURL failed', err);
+        });
+        // This WebContentsView's webContents IS the simulator: the native-host
+        // preload runs here and issues SPAWN, so bridge-router resolves
+        // ap.simulatorWc = event.sender = this wc, and SIMULATOR_EVENTS flow back.
+        simulatorWebContentsId = simWc.id;
+        // Forward this WCV's network requests (wx.request/download/upload run here,
+        // not in the service host) into the service-host console so they show in the
+        // embedded DevTools the right panel hosts. Attaches the CDP debugger; no-op
+        // if the forwarder is unwired (partial test ctx) or the debugger is claimed.
+        ctx.networkForward?.attachSimulator(simWc);
+        // Model A: bounds come ONLY from the renderer's window-level placement
+        // snapshot. The view now exists, so re-reconcile: gateReadiness admits the
+        // simulator (gated hidden while its WCV was absent) and the latest desired
+        // placement attaches + sizes it. Until the next snapshot it stays unadded.
+        reconciler.reconcileNow();
+        // Native-host page code (console.log / wx.request / Sources) runs in the
+        // hidden SERVICE HOST window, not this DeviceShell host nor the render-host
+        // guests. Keep the right-panel DevTools host view stable and point it at the
+        // service host so its Console/Network(fetch)/Sources reflect the logic layer.
+        // (The UI/view layer's Elements equivalent is the native WXML panel +
+        // render-guest highlight chain, which targets the active render guest.)
+        devtoolsHost.attach();
+        return ready;
+    }
+    function softReloadNativeSimulator(simulatorUrl) {
+        if (!nativeSimulatorView || nativeSimulatorView.webContents.isDestroyed())
+            return false;
+        if (!nativeSimulatorShellReady)
+            return false;
+        const payload = { url: simulatorUrl };
+        nativeSimulatorView.webContents.send(SIMULATOR_EVENTS.RELAUNCH, payload);
+        return true;
+    }
+    function detachSimulator() {
+        settleNativeSimulatorReady?.();
+        settleNativeSimulatorReady = null;
+        devtoolsHost.stopFollowing();
+        detachNativeCustomApiBridge();
+        // Stop Elements forwarding (detaches only the debugger sessions IT attached;
+        // safe-area's sessions are untouched). Idempotent — the host 'destroyed'
+        // handler may have already run.
+        devtoolsHost.stopElementsForwarding();
+        // Stop forwarding the simulator WCV's network (its debugger is detached as
+        // the view is closed below, but drop our session deterministically first).
+        // Also drop the DevTools front-end host — its wc is destroyed below; a stale
+        // ref would make the forwarder dispatch into a dead wc instead of falling
+        // back to the console.
+        ctx.networkForward?.detachSimulator();
+        ctx.networkForward?.setDevtoolsHost(null);
+        // Native-host simulator content view (no-op in the default path) — same
+        // single teardown path as relaunch. detachNativeCustomApiBridge was already
+        // called above.
+        tearDownNativeSimulatorView('close');
+        overlayPanels.hidePopover();
+        // Drop the settings view too — the previous detachAllViews() did.
+        overlayPanels.destroySettings();
+        // Destroy the right-panel DevTools front-end host — its wc is closed here.
+        devtoolsHost.destroyHostView();
+        simulatorWebContentsId = null;
+        nativeSimulatorProjectPath = null;
+    }
+    reconciler.registerView(VIEW_ID.simulator, {
+        getView: () => nativeSimulatorView,
+        setAdded: (added) => { nativeSimulatorViewAdded = added; },
+        gateHidden: () => !nativeSimulatorView,
+        applyBounds: (view, bounds, extra) => applyNativeSimulatorBounds(view, bounds, extra?.zoom ?? 1),
+    });
+    return {
+        attachNativeSimulator,
+        softReloadNativeSimulator,
+        detachSimulator,
+        getSimulatorWebContentsId: () => simulatorWebContentsId,
+        getSimulatorWebContents: () => {
+            if (simulatorWebContentsId == null)
+                return null;
+            const wc = webContents.fromId(simulatorWebContentsId);
+            return wc && !wc.isDestroyed() ? wc : null;
+        },
+        getSimulatorProjectPath: () => nativeSimulatorProjectPath,
+    };
+}
+//# sourceMappingURL=native-simulator-view.js.map

package/dist/main/services/views/overlay-panels-view.d.ts

@@ -0,0 +1,29 @@
+import type { WebContents } from 'electron';
+import type { PlacementReconciler } from './placement-reconciler.js';
+import type { ViewManagerContext } from './view-manager.js';
+/**
+ * The two main-owned overlay panels: the settings sheet (right-side panel over
+ * a transparent backdrop) and the transient popover. Their bounds are
+ * main-computed and published into the reconciler's `overlayDesired` (top-tier
+ * layers, so a reorder keeps them above every base overlay).
+ */
+export interface OverlayPanelsView {
+    showSettings(): Promise<void>;
+    hideSettings(): void;
+    showPopover(data: unknown): void;
+    hidePopover(): void;
+    /** Re-apply whichever of settings/popover is currently present (window resize / toolbar height change). */
+    reapplyPresentOverlays(): void;
+    /** Re-apply the settings overlay only (the resize entry point re-applies settings, not popover). */
+    applySettingsBoundsIfPresent(): void;
+    /** Destroy the cached settings view (aggregate simulator detach). */
+    destroySettings(): void;
+    getSettingsWebContents(): WebContents | null;
+    getSettingsWebContentsId(): number | null;
+    getPopoverWebContentsId(): number | null;
+}
+export declare function createOverlayPanelsView(ctx: ViewManagerContext, reconciler: PlacementReconciler, deps: {
+    /** The host-toolbar strip height that offsets the overlay top edge. */
+    getHostToolbarHeight(): number;
+}): OverlayPanelsView;
+//# sourceMappingURL=overlay-panels-view.d.ts.map

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

@@ -0,0 +1,150 @@
+import { WebContentsView } from 'electron';
+import path from 'path';
+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();
+    }
+    async function showSettings() {
+        if (!settingsView) {
+            settingsView = new WebContentsView({
+                webPreferences: {
+                    nodeIntegration: false,
+                    contextIsolation: true,
+                    sandbox: false,
+                    preload: mainPreloadPath,
+                },
+            });
+            // 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();
+    }
+    function hideSettings() {
+        reconciler.deleteOverlayDesired(VIEW_ID.settings);
+        reconciler.reconcileNow();
+    }
+    function showPopover(data) {
+        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'));
+    }
+    function hidePopover() {
+        if (!popoverView)
+            return;
+        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 reapplyPresentOverlays() {
+        if (reconciler.hasOverlayDesired(VIEW_ID.settings))
+            applySettingsBounds();
+        if (reconciler.hasOverlayDesired(VIEW_ID.popover))
+            applyPopoverBounds();
+    }
+    function applySettingsBoundsIfPresent() {
+        if (reconciler.hasOverlayDesired(VIEW_ID.settings))
+            applySettingsBounds();
+    }
+    function destroySettings() {
+        destroyChildView(ctx.windows.mainWindow, settingsView);
+        settingsView = null;
+    }
+    reconciler.registerView(VIEW_ID.settings, { getView: () => settingsView });
+    reconciler.registerView(VIEW_ID.popover, { getView: () => popoverView });
+    return {
+        showSettings,
+        hideSettings,
+        showPopover,
+        hidePopover,
+        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;
+        },
+    };
+}
+//# sourceMappingURL=overlay-panels-view.js.map