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

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

@@ -1,1567 +1,88 @@
-import { ipcMain, nativeTheme, shell, WebContentsView, webContents } from 'electron';
-import fs from 'node:fs';
-import path from 'path';
-import { cjsSiblingPreloadPath, mainPreloadPath } from '../../utils/paths.js';
-import { simDeskBg } from '../../utils/theme.js';
-import { applyNavigationHardening, handleWindowOpenExternal, } from '../../windows/navigation-hardening.js';
-import { SimulatorCustomApiBridgeChannel } from '../../../shared/ipc-channels.js';
-import { buildDevtoolsProjectSourceLinksScript, decodeOpenInEditorUrl, projectSourceContextFromServiceHostUrl, resourceUrlToProjectRelativePath, } from '../../../shared/open-in-editor.js';
 import { createSafeAreaController } from '../safe-area/index.js';
-import { buildCustomizeTabsScript } from './devtools-tabs.js';
-import { installElementsForward } from '../elements-forward/index.js';
-import { installServiceConsoleForward } from '../service-console/index.js';
-import * as layout from '../layout/index.js';
-import { handleCustomApiBridgeRequest, } from '../simulator/custom-apis.js';
-import { configureMiniappSession, miniappPartition } from './miniapp-partition.js';
-import { acquireHostToolbarSessionRuntime, releaseHostToolbarSessionRuntime, } from './host-toolbar-session-runtime.js';
-import { createHostToolbarPortChannel, } from './host-toolbar-port-channel.js';
-import { parseRoute } from '../../../shared/simulator-route.js';
-import { HEADER_H, HOST_TOOLBAR_RUNTIME_MARKER } from '../../../shared/constants.js';
-import { reconcile, createInitialState } from '@dimina-kit/electron-deck/layout';
-import { applyViewOps } from './apply-view-ops.js';
-import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
-/**
- * Resolve a DevTools source request against the service-host URL that created
- * the inspected app. Its pkgRoot is authoritative; the workspace is only a
- * stale-session consistency guard.
- */
-export function resolveProjectEditorTarget(serviceHostUrl, activeProjectRoot, req, isFile = (absolutePath) => fs.statSync(absolutePath).isFile()) {
-    const sourceContext = projectSourceContextFromServiceHostUrl(serviceHostUrl, activeProjectRoot);
-    if (!sourceContext)
-        return null;
-    const rel = resourceUrlToProjectRelativePath(req.url, sourceContext);
-    if (!rel)
-        return null;
-    const absolute = path.resolve(sourceContext.projectRoot, ...rel.split('/'));
-    const fromRoot = path.relative(path.resolve(sourceContext.projectRoot), absolute);
-    if (!fromRoot || fromRoot.startsWith('..') || path.isAbsolute(fromRoot))
-        return null;
-    try {
-        if (!isFile(absolute))
-            return null;
-    }
-    catch {
-        return null;
-    }
-    return {
-        path: rel,
-        line: typeof req.line === 'number' ? req.line + 1 : undefined,
-        column: typeof req.column === 'number' ? req.column + 1 : undefined,
-    };
-}
-// `webContents.executeJavaScript()` registers a transient `did-stop-loading`
-// listener on the target wc whenever that wc is still loading (Electron's
-// `waitTillCanExecuteJavaScript` defers the eval until load finishes, then
-// removes the listener). The DevTools front-end host wc takes a burst of injects
-// during its boot window — tab customization, default-panel selection, the 150ms
-// Elements-forward reconcile, and Network-forward probing all call
-// `executeJavaScript()` on it before the front-end has finished loading — so the
-// pending listeners can transiently exceed Node's default EventEmitter ceiling
-// of 10 and print a spurious `MaxListenersExceededWarning: 11 did-stop-loading
-// listeners`. They drain once the wc stops loading; this is a boot-time
-// concurrency spike, not a per-event leak. Raise the ceiling on the DevTools
-// host wc, which we knowingly inject into repeatedly during its boot window, so
-// the benign spike stays quiet. (Confirmed at runtime: the tripped emitter is
-// this host wc's `did-stop-loading`, count 11 — see the `process.on('warning')`
-// diagnostic in app bootstrap.)
-const DEVTOOLS_HOST_EXEC_JS_MAX_LISTENERS = 50;
-function raiseExecuteJavaScriptListenerCeiling(wc) {
-    try {
-        if (wc.isDestroyed())
-            return;
-        if (wc.getMaxListeners() >= DEVTOOLS_HOST_EXEC_JS_MAX_LISTENERS)
-            return;
-        wc.setMaxListeners(DEVTOOLS_HOST_EXEC_JS_MAX_LISTENERS);
-    }
-    catch { /* torn-down / stub wc — best effort, warning is non-fatal */ }
-}
+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 { createNativeSimulatorView } from './native-simulator-view.js';
+export { resolveProjectEditorTarget, } from './resolve-project-editor-target.js';
 /**
  * Build a ViewManager bound to the given context. The returned object is the
  * only component allowed to instantiate or add/remove overlay WebContentsViews.
  *
- * All view-related mutable state lives inside this closure and is not exposed
- * on the context object.
+ * All view-related mutable state lives inside the per-domain factory closures
+ * (and the single placement reconciler) below, never on the context object.
  */
 export function createViewManager(ctx) {
     // CSS env(safe-area-inset-*) simulation for render-host guests (per device).
-    // Driven from did-attach-webview below; re-pushed on device change via
-    // reapplySafeArea. Torn down in disposeAll.
+    // 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 });
-    // ── Private mutable state ───────────────────────────────────────────────
-    let simulatorView = null;
-    let simulatorViewAdded = false;
-    // NATIVE-HOST ONLY: the simulator content WebContentsView (the DeviceShell
-    // host). In the default path the simulator is a renderer `<webview>` and this
-    // stays null. Positioned in the simulator panel region (left of the splitter)
-    // while `simulatorView` above hosts its DevTools in the right panel region.
-    let nativeSimulatorView = null;
-    let nativeSimulatorViewAdded = false;
-    let nativeSimulatorProjectPath = null;
-    let settleNativeSimulatorReady = null;
-    // NATIVE-HOST ONLY. 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;
-    // NATIVE-HOST ONLY. 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 settingsView = null;
-    let popoverView = null;
-    let simulatorWebContentsId = null;
-    // NATIVE-HOST ONLY. The webContents the right-panel Chrome DevTools front-end
-    // currently inspects. We point it at the SERVICE HOST (logic layer) — the
-    // hidden BrowserWindow where the mini-app's page code runs (`console.log`,
-    // `wx.request`, Sources/Network(fetch) all live there). The UI/view layer
-    // (Elements/Styles/WXML tree) is served separately by the native WXML panel +
-    // render-guest highlight chain (`simulator-storage`/`simulator-wxml`), so a
-    // single DevTools front-end is enough. The service window can be swapped on
-    // respawn (pre-warm pool recycles it), so this is re-resolved fresh via
-    // `ctx.bridge.getServiceWc()` and re-pointed on every render-side event.
-    let nativeDevtoolsSourceWc = null;
-    let unsubscribeNativeRenderEvents = null;
-    // Disposer for the Elements-forward feature (routes the front-end's Elements
-    // CDP traffic at the active render guest). Installed in
-    // `attachNativeSimulatorDevtoolsHost`, stopped on detach / host destroyed.
-    let stopElementsForward = null;
-    // Disposer for the service-layer console capture (CDP `consoleAPICalled` on the
-    // service host wc → console fan-out). Installed when the DevTools is pointed at
-    // a service host, stopped when that source is closed / swapped.
-    let stopServiceConsole = null;
-    let nativeDevtoolsRetryTimer = null;
-    let nativeDevtoolsRetryToken = 0;
-    // ── Embedded workbench editor WebContentsView ────────────────────────
-    // The opt-in VS Code workbench hosting the 'editor' dock slot. Lazily created
-    // by `attachWorkbench` from the COI server URL; its bounds ride the renderer
-    // 'editor'-slot anchor (forward anchor, like the simulator DevTools overlay).
-    let workbenchView = null;
-    // Whether the devtools-theme → workbench-theme `nativeTheme` listener is live.
-    // Bound lazily on first workbench attach, removed on detach.
-    let workbenchThemeSyncBound = false;
-    // COI server base URL for the workbench, stored by `setWorkbenchSource`. The
-    // heavy WebContentsView load is deferred until the 'editor' slot first becomes
-    // visible (first non-zero `setWorkbenchBounds`) so it never sits on the app
-    // boot critical path (which would delay preload/window-ready and trip the e2e
-    // health check into a relaunch).
-    let workbenchUrl = null;
-    // ── Host-controllable toolbar WebContentsView ───────────────────────────
-    // A strip above the devtools header that the downstream host loads its own
-    // content into and fully controls. Bounds come from a renderer DOM anchor
-    // (forward anchor, like the simulator DevTools overlay); its height is
-    // dynamic via a reverse size-advertiser the toolbar's own renderer drives.
-    let hostToolbarView = null;
-    let hostToolbarPreloadOverride = null;
-    let hostToolbarViewAdded = false;
-    // Whether THIS manager holds a reference on the shared defaultSession
-    // registration of the toolbar-runtime preload (see
-    // host-toolbar-session-runtime.ts). Acquired on first toolbar need,
-    // released exactly once in disposeAll — a manager that never used the
-    // toolbar must not decrement a ref it never took.
-    let hostToolbarRuntimeAcquired = false;
-    // Placeholder height authority: 'auto' = advertiser reports forward to the
-    // renderer; { fixed } = host-pinned, advertiser reports are dropped.
-    let hostToolbarHeightMode = 'auto';
-    // Last toolbar height NOTIFIED to the main-window renderer — the replay
-    // source behind `getHostToolbarHeight()`. Updated ONLY inside
-    // `notifyHostToolbarHeight` so the retained value can never diverge from
-    // what the renderer was told (an advertiser report dropped by a `{ fixed }`
-    // pin must not pollute it, and a setHeightMode validation reject leaves it
-    // untouched).
-    let hostToolbarLastHeight = 0;
-    // Gated narrow channel to the toolbar PAGE (per-load MessagePort handshake;
-    // see host-toolbar-port-channel.ts). Control-level registry — created with
-    // the manager so onMessage() works before any toolbar view exists.
-    const hostToolbarPort = createHostToolbarPortChannel({
-        isCurrent: (wc) => liveHostToolbarWebContents() === wc,
+    // 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.
+    const reconciler = createPlacementReconciler(ctx);
+    const workbench = createWorkbenchView(ctx, reconciler);
+    const devtoolsHost = createDevtoolsHost(ctx, reconciler, {
+        openFileInWorkbench: workbench.openFileInWorkbench,
     });
-    // ── Internal helpers ────────────────────────────────────────────────────
-    function destroyViewInternal(view) {
-        if (!view)
-            return;
-        if (!ctx.windows.mainWindow.isDestroyed()) {
-            try {
-                ctx.windows.mainWindow.contentView.removeChildView(view);
-            }
-            catch { /* already removed */ }
-        }
-        try {
-            if (!view.webContents.isDestroyed()) {
-                view.webContents.close();
-            }
-        }
-        catch { /* ignore */ }
-    }
-    // ── Placement reconciler ────────────────────────────────────────────────
-    // The main-process view tree is converged toward the renderer's declared
-    // placement by a level-triggered reconciler (docs/view-placement-reconciler.md).
-    // The renderer publishes a window-level snapshot into `baseDesired`;
-    // settings/popover are main-owned and live in `overlayDesired`. Any change
-    // merges the two, runs the pure reconcile core, and applies the ordered ops
-    // through `viewTarget`. `epochCounter` is a single monotonic tick — main is the
-    // only (serial) reconcile caller, so the core's stale guard passes by
-    // construction; `rendererGeneration` still drives the reset on renderer restart.
-    let placementState = createInitialState();
-    let epochCounter = 0;
-    let rendererGeneration = 0;
-    const baseDesired = new Map();
-    const overlayDesired = new Map();
-    // simulator / simulator-devtools WCVs are built by the project-open flow, not
-    // by an attach op; gate them hidden until they exist so the reconciler never
-    // records an attach that addChildView can't perform. The view-creation sites
-    // call reconcileNow() to re-open the gate. workbench is gated until it has a
-    // source or a live view (it lazy-creates from the URL in target.attach).
-    function gateReadiness(v) {
-        if (v.viewId === VIEW_ID.simulator && !nativeSimulatorView)
-            return { ...v, placement: { visible: false } };
-        if (v.viewId === VIEW_ID.simulatorDevtools && !simulatorView)
-            return { ...v, placement: { visible: false } };
-        if (v.viewId === VIEW_ID.workbench && !workbenchView && !workbenchUrl)
-            return { ...v, placement: { visible: false } };
-        return v;
-    }
-    function resolveView(viewId) {
-        switch (viewId) {
-            case VIEW_ID.simulator: return nativeSimulatorView;
-            case VIEW_ID.simulatorDevtools: return simulatorView;
-            case VIEW_ID.workbench: return workbenchView;
-            case VIEW_ID.hostToolbar: return hostToolbarView;
-            case VIEW_ID.settings: return settingsView;
-            case VIEW_ID.popover: return popoverView;
-            default: return null;
-        }
-    }
-    function markAdded(viewId, added) {
-        switch (viewId) {
-            case VIEW_ID.simulator:
-                nativeSimulatorViewAdded = added;
-                break;
-            case VIEW_ID.simulatorDevtools:
-                simulatorViewAdded = added;
-                break;
-            case VIEW_ID.hostToolbar:
-                hostToolbarViewAdded = added;
-                break;
-            // popover has no added-flag (create == added).
-        }
-    }
-    // simulator zoom rides in `extra`: setBounds also drives the WCV zoomFactor and
-    // propagates it to nested render-host guests (from the old
-    // setNativeSimulatorViewBounds body).
-    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 */ }
-    }
-    const viewTarget = {
-        attach(viewId) {
-            if (ctx.windows.mainWindow.isDestroyed())
-                return;
-            if (viewId === VIEW_ID.workbench && !workbenchView && workbenchUrl) {
-                // Lazy-load the workbench; attachWorkbench adds it + sets the flag.
-                void attachWorkbench(workbenchUrl);
-                return;
-            }
-            if (viewId === VIEW_ID.hostToolbar) {
-                const view = ensureHostToolbarView();
-                ctx.windows.mainWindow.contentView.addChildView(view);
-                hostToolbarViewAdded = true;
-                return;
-            }
-            const view = resolveView(viewId);
-            if (!view)
-                return;
-            ctx.windows.mainWindow.contentView.addChildView(view);
-            markAdded(viewId, true);
-        },
-        detach(viewId) {
-            const view = resolveView(viewId);
-            if (view && !ctx.windows.mainWindow.isDestroyed()) {
-                try {
-                    ctx.windows.mainWindow.contentView.removeChildView(view);
-                }
-                catch { /* already removed */ }
-            }
-            markAdded(viewId, false);
-        },
-        setBounds(viewId, bounds, extra) {
-            const view = resolveView(viewId);
-            if (!view || view.webContents.isDestroyed())
-                return;
-            if (viewId === VIEW_ID.simulator) {
-                applyNativeSimulatorBounds(view, bounds, extra?.zoom ?? 1);
-                return;
-            }
-            view.setBounds(bounds);
-        },
-        setVisible(viewId, visible) {
-            const view = resolveView(viewId);
-            if (!view)
-                return;
-            try {
-                view.setVisible(visible);
-            }
-            catch { /* stub may lack setVisible */ }
-        },
-        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 = resolveView(viewId);
-                if (view) {
-                    try {
-                        cv.addChildView(view);
-                    }
-                    catch { /* already attached */ }
-                }
-            }
-        },
-    };
-    // Create the lazily-built views (host-toolbar, workbench) BEFORE reconcile so
-    // the setBounds op — which the core emits before attach — lands on a live view
-    // rather than a not-yet-created one.
-    function ensureLazyViews() {
-        const ht = baseDesired.get(VIEW_ID.hostToolbar);
-        if (ht?.placement.visible && !liveHostToolbarWebContents())
-            ensureHostToolbarView();
-        const wb = baseDesired.get(VIEW_ID.workbench);
-        if (wb?.placement.visible && !workbenchView && workbenchUrl)
-            void attachWorkbench(workbenchUrl);
-    }
-    function reconcileNow() {
-        ensureLazyViews();
-        const views = [];
-        for (const v of baseDesired.values())
-            views.push(gateReadiness(v));
-        for (const v of overlayDesired.values())
-            views.push(v);
-        const result = reconcile(placementState, {
-            generation: rendererGeneration,
-            epoch: ++epochCounter,
-            views,
-        });
-        placementState = result.state;
-        applyViewOps(result.ops, viewTarget);
-    }
-    function setPlacementSnapshot(snapshot) {
-        rendererGeneration = snapshot.generation;
-        baseDesired.clear();
-        for (const v of snapshot.views)
-            baseDesired.set(v.viewId, v);
-        reconcileNow();
-    }
-    // ── Embedded workbench editor WebContentsView ────────────────────────
-    /** Current devtools color scheme, mirrored into the workbench's theme. */
-    function workbenchThemeScheme() {
-        return nativeTheme.shouldUseDarkColors ? 'dark' : 'light';
-    }
-    // Push the live devtools scheme into the workbench whenever it flips. The
-    // workbench is a plain isolated http document, so drive its exposed
-    // `__WB_SET_THEME` setter over executeJavaScript (mirrors openFileInWorkbench).
-    // The setter only exists once the workbench's configuration service is
-    // initialized; before then the URL-query initial value already covers the
-    // current scheme, and a missing setter here is a tolerated no-op.
-    function pushWorkbenchTheme() {
-        if (!workbenchView || workbenchView.webContents.isDestroyed())
-            return;
-        const wc = workbenchView.webContents;
-        if (typeof wc.executeJavaScript !== 'function')
-            return;
-        const script = `window.__WB_SET_THEME && window.__WB_SET_THEME(${JSON.stringify(workbenchThemeScheme())})`;
-        wc.executeJavaScript(script, true).catch(() => { });
-    }
-    async function attachWorkbench(url) {
-        if (workbenchView)
-            return;
-        const view = new WebContentsView({
-            webPreferences: {
-                nodeIntegration: false,
-                contextIsolation: true,
-                sandbox: false,
-            },
-        });
-        workbenchView = view;
-        // 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
-        // detachWorkbench.
-        if (!workbenchThemeSyncBound) {
-            nativeTheme.on('updated', pushWorkbenchTheme);
-            workbenchThemeSyncBound = true;
-        }
-        // The workbench bundle loads arbitrary URLs (docs links, etc.); route popups
-        // + cross-origin in-place navigation to the OS browser (mirror the host
-        // toolbar / native simulator hardening).
-        try {
-            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).
-        const loadUrl = `${url}index.html?theme=${workbenchThemeScheme()}`;
-        await view.webContents.loadURL(loadUrl).catch((err) => {
-            console.error('[workbench] attachWorkbench — loadURL failed', err);
-        });
-    }
-    /** Store the COI base URL; the heavy load happens lazily on first show. */
-    function setWorkbenchSource(url) {
-        workbenchUrl = url;
-    }
-    function detachWorkbench() {
-        if (workbenchThemeSyncBound) {
-            nativeTheme.removeListener('updated', pushWorkbenchTheme);
-            workbenchThemeSyncBound = false;
-        }
-        destroyViewInternal(workbenchView);
-        workbenchView = null;
-        baseDesired.delete(VIEW_ID.workbench);
-        reconcileNow();
-    }
-    // Build the `file:///workspace/<rel>` URI string with each path SEGMENT
-    // percent-encoded. A raw `rel` passed to `vscode.Uri.parse` mis-parses a
-    // filename containing `#` (treated as a fragment) or `?` (treated as a
-    // query), opening the wrong document; encoding each segment (but not the
-    // `/` separators) keeps the path structure while escaping the reserved
-    // characters. Leading slashes are already stripped by the caller.
-    function workspaceUriFor(rel) {
-        const encoded = rel.split('/').map(encodeURIComponent).join('/');
-        return `file:///workspace/${encoded}`;
-    }
-    // Single attempt to reveal `uri` at the 0-based position in the workbench.
-    // Resolves false when `__WB_PROBE` is not yet exposed (the workbench's
-    // configuration service has not initialized) OR the open throws, so the
-    // caller can retry; true once the document is shown.
-    function tryRevealInWorkbench(uri, zeroLine, zeroCol) {
-        if (!workbenchView || workbenchView.webContents.isDestroyed()) {
-            return Promise.resolve(false);
-        }
-        const script = `(async () => {
-      try {
-        const P = window.__WB_PROBE; if (!P) return false
-        const vscode = P.vscode
-        const uri = vscode.Uri.parse(${JSON.stringify(uri)})
-        const doc = await vscode.workspace.openTextDocument(uri)
-        const pos = new vscode.Position(${zeroLine}, ${zeroCol})
-        await vscode.window.showTextDocument(doc, { selection: new vscode.Range(pos, pos) })
-        return true
-      } catch (e) { return false }
-    })()`;
-        return workbenchView.webContents
-            .executeJavaScript(script, true)
-            .then((ok) => ok === true)
-            .catch(() => false);
-    }
-    // Reveal a project file in the embedded workbench, awaiting the real open
-    // result and retrying while the workbench finishes booting. The right-panel
-    // console redirect (`onOpenUrl`) fires open-in-editor clicks that can land
-    // during the workbench's lazy attach/boot window, when `__WB_PROBE` is not
-    // yet exposed; without the retry the click is silently dropped (the inner
-    // script returns false and the old code ignored it). Returns true only once
-    // the document is actually shown; false when there is no workbench view or
-    // every attempt failed.
-    function openFileInWorkbench(relPath, line, column) {
-        if (!workbenchView || workbenchView.webContents.isDestroyed())
-            return false;
-        // The workbench mirrors the active project under file:///workspace/<rel>; the
-        // open-in-editor target is 1-based (editor convention) while vscode.Position
-        // is 0-based, so clamp-convert. Drive the workbench's own vscode API rather
-        // than a preload bridge — the bundle is a plain isolated http document.
-        const uri = workspaceUriFor(relPath.replace(/^\/+/, ''));
-        const zeroLine = Math.max(0, Math.floor(line) - 1);
-        const zeroCol = Math.max(0, Math.floor(column) - 1);
-        void (async () => {
-            // Poll for workbench readiness: ~10 attempts × 150ms ≈ 1.5s, covering the
-            // first lazy attach + ext-host boot. Each attempt re-checks the live view
-            // so a teardown mid-retry bails cleanly.
-            for (let attempt = 0; attempt < 10; attempt++) {
-                if (!workbenchView || workbenchView.webContents.isDestroyed())
-                    return;
-                if (await tryRevealInWorkbench(uri, zeroLine, zeroCol))
-                    return;
-                await new Promise((resolve) => setTimeout(resolve, 150));
-            }
-            console.error('[workbench] openFileInWorkbench: workbench never became ready for', uri);
-        })();
-        return true;
-    }
-    // ── Host-controllable toolbar WebContentsView ───────────────────────────
-    // The toolbar's webContents lifecycle belongs to the HOST, which may close
-    // it out from under us (the documented rebuild path). In real Electron a
-    // WebContentsView whose webContents was destroyed can report `webContents`
-    // as undefined — not merely a destroyed handle — so every access must
-    // tolerate BOTH (observed in the R1 e2e: `.isDestroyed()` on undefined threw
-    // inside the control surface after the host closed the wc).
-    function liveHostToolbarWebContents() {
-        const wc = hostToolbarView?.webContents;
-        if (!wc || wc.isDestroyed())
-            return null;
-        return wc;
-    }
-    // Lazily create the host-toolbar view. Mirrors `showSettings` for the
-    // webPreferences shape and the native simulator for nav hardening +
-    // background color (the host may load arbitrary URLs / content). Idempotent.
-    function ensureHostToolbarView() {
-        if (hostToolbarView && liveHostToolbarWebContents()) {
-            return hostToolbarView;
-        }
-        // Rebuilding after the host destroyed the underlying webContents: detach the
-        // dead view from the contentView and reset the added-flag so the new view
-        // gets re-mounted (otherwise the `hostToolbarViewAdded` guard would skip the
-        // addChildView and the toolbar would silently disappear).
-        if (hostToolbarView && hostToolbarViewAdded) {
-            try {
-                ctx.windows.mainWindow.contentView.removeChildView(hostToolbarView);
-            }
-            catch { /* already removed */ }
-            hostToolbarViewAdded = false;
-        }
-        // The instance is being replaced — forget its reconciled mount state so the
-        // rebuilt view is treated as a fresh attach (not skipped as already-attached).
-        placementState.actual.delete(VIEW_ID.hostToolbar);
-        // The framework's height-advertiser runtime is SESSION-resident: register
-        // it on session.defaultSession (ref-counted across coexisting managers)
-        // BEFORE the view exists, so the very first load already runs it. The
-        // toolbar WCV stays on the defaultSession (no partition/session override)
-        // — moving it onto its own partition would silently detach it from this
-        // registration and height advertising would die with no error.
-        if (!hostToolbarRuntimeAcquired) {
-            acquireHostToolbarSessionRuntime();
-            hostToolbarRuntimeAcquired = true;
-        }
-        // `webPreferences.preload` is the HOST's alone (setPreloadPath); the
-        // built-in advertiser no longer rides it (it would execute twice — the
-        // session copy + the webPreferences copy). The additionalArguments marker
-        // is what the session runtime's guard keys on to activate here and stay a
-        // zero-footprint no-op in every other defaultSession renderer.
-        const webPreferences = {
-            nodeIntegration: false,
-            contextIsolation: true,
-            sandbox: false,
-            additionalArguments: [HOST_TOOLBAR_RUNTIME_MARKER],
-        };
-        if (hostToolbarPreloadOverride !== null) {
-            webPreferences.preload = hostToolbarPreloadOverride;
-        }
-        const view = new WebContentsView({ webPreferences });
-        hostToolbarView = view;
-        // Hook the per-load MessagePort handshake (did-finish-load) + dead-port
-        // cleanup (destroyed) on the fresh wc. AFTER the assignment above so the
-        // channel's isCurrent guard sees this wc as the live one.
-        hostToolbarPort.attach(view.webContents);
-        // Paint the surface a neutral color so growing the reserved strip never
-        // flashes white before the host content paints (mirrors the native
-        // simulator's setBackgroundColor anti-flash).
-        try {
-            view.setBackgroundColor('#121212');
-        }
-        catch { /* stub may lack it */ }
-        // The host may load arbitrary URLs; route popups + cross-origin in-place
-        // navigation to the OS browser (mirror the native simulator hardening).
-        try {
-            view.webContents.setWindowOpenHandler(({ url }) => handleWindowOpenExternal(url));
-        }
-        catch { /* stub may lack it */ }
-        return view;
-    }
-    // Single funnel for the height notify: retain-then-push, so the retained
-    // value is exactly the last value the renderer was told. Every height
-    // notify site MUST go through here — the renderer pulls the retained value
-    // on project-view mount to replay a push it missed (the toolbar's
-    // size-advertiser deduplicates and never re-reports).
-    function notifyHostToolbarHeight(height) {
-        hostToolbarLastHeight = height;
-        ctx.notify.hostToolbarHeightChanged(height);
-        if (overlayDesired.has(VIEW_ID.settings))
-            applySettingsBounds();
-        if (overlayDesired.has(VIEW_ID.popover))
-            applyPopoverBounds();
-    }
-    function setHostToolbarHeight(extent) {
-        // While the host pins a fixed height, drop advertiser reports entirely —
-        // the session-resident advertiser is always installed, so forwarding its
-        // reports would make the strip oscillate between the pinned and measured
-        // heights on every content resize. Dropped reports must not touch the
-        // retained value either: retention records what was NOTIFIED, not what
-        // was reported.
-        if (hostToolbarHeightMode !== 'auto')
-            return;
-        // Push the reserved height back to the main-window renderer so its
-        // placeholder div resizes (closing the dynamic-height loop). The notified
-        // height IS retained in main (`getHostToolbarHeight`) so a renderer that
-        // mounts later can pull/replay it; the renderer placeholder remains the
-        // geometry authority — the forward anchor re-reports bounds from it.
-        notifyHostToolbarHeight(extent);
-    }
-    function hideHostToolbar() {
-        baseDesired.set(VIEW_ID.hostToolbar, {
-            viewId: VIEW_ID.hostToolbar,
-            placement: { visible: false },
-            layer: VIEW_LAYER.hostToolbar,
-        });
-        reconcileNow();
-        // Collapse the renderer placeholder to 0 too. Otherwise its anchor keeps a
-        // non-zero reserved height and re-publishes bounds on the next window
-        // resize, silently re-adding the view we just hid (unstable hide). Zeroing
-        // the height flips the anchor to `present:false` so it stops re-publishing.
-        // Through the funnel so the retained value follows to 0 — a renderer
-        // mounting after the hide must replay 0, not the stale pre-hide height.
-        notifyHostToolbarHeight(0);
-    }
-    const hostToolbar = {
-        async loadURL(url) {
-            const view = ensureHostToolbarView();
-            // Invalidate SYNCHRONOUSLY at initiation, before the load is issued:
-            // the current document is about to be replaced, so a same-tick send()
-            // must report false instead of confirming delivery into it. The channel
-            // recovers on the new document's did-finish-load handshake. (Cannot
-            // rely on did-start-navigation here — that only covers page-initiated
-            // navigations once the load is actually under way.)
-            hostToolbarPort.invalidate();
-            await view.webContents.loadURL(url);
-        },
-        async loadFile(filePath) {
-            const view = ensureHostToolbarView();
-            // Same initiation-invalidates contract as loadURL above.
-            hostToolbarPort.invalidate();
-            await view.webContents.loadFile(filePath);
-        },
-        get webContents() {
-            return liveHostToolbarWebContents();
-        },
-        hide() {
-            hideHostToolbar();
-        },
-        setPreloadPath(path) {
-            // The HOST's own webPreferences.preload, applied when the view is next
-            // (re)created. `null` = no host preload. The framework advertiser is
-            // session-resident and unaffected either way (see ensureHostToolbarView).
-            hostToolbarPreloadOverride = path;
-        },
-        setHeightMode(mode) {
-            // Validate BEFORE touching any state: a poisoned `{ fixed }` (NaN /
-            // ±Infinity / negative) must neither reach the renderer placeholder
-            // (`height: NaNpx` corrupts the strip with no error anywhere) nor
-            // clobber the standing mode — fail-closed, not fail-corrupt.
-            if (mode !== 'auto' && !(Number.isFinite(mode.fixed) && mode.fixed >= 0)) {
-                throw new TypeError(`hostToolbar.setHeightMode: fixed height must be a finite, non-negative number (got ${mode.fixed})`);
-            }
-            hostToolbarHeightMode = mode;
-            if (mode !== 'auto') {
-                // Pin immediately: a preload-less/static toolbar never advertises, so
-                // waiting for the next report would leave the strip at height 0.
-                notifyHostToolbarHeight(mode.fixed);
-            }
-            // Switching back to 'auto' deliberately does NOT synthesize a notify —
-            // replaying a stale cached height would flash the old size; the NEXT
-            // advertiser report drives the placeholder again. The RETAINED value
-            // survives the switch though: a freshly-mounting renderer still needs
-            // the pinned height until that next report lands.
-        },
-        onMessage(channel, handler) {
-            return hostToolbarPort.onMessage(channel, handler);
-        },
-        onReady(handler) {
-            return hostToolbarPort.onReady(handler);
-        },
-        send(channel, payload) {
-            return hostToolbarPort.send(channel, payload);
-        },
-    };
-    function overlayHeaderHeight() {
-        return HEADER_H + hostToolbarLastHeight;
-    }
-    // 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();
-        overlayDesired.set(VIEW_ID.settings, {
-            viewId: VIEW_ID.settings,
-            placement: {
-                visible: true,
-                bounds: layout.computeSettingsBounds(w, h, overlayHeaderHeight()),
-            },
-            layer: VIEW_LAYER.settings,
-        });
-        reconcileNow();
-    }
-    function applyPopoverBounds() {
-        if (!popoverView || ctx.windows.mainWindow.isDestroyed())
-            return;
-        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        overlayDesired.set(VIEW_ID.popover, {
-            viewId: VIEW_ID.popover,
-            placement: {
-                visible: true,
-                bounds: layout.computePopoverBounds(w, h, overlayHeaderHeight()),
-            },
-            layer: VIEW_LAYER.popover,
-        });
-        reconcileNow();
-    }
-    function clearNativeDevtoolsRetry() {
-        nativeDevtoolsRetryToken++;
-        if (nativeDevtoolsRetryTimer) {
-            clearTimeout(nativeDevtoolsRetryTimer);
-            nativeDevtoolsRetryTimer = null;
-        }
-    }
-    function closeNativeDevtoolsSource() {
-        const source = nativeDevtoolsSourceWc;
-        nativeDevtoolsSourceWc = null;
-        try {
-            stopServiceConsole?.();
-        }
-        catch { /* already stopped */ }
-        stopServiceConsole = null;
-        if (!source || source.isDestroyed())
-            return;
-        try {
-            if (source.isDevToolsOpened()) {
-                source.closeDevTools();
-            }
-        }
-        catch { /* source may be mid-destroy */ }
-    }
-    function stopFollowingNativeServiceHost() {
-        clearNativeDevtoolsRetry();
-        if (unsubscribeNativeRenderEvents) {
-            try {
-                unsubscribeNativeRenderEvents();
-            }
-            catch { /* ignore */ }
-            unsubscribeNativeRenderEvents = null;
-        }
-        closeNativeDevtoolsSource();
-    }
-    // ── Open-in-editor: click a console file link → workbench ──────────────
-    // The right-panel console is the embedded Chromium DevTools front-end. Once a
-    // sourcemap maps a console frame back to source (restored by the service-host
-    // importScripts sourcemap rewrite), we redirect a source-link click to OUR
-    // workbench editor instead of the DevTools Sources panel: install an "open
-    // resource handler" in the front-end realm that encodes (url, line, col) into
-    // a sentinel URL and asks the front-end to open it; Electron surfaces that as
-    // `devtools-open-url` on the inspected (service-host) wc, which we decode,
-    // map to a project-relative path, and reveal in the workbench WCV.
-    const openInEditorWiredWcIds = new Set();
-    function injectOpenResourceHandler(serviceWc, devtoolsWc) {
-        // Inject the front-end glue that routes a project source-link click to our
-        // Monaco editor instead of the DevTools Sources panel: a capture-phase click
-        // interceptor re-emits an encoded sentinel via
-        // `InspectorFrontendHost.openInNewTab` → Electron `devtools-open-url`. (The
-        // legacy `setOpenResourceHandler` hook this used to rely on is gone in
-        // current Chromium, so the script keeps it only as a fallback.)
-        //
-        // Destroy-race chokepoint: this runs from a deferred `dom-ready` callback
-        // (see wireOpenInEditor), by which time the inspected service-host wc may
-        // already be torn down (pool swap / project close / relaunch). Reading
-        // `serviceWc.getURL()` on a destroyed wc throws "Object has been destroyed"
-        // synchronously, which would escape the event listener. Guard both wc and
-        // wrap the body so a teardown mid-call degrades silently (mirrors
-        // customizeDevtoolsTabs).
-        if (serviceWc.isDestroyed() || devtoolsWc.isDestroyed())
-            return;
-        try {
-            const sourceContext = projectSourceContextFromServiceHostUrl(serviceWc.getURL(), ctx.workspace?.getProjectPath?.());
-            if (!sourceContext)
-                return;
-            devtoolsWc.executeJavaScript(buildDevtoolsProjectSourceLinksScript(sourceContext)).catch(() => { });
-        }
-        catch { /* wc torn down mid-call — degrade silently */ }
-    }
-    // ── DevTools tab customization: keep only Elements/Console/Network ──────────
-    // Inject into the same DevTools front-end host wc that the console/network
-    // injectors target. Reorders Elements/Console/Network to the front and closes
-    // every other panel tab by driving the front-end's UI.ViewManager /
-    // InspectorView.tabbedLocation (see ./devtools-tabs.ts). Best-effort: the
-    // injected script bounded-polls for the lazily-registered panels, wraps
-    // everything in try/catch, and silently no-ops if the API never appears —
-    // DevTools default tab behaviour is preserved on any failure. Re-injected on
-    // every (re)point so a re-`openDevTools` (service-host pool swap) re-applies.
-    function customizeDevtoolsTabs(devtoolsWc) {
-        try {
-            if (devtoolsWc.isDestroyed())
-                return;
-            const inject = () => {
-                if (devtoolsWc.isDestroyed())
-                    return;
-                try {
-                    void devtoolsWc.executeJavaScript(buildCustomizeTabsScript()).catch(() => { });
-                }
-                catch { /* wc torn down mid-call */ }
-            };
-            if (devtoolsWc.isLoading()) {
-                devtoolsWc.once('dom-ready', inject);
-            }
-            else {
-                inject();
-            }
-        }
-        catch { /* wc surface incomplete / torn down; degrade silently */ }
-    }
-    function wireOpenInEditor(serviceWc, devtoolsWc) {
-        // Inject the front-end handler on every (re)attach — the DevTools front-end
-        // wc is recreated per simulatorView, so a fresh host needs the handler set.
-        if (!devtoolsWc.isDestroyed()) {
-            if (devtoolsWc.isLoading()) {
-                devtoolsWc.once('dom-ready', () => injectOpenResourceHandler(serviceWc, devtoolsWc));
-            }
-            else {
-                injectOpenResourceHandler(serviceWc, devtoolsWc);
-            }
-        }
-        // Attach the `devtools-open-url` decoder to the inspected service wc once
-        // (the listener is keyed off the encoded sentinel scheme, so it only acts on
-        // OUR redirected links; any other devtools "open in new tab" falls through).
-        if (openInEditorWiredWcIds.has(serviceWc.id))
-            return;
-        openInEditorWiredWcIds.add(serviceWc.id);
-        const onOpenUrl = (_event, url) => {
-            const req = decodeOpenInEditorUrl(url);
-            if (!req)
-                return; // not our sentinel — leave it to Electron's default path
-            const target = resolveProjectEditorTarget(serviceWc.getURL(), ctx.workspace?.getProjectPath?.(), req);
-            if (!target)
-                return;
-            // Drive the workbench WCV (the sole editor) when it is attached, AND
-            // always emit `editor:openFile` — it carries the editor-agnostic mapping
-            // (project-relative path + 1-based line) that downstream/consumers (and the
-            // open-in-editor contract test) observe; with Monaco gone it has no
-            // renderer subscriber, so emitting it is harmless when the workbench
-            // handles the actual reveal.
-            openFileInWorkbench(target.path, target.line ?? 1, target.column ?? 1);
-            ctx.notify.editorOpenFile(target);
-        };
-        serviceWc.on('devtools-open-url', onOpenUrl);
-        // Consolidate teardown onto the connection layer,
-        // but as a wc-LIFETIME resource: the open-in-editor wiring inspects this
-        // service-host wc and must SURVIVE pool reuse (`reset`) — the dedup set
-        // entry + listener stay valid across sessions reusing the same wc, and the
-        // early-return dedup above correctly skips re-wiring after a reset. So we
-        // register on `'closed'` (fires only on real wc destroy), NOT `own()`
-        // (which also fires on `reset` and would leave the wc un-wired after reuse
-        // because re-pointing the same wc.id early-returns). acquire() is
-        // idempotent — bridge-router owning session-scoped resources on the same
-        // serviceWc connection coexists cleanly.
-        const conn = ctx.connections.acquire(serviceWc);
-        conn.on('closed', () => {
-            openInEditorWiredWcIds.delete(serviceWc.id);
-            try {
-                serviceWc.removeListener('devtools-open-url', onOpenUrl);
-            }
-            catch { /* wc gone */ }
-        });
-    }
-    // Point the right-panel Chrome DevTools front-end at `next` — the SERVICE HOST
-    // webContents (logic layer). Idempotent: if we already inspect this wc, no-op.
-    function pointNativeDevtoolsAtServiceWc(next) {
-        if (!simulatorView || simulatorView.webContents.isDestroyed())
-            return true;
-        if (nativeDevtoolsSourceWc?.id === next.id && !nativeDevtoolsSourceWc.isDestroyed()) {
-            return true;
-        }
-        closeNativeDevtoolsSource();
-        nativeDevtoolsSourceWc = next;
-        try {
-            next.setDevToolsWebContents(simulatorView.webContents);
-            // DevTools renders into the right-panel host view (simulatorView); with a
-            // custom host the `mode` is overridden, and `activate:false` prevents it
-            // stealing focus — this re-points whenever the service window is swapped,
-            // so a focusing window would yank focus repeatedly (disrupting the user /
-            // e2e).
-            next.openDevTools({ mode: 'detach', activate: false });
-            // Redirect console source-link clicks to the workbench editor.
-            wireOpenInEditor(next, simulatorView.webContents);
-            // Keep only Elements/Console/Network tabs (front-most, in that order).
-            // Re-applied on every re-point so a service-host pool swap (fresh
-            // openDevTools) re-asserts the custom tab bar.
-            customizeDevtoolsTabs(simulatorView.webContents);
-            // Capture service-layer console via CDP (NOT a preload monkeypatch, which
-            // would clobber native source attribution) and feed it to the console
-            // fan-out (automation `App.logAdded`). Bound to THIS service wc; replaced
-            // on the next re-point via closeNativeDevtoolsSource.
-            try {
-                stopServiceConsole?.();
-            }
-            catch { /* already stopped */ }
-            stopServiceConsole = installServiceConsoleForward({
-                serviceWc: next,
-                connections: ctx.connections,
-                emit: (entry) => ctx.consoleForwarder?.emit(entry),
-            }).stop;
-            return true;
-        }
-        catch {
-            if (nativeDevtoolsSourceWc?.id === next.id) {
-                nativeDevtoolsSourceWc = null;
-            }
-            return false;
-        }
-    }
-    // Resolve the SERVICE HOST webContents for the active (or named) app. This is
-    // the hidden service BrowserWindow's wc — a top-level wc that CAN host a
-    // Chrome DevTools front-end (unlike a `<webview>` guest's). Re-resolved fresh
-    // so a pre-warm-pool swap on respawn is tolerated.
-    function pointNativeDevtoolsAtActiveServiceHost(appId) {
-        if (!ctx.bridge?.isNativeHost())
-            return true;
-        if (!simulatorView || simulatorView.webContents.isDestroyed())
-            return true;
-        const wc = ctx.bridge.getServiceWc(appId);
-        if (!wc || wc.isDestroyed())
-            return false;
-        return pointNativeDevtoolsAtServiceWc(wc);
-    }
-    function scheduleNativeDevtoolsFollow(appId, attempt = 0) {
-        if (attempt >= 20)
-            return;
-        if (!ctx.bridge?.isNativeHost())
-            return;
-        const token = nativeDevtoolsRetryToken;
-        if (nativeDevtoolsRetryTimer)
-            clearTimeout(nativeDevtoolsRetryTimer);
-        nativeDevtoolsRetryTimer = setTimeout(() => {
-            nativeDevtoolsRetryTimer = null;
-            if (token !== nativeDevtoolsRetryToken)
-                return;
-            if (pointNativeDevtoolsAtActiveServiceHost(appId))
-                return;
-            scheduleNativeDevtoolsFollow(appId, attempt + 1);
-        }, 50);
-    }
-    function followNativeDevtoolsServiceHost(appId) {
-        clearNativeDevtoolsRetry();
-        if (pointNativeDevtoolsAtActiveServiceHost(appId))
-            return;
-        scheduleNativeDevtoolsFollow(appId);
-    }
-    // Render-side activity (a page DOM mounting / the visible page changing)
-    // always follows a spawn or respawn, by which point the service window exists
-    // (and may have been swapped by the pool). Re-resolve + re-point the DevTools
-    // at the now-current service host on every such event.
-    function onNativeRenderEvent(event) {
-        if (event.kind !== 'activePage' && event.kind !== 'domReady')
-            return;
-        followNativeDevtoolsServiceHost(event.appId);
-    }
-    // ── ViewManager methods ─────────────────────────────────────────────────
-    function attachNativeSimulatorDevtoolsHost() {
-        stopFollowingNativeServiceHost();
-        // Destroy old simulatorView to prevent WebContentsView leak
-        if (simulatorView) {
-            removeSimulatorDevtoolsView();
-            try {
-                if (!simulatorView.webContents.isDestroyed()) {
-                    simulatorView.webContents.close();
-                }
-            }
-            catch { /* ignore */ }
-            simulatorView = null;
-        }
-        simulatorView = new WebContentsView();
-        // Default DevTools to Console panel (Chrome DevTools defaults to Elements).
-        // The DevTools UI lives inside closed shadow roots, so a light-DOM
-        // querySelector('[role="tab"]') cannot reach the tab bar to click it.
-        // Instead drive the front-end's own view manager: the bundled DevTools
-        // exposes `UI.ViewManager.instance().showView(id)` on `globalThis.UI`
-        // once the front-end has finished bootstrapping. We poll for it and
-        // request the `console` view, and also persist the choice via the
-        // `panel-selectedTab` localStorage key so subsequent reloads honor it.
-        const devtoolsWc = simulatorView.webContents;
-        // The boot-time burst of `executeJavaScript()` injects on this host wc (tab
-        // customization / console default / Elements+Network forwarding below) each
-        // queue a pending `did-stop-loading` waiter while the front-end is still
-        // loading (see raiseExecuteJavaScriptListenerCeiling).
-        raiseExecuteJavaScriptListenerCeiling(devtoolsWc);
-        // Hand the network forwarder THIS front-end host wc — it injects the
-        // simulator WCV's Network.* CDP events into `window.DevToolsAPI.dispatchMessage`
-        // here so the native Network tab renders them (falls back to the service-host
-        // console line when null / the API never appears). Cleared on detach.
-        ctx.networkForward?.setDevtoolsHost(devtoolsWc);
-        // Elements forwarding (production, always on for the native simulator): route
-        // the front-end's Elements-panel CDP traffic (DOM/CSS/Overlay/DOMSnapshot/
-        // DOMDebugger) onto the ACTIVE RENDER GUEST so the panel reflects the page's
-        // live DOM tree instead of the service host it natively inspects. Reuses the
-        // safe-area-attached debugger session (never detaches one it doesn't own);
-        // Emulation.* and every other domain stay on the service-host path. Degrades
-        // to the native service-host DOM if the front-end hook is unavailable. The
-        // disposer is stopped on detach / host destroyed.
-        if (ctx.bridge) {
-            try {
-                stopElementsForward?.();
-            }
-            catch { /* prior disposer already gone */ }
-            // Capture THIS instance's disposer in the destroy handler — NOT the mutable
-            // `stopElementsForward`. A respawn creates a new simulatorView whose old
-            // devtools host wc is destroyed AFTER the new instance is already installed;
-            // a handler closing over `stopElementsForward` would then dispose the CURRENT
-            // instance (its reconcile loop never gets to install the hook, so Elements
-            // falls back to the natively-inspected service host). Stop only this wc's own
-            // forward, and clear the module pointer only while it still points here.
-            const thisForward = installElementsForward({ devtoolsWc, bridge: ctx.bridge, connections: ctx.connections });
-            stopElementsForward = thisForward;
-            devtoolsWc.once('destroyed', () => {
-                try {
-                    thisForward();
-                }
-                catch { /* already stopped */ }
-                if (stopElementsForward === thisForward)
-                    stopElementsForward = null;
-            });
-        }
-        devtoolsWc.once('dom-ready', () => {
-            devtoolsWc.executeJavaScript(`
-        (function() {
-          try { localStorage.setItem('panel-selectedTab', '"console"') } catch {}
-          let tries = 0
-          const timer = setInterval(() => {
-            tries++
-            try {
-              const UI = globalThis.UI
-              const vm = UI && UI.ViewManager && typeof UI.ViewManager.instance === 'function'
-                ? UI.ViewManager.instance()
-                : null
-              if (vm && typeof vm.showView === 'function') {
-                vm.showView('console')
-                clearInterval(timer)
-                return
-              }
-            } catch {}
-            if (tries > 80) clearInterval(timer)
-          }, 50)
-        })()
-      `).catch(() => { });
-        });
-        // Anchor-only mount: the renderer's published rect is the SOLE authority.
-        // If a non-zero rect was already published (it can land before this attach
-        // on the project-open ordering), replay it; otherwise the view stays
-        // unadded and unsized until the first publish arrives. No static-layout
-        // fallback — an attach-time computed rect raced the precise anchor rect
-        // and flashed the overlay at the wrong rectangle.
-        // The view now exists: re-run the reconciler so a placement published before
-        // this attach (project-open ordering) attaches it once the gate re-opens.
-        reconcileNow();
-        if (ctx.bridge?.isNativeHost()) {
-            unsubscribeNativeRenderEvents = ctx.bridge.onRenderEvent(onNativeRenderEvent);
-            followNativeDevtoolsServiceHost();
-        }
-    }
-    /**
-     * Remove the custom-apis bridge `ipcMain.on` listener, if any. Idempotent.
-     */
-    function detachNativeCustomApiBridge() {
-        if (nativeCustomApiBridgeHandler) {
-            ipcMain.removeListener(SimulatorCustomApiBridgeChannel.Request, nativeCustomApiBridgeHandler);
-            nativeCustomApiBridgeHandler = null;
-        }
-    }
-    /**
-     * 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;
-        // The view is gone: gateReadiness now hides it, so reconcile detaches it.
-        reconcileNow();
-    }
-    /**
-     * 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;
-                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.
-            followNativeDevtoolsServiceHost();
-        });
-        // 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.
-        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.)
-        attachNativeSimulatorDevtoolsHost();
-        return ready;
-    }
-    function detachSimulator() {
-        settleNativeSimulatorReady?.();
-        settleNativeSimulatorReady = null;
-        stopFollowingNativeServiceHost();
-        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.
-        try {
-            stopElementsForward?.();
-        }
-        catch { /* already stopped */ }
-        stopElementsForward = null;
-        // 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');
-        hidePopover();
-        // Drop the settings view too — the previous detachAllViews() did.
-        destroyViewInternal(settingsView);
-        settingsView = null;
-        destroyViewInternal(simulatorView);
-        simulatorView = null;
-        simulatorViewAdded = false;
-        simulatorWebContentsId = null;
-        nativeSimulatorProjectPath = null;
-    }
-    // Remove (but do not destroy) the DevTools overlay from the contentView.
-    // Internal teardown helper for re-attach; user-facing visibility is the
-    // anchor 0×0 single path (`setSimulatorDevtoolsBounds`).
-    function removeSimulatorDevtoolsView() {
-        if (simulatorView && simulatorViewAdded) {
-            try {
-                ctx.windows.mainWindow.contentView.removeChildView(simulatorView);
-            }
-            catch (e) {
-                console.error('[workbench] removeSimulatorDevtoolsView error', e);
-            }
-            simulatorViewAdded = false;
-        }
-    }
-    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() {
-        overlayDesired.delete(VIEW_ID.settings);
-        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;
-        overlayDesired.delete(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.
-        destroyViewInternal(popoverView);
-        popoverView = null;
-        reconcileNow();
-        ctx.notify.popoverClosed();
-    }
-    function repositionAll() {
-        // Simulator + DevTools overlay: bounds owned by the renderer's anchor
-        // publishes; their ResizeObserver/window-resize listeners re-measure, so
-        // no static re-apply here.
-        if (overlayDesired.has(VIEW_ID.settings))
-            applySettingsBounds();
-        if (overlayDesired.has(VIEW_ID.popover))
-            applyPopoverBounds();
+    // hostToolbar and the overlay panels form a height cycle: the toolbar height
+    // offsets the overlays' top edge, and a toolbar height change re-applies the
+    // present overlays. The toolbar receives a thunk into the (hoisted) function
+    // declaration below so the reference resolves at runtime — after the overlay
+    // panels exist — while both domains stay plain const bindings.
+    const hostToolbar = createHostToolbarView(ctx, reconciler, {
+        reapplyPresentOverlays: () => reapplyToolbarDependentOverlays(),
+    });
+    const overlayPanels = createOverlayPanelsView(ctx, reconciler, {
+        getHostToolbarHeight: hostToolbar.getHostToolbarHeight,
+    });
+    const nativeSimulator = createNativeSimulatorView(ctx, reconciler, {
+        safeArea,
+        devtoolsHost,
+        overlayPanels,
+    });
+    function reapplyToolbarDependentOverlays() {
+        overlayPanels.reapplyPresentOverlays();
     }
     function disposeAll() {
-        detachSimulator();
+        // Aggregate simulator detach first (native simulator + devtools host +
+        // settings/popover), then the workbench, the host toolbar, and the
+        // per-guest safe-area sessions.
+        nativeSimulator.detachSimulator();
         // Embedded workbench editor view (no-op when the host never opted in;
         // also removes the devtools-theme sync listener).
-        detachWorkbench();
-        // Narrow channel first: close the live MessagePort + sweep the onMessage
-        // registry, so a send() racing teardown reports false instead of posting
-        // into a wc that is about to be closed.
-        hostToolbarPort.dispose();
-        // Host-controllable toolbar view: removed from the contentView + its
-        // WebContents closed (the host's loaded content is torn down on app exit).
-        destroyViewInternal(hostToolbarView);
-        hostToolbarView = null;
-        hostToolbarViewAdded = false;
-        // Release this manager's reference on the shared defaultSession
-        // toolbar-runtime registration (only if it ever acquired one — a manager
-        // that never used the toolbar must not drive the shared count to zero).
-        // The LAST release unregisters; other coexisting managers keep theirs.
-        if (hostToolbarRuntimeAcquired) {
-            releaseHostToolbarSessionRuntime();
-            hostToolbarRuntimeAcquired = false;
-        }
+        workbench.detachWorkbench();
+        hostToolbar.dispose();
         safeArea.dispose();
     }
-    function resize(_simWidth) {
-        // Simulator + DevTools overlay bounds are owned solely by the renderer's
-        // anchor publishes — its ResizeObserver/window-resize listeners re-measure
-        // on this same resize. No static re-apply (it raced the precise rect).
-        if (overlayDesired.has(VIEW_ID.settings))
-            applySettingsBounds();
-    }
     return {
-        attachNativeSimulator,
-        detachSimulator,
+        attachNativeSimulator: nativeSimulator.attachNativeSimulator,
+        softReloadNativeSimulator: nativeSimulator.softReloadNativeSimulator,
+        detachSimulator: nativeSimulator.detachSimulator,
         reapplySafeArea: (device) => safeArea.reapplyAll(device),
-        showSettings,
-        hideSettings,
-        showPopover,
-        hidePopover,
-        repositionAll,
+        showSettings: overlayPanels.showSettings,
+        hideSettings: overlayPanels.hideSettings,
+        showPopover: overlayPanels.showPopover,
+        hidePopover: overlayPanels.hidePopover,
+        repositionAll: () => overlayPanels.reapplyPresentOverlays(),
         disposeAll,
-        getSimulatorWebContentsId: () => simulatorWebContentsId,
-        getSimulatorWebContents: () => {
-            if (simulatorWebContentsId == null)
-                return null;
-            const wc = webContents.fromId(simulatorWebContentsId);
-            return wc && !wc.isDestroyed() ? wc : null;
-        },
-        getSimulatorProjectPath: () => nativeSimulatorProjectPath,
-        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;
-        },
-        getHostToolbarWebContentsId: () => liveHostToolbarWebContents()?.id ?? null,
-        getHostToolbarHeight: () => hostToolbarLastHeight,
-        resize,
-        setPlacementSnapshot,
-        attachWorkbench,
-        setWorkbenchSource,
-        detachWorkbench,
-        openFileInWorkbench,
-        setHostToolbarHeight,
-        hostToolbar,
+        getSimulatorWebContentsId: nativeSimulator.getSimulatorWebContentsId,
+        getSimulatorWebContents: nativeSimulator.getSimulatorWebContents,
+        getSimulatorProjectPath: nativeSimulator.getSimulatorProjectPath,
+        getSettingsWebContents: overlayPanels.getSettingsWebContents,
+        getSettingsWebContentsId: overlayPanels.getSettingsWebContentsId,
+        getPopoverWebContentsId: overlayPanels.getPopoverWebContentsId,
+        getHostToolbarWebContentsId: hostToolbar.getHostToolbarWebContentsId,
+        getHostToolbarHeight: hostToolbar.getHostToolbarHeight,
+        resize: () => overlayPanels.applySettingsBoundsIfPresent(),
+        setPlacementSnapshot: reconciler.setPlacementSnapshot,
+        attachWorkbench: workbench.attachWorkbench,
+        setWorkbenchSource: workbench.setWorkbenchSource,
+        detachWorkbench: workbench.detachWorkbench,
+        openFileInWorkbench: workbench.openFileInWorkbench,
+        setHostToolbarHeight: hostToolbar.setHostToolbarHeight,
+        hostToolbar: hostToolbar.control,
     };
 }
 //# sourceMappingURL=view-manager.js.map