@dimina-kit/devtools 0.3.2-dev.20260611063505 → 0.4.0-dev.20260612025610

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

@@ -1,6 +1,6 @@
 import { ipcMain, shell, WebContentsView, webContents } from 'electron';
 import path from 'path';
-import { cjsSiblingPreloadPath, hostToolbarPreloadPath, mainPreloadPath } from '../../utils/paths.js';
+import { cjsSiblingPreloadPath, mainPreloadPath } from '../../utils/paths.js';
 import { applyNavigationHardening, handleWindowOpenExternal, } from '../../windows/navigation-hardening.js';
 import { SimulatorCustomApiBridgeChannel } from '../../../shared/ipc-channels.js';
 import { OPEN_IN_EDITOR_SCHEME, decodeOpenInEditorUrl, resourceUrlToProjectRelativePath, } from '../../../shared/open-in-editor.js';
@@ -9,9 +9,11 @@ import { buildCustomizeTabsScript } from './devtools-tabs.js';
 import { installElementsForward } from '../elements-forward/index.js';
 import * as layout from '../layout/index.js';
 import { handleCustomApiBridgeRequest, } from '../simulator/custom-apis.js';
-import { getDefaultTab } from '../workbench-context.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';
 /**
  * Build a ViewManager bound to the given context. The returned object is the
  * only component allowed to instantiate or add/remove overlay WebContentsViews.
@@ -20,9 +22,6 @@ import { parseRoute } from '../../../shared/simulator-route.js';
  * on the context object.
  */
 export function createViewManager(ctx) {
-    // Resolve once: full WorkbenchContext always provides headerHeight; partial
-    // test contexts may omit it, in which case fall back to the default 40.
-    const headerHeight = ctx.headerHeight ?? 40;
     // 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.
@@ -56,7 +55,6 @@ export function createViewManager(ctx) {
     let settingsView = null;
     let settingsViewAdded = false;
     let popoverView = null;
-    let lastSimWidth = 375;
     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
@@ -75,10 +73,10 @@ export function createViewManager(ctx) {
     let stopElementsForward = null;
     let nativeDevtoolsRetryTimer = null;
     let nativeDevtoolsRetryToken = 0;
-    // Renderer-driven overlay bounds for the simulator DevTools view. When
-    // non-null this takes precedence over the legacy layout computed from the
-    // window content size. A zero-area rectangle means "hide" — the overlay is
-    // removed from the contentView but its WebContents stays alive.
+    // Renderer-driven overlay bounds for the simulator DevTools view — the SOLE
+    // mount/geometry authority (no static-layout fallback). A zero-area
+    // rectangle means "hide" — the overlay is removed from the contentView but
+    // its WebContents stays alive.
     let simulatorBoundsOverride = null;
     // ── Host-controllable toolbar WebContentsView ───────────────────────────
     // A strip above the devtools header that the downstream host loads its own
@@ -88,6 +86,21 @@ export function createViewManager(ctx) {
     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';
+    // 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,
+    });
     // ── Internal helpers ────────────────────────────────────────────────────
     function destroyViewInternal(view) {
         if (!view)
@@ -105,16 +118,6 @@ export function createViewManager(ctx) {
         }
         catch { /* ignore */ }
     }
-    function applySimulatorBounds(simWidth) {
-        if (!simulatorView || ctx.windows.mainWindow.isDestroyed())
-            return;
-        if (simulatorBoundsOverride) {
-            simulatorView.setBounds(simulatorBoundsOverride);
-            return;
-        }
-        const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        simulatorView.setBounds(layout.computeSimulatorBounds(w, h, simWidth, headerHeight));
-    }
     // Renderer publishes width/height = 0 to mean "hide overlay" — the
     // surrounding React panel is unmounted/collapsed. We keep the cached
     // value (so future republishes win over legacy layout) but remove the
@@ -145,11 +148,23 @@ export function createViewManager(ctx) {
         simulatorView.setBounds(bounds);
     }
     // ── 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 && !hostToolbarView.webContents.isDestroyed()) {
+        if (hostToolbarView && liveHostToolbarWebContents()) {
             return hostToolbarView;
         }
         // Rebuilding after the host destroyed the underlying webContents: detach the
@@ -163,21 +178,36 @@ export function createViewManager(ctx) {
             catch { /* already removed */ }
             hostToolbarViewAdded = false;
         }
-        const view = new WebContentsView({
-            webPreferences: {
-                nodeIntegration: false,
-                contextIsolation: true,
-                sandbox: false,
-                // Default: the reverse size-advertiser preload that measures the host
-                // content's intrinsic height and posts it on the advertise channel so
-                // main reserves exactly that strip height (dynamic height via
-                // ViewAnchor). When the host-shell supplies its own toolbar preload
-                // (workbench config.toolbar.preloadPath), use that instead — the host
-                // owns the bridge and may install the advertiser itself.
-                preload: hostToolbarPreloadOverride ?? hostToolbarPreloadPath,
-            },
-        });
+        // 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).
@@ -200,7 +230,7 @@ export function createViewManager(ctx) {
         // WebContents (and the host's loaded content) alive. Do NOT create the
         // view just to immediately hide it.
         if (isHidden(bounds)) {
-            if (hostToolbarView && hostToolbarViewAdded && !hostToolbarView.webContents.isDestroyed()) {
+            if (hostToolbarView && hostToolbarViewAdded && liveHostToolbarWebContents()) {
                 try {
                     ctx.windows.mainWindow.contentView.removeChildView(hostToolbarView);
                 }
@@ -219,6 +249,12 @@ export function createViewManager(ctx) {
         view.setBounds(bounds);
     }
     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.
+        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 height is
         // not retained in main — the renderer placeholder is the single source of
@@ -242,37 +278,72 @@ export function createViewManager(ctx) {
     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() {
-            if (!hostToolbarView)
-                return null;
-            if (hostToolbarView.webContents.isDestroyed())
-                return null;
-            return hostToolbarView.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.
+                ctx.notify.hostToolbarHeightChanged(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.
+        },
+        onMessage(channel, handler) {
+            return hostToolbarPort.onMessage(channel, handler);
+        },
+        onReady(handler) {
+            return hostToolbarPort.onReady(handler);
+        },
+        send(channel, payload) {
+            return hostToolbarPort.send(channel, payload);
+        },
     };
     function applySettingsBounds() {
         if (!settingsView || ctx.windows.mainWindow.isDestroyed())
             return;
         const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        settingsView.setBounds(layout.computeSettingsBounds(w, h, headerHeight));
+        settingsView.setBounds(layout.computeSettingsBounds(w, h, HEADER_H));
     }
     function applyPopoverBounds() {
         if (!popoverView || ctx.windows.mainWindow.isDestroyed())
             return;
         const [w = 0, h = 0] = ctx.windows.mainWindow.getContentSize();
-        popoverView.setBounds(layout.computePopoverBounds(w, h, headerHeight));
+        popoverView.setBounds(layout.computePopoverBounds(w, h, HEADER_H));
     }
     function clearNativeDevtoolsRetry() {
         nativeDevtoolsRetryToken++;
@@ -511,84 +582,11 @@ export function createViewManager(ctx) {
         followNativeDevtoolsServiceHost(event.appId);
     }
     // ── ViewManager methods ─────────────────────────────────────────────────
-    function attachSimulator(simWcId, simWidth) {
-        const sim = webContents.fromId(simWcId);
-        if (!sim) {
-            console.error('[workbench] attachSimulator — simWc not found for id', simWcId);
-            return;
-        }
-        lastSimWidth = simWidth;
-        simulatorWebContentsId = simWcId;
-        // Destroy old simulatorView to prevent WebContentsView leak
-        if (simulatorView) {
-            hideSimulator();
-            try {
-                if (!simulatorView.webContents.isDestroyed()) {
-                    simulatorView.webContents.close();
-                }
-            }
-            catch { /* ignore */ }
-            simulatorView = null;
-        }
-        simulatorView = new WebContentsView();
-        sim.setDevToolsWebContents(simulatorView.webContents);
-        // Embedded in the right-panel host view; never bring it to the foreground
-        // (would steal focus from the user / disrupt e2e).
-        sim.openDevTools({ mode: 'detach', activate: false });
-        // 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;
-        // Keep only Elements/Console/Network tabs (front-most, in that order).
-        customizeDevtoolsTabs(devtoolsWc);
-        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(() => { });
-        });
-        if (getDefaultTab(ctx) === 'simulator') {
-            if (simulatorBoundsOverride) {
-                if (!isHidden(simulatorBoundsOverride)) {
-                    ctx.windows.mainWindow.contentView.addChildView(simulatorView);
-                    simulatorViewAdded = true;
-                    simulatorView.setBounds(simulatorBoundsOverride);
-                }
-            }
-            else {
-                ctx.windows.mainWindow.contentView.addChildView(simulatorView);
-                simulatorViewAdded = true;
-                applySimulatorBounds(simWidth);
-            }
-        }
-    }
-    function attachNativeSimulatorDevtoolsHost(simWidth) {
+    function attachNativeSimulatorDevtoolsHost() {
         stopFollowingNativeServiceHost();
         // Destroy old simulatorView to prevent WebContentsView leak
         if (simulatorView) {
-            hideSimulator();
+            removeSimulatorDevtoolsView();
             try {
                 if (!simulatorView.webContents.isDestroyed()) {
                     simulatorView.webContents.close();
@@ -657,19 +655,16 @@ export function createViewManager(ctx) {
         })()
       `).catch(() => { });
         });
-        if (getDefaultTab(ctx) === 'simulator') {
-            if (simulatorBoundsOverride) {
-                if (!isHidden(simulatorBoundsOverride)) {
-                    ctx.windows.mainWindow.contentView.addChildView(simulatorView);
-                    simulatorViewAdded = true;
-                    simulatorView.setBounds(simulatorBoundsOverride);
-                }
-            }
-            else {
-                ctx.windows.mainWindow.contentView.addChildView(simulatorView);
-                simulatorViewAdded = true;
-                applySimulatorBounds(simWidth);
-            }
+        // 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.
+        if (simulatorBoundsOverride && !isHidden(simulatorBoundsOverride)) {
+            ctx.windows.mainWindow.contentView.addChildView(simulatorView);
+            simulatorViewAdded = true;
+            simulatorView.setBounds(simulatorBoundsOverride);
         }
         if (ctx.bridge?.isNativeHost()) {
             unsubscribeNativeRenderEvents = ctx.bridge.onRenderEvent(onNativeRenderEvent);
@@ -738,12 +733,11 @@ export function createViewManager(ctx) {
         // the defensive re-attach path calling it directly remains safe.
         ctx.connections.acquire(simWc).own(detachNativeCustomApiBridge);
     }
-    function attachNativeSimulator(simulatorUrl, simWidth) {
+    function attachNativeSimulator(simulatorUrl, _simWidth) {
         if (!ctx.preloadPath) {
             console.error('[workbench] attachNativeSimulator — preloadPath unset; cannot mount native simulator');
             return;
         }
-        lastSimWidth = simWidth;
         // Tear down any previous native simulator view (relaunch / re-open).
         if (nativeSimulatorView) {
             detachNativeCustomApiBridge();
@@ -901,7 +895,7 @@ export function createViewManager(ctx) {
         // 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(simWidth);
+        attachNativeSimulatorDevtoolsHost();
     }
     function detachSimulator() {
         stopFollowingNativeServiceHost();
@@ -955,23 +949,16 @@ export function createViewManager(ctx) {
         // session must not be replayed onto a fresh re-attach (stale slice/offset).
         lastRendererRect = null;
     }
-    function showSimulator(simWidth) {
-        lastSimWidth = simWidth;
-        if (!simulatorView)
-            return;
-        if (!simulatorViewAdded) {
-            ctx.windows.mainWindow.contentView.addChildView(simulatorView);
-            simulatorViewAdded = true;
-        }
-        applySimulatorBounds(simWidth);
-    }
-    function hideSimulator() {
+    // 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] hideSimulator error', e);
+                console.error('[workbench] removeSimulatorDevtoolsView error', e);
             }
             simulatorViewAdded = false;
         }
@@ -1035,10 +1022,9 @@ export function createViewManager(ctx) {
         }
     }
     function repositionAll() {
-        // Native simulator: bounds owned by the renderer's reportBounds (Model A);
-        // its window-resize listener re-measures, so no coarse re-apply here.
-        if (simulatorView && simulatorViewAdded)
-            applySimulatorBounds(lastSimWidth);
+        // 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 (settingsView && settingsViewAdded)
             applySettingsBounds();
         if (popoverView)
@@ -1046,11 +1032,23 @@ export function createViewManager(ctx) {
     }
     function disposeAll() {
         detachSimulator();
+        // 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;
+        }
         safeArea.dispose();
     }
     function setNativeSimulatorViewBounds(params) {
@@ -1102,34 +1100,17 @@ export function createViewManager(ctx) {
         }
         catch { /* hostWebContents unavailable; guests get zoom on attach */ }
     }
-    function resize(simWidth) {
-        lastSimWidth = simWidth;
-        // Native simulator bounds are owned solely by the renderer's reportBounds
-        // (Model A) — its ResizeObserver/window-resize listeners re-measure on this
-        // same resize. No coarse panel-size re-apply here (it raced the precise rect).
-        if (simulatorViewAdded)
-            applySimulatorBounds(simWidth);
+    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 (settingsViewAdded)
             applySettingsBounds();
     }
-    function setVisible(visible, simWidth) {
-        lastSimWidth = simWidth;
-        if (!simulatorView)
-            return;
-        if (visible && !simulatorViewAdded) {
-            showSimulator(simWidth);
-        }
-        else if (!visible) {
-            hideSimulator();
-        }
-    }
     return {
-        attachSimulator,
         attachNativeSimulator,
         detachSimulator,
         reapplySafeArea: (device) => safeArea.reapplyAll(device),
-        showSimulator,
-        hideSimulator,
         showSettings,
         hideSettings,
         showPopover,
@@ -1143,9 +1124,6 @@ export function createViewManager(ctx) {
             const wc = webContents.fromId(simulatorWebContentsId);
             return wc && !wc.isDestroyed() ? wc : null;
         },
-        getLastSimWidth: () => lastSimWidth,
-        isSimulatorAdded: () => simulatorViewAdded,
-        hasSimulatorView: () => simulatorView !== null,
         getSettingsWebContents: () => {
             if (!settingsView)
                 return null;
@@ -1167,16 +1145,9 @@ export function createViewManager(ctx) {
                 return null;
             return popoverView.webContents.id;
         },
-        getHostToolbarWebContentsId: () => {
-            if (!hostToolbarView)
-                return null;
-            if (hostToolbarView.webContents.isDestroyed())
-                return null;
-            return hostToolbarView.webContents.id;
-        },
+        getHostToolbarWebContentsId: () => liveHostToolbarWebContents()?.id ?? null,
         setNativeSimulatorViewBounds,
         resize,
-        setVisible,
         setSimulatorDevtoolsBounds,
         setHostToolbarBounds,
         setHostToolbarHeight,

package/dist/main/services/workbench-context.d.ts

@@ -12,10 +12,9 @@ import { type ViewManager } from './views/view-manager.js';
 import { type WindowService } from './window-service.js';
 import { type WorkspaceService } from './workspace/workspace-service.js';
 import { type SimulatorApiRegistry } from './simulator/custom-apis.js';
-import { type ToolbarStore } from './toolbar/toolbar-store.js';
 import { sanitizeTemplates } from './projects/templates.js';
 import type { ProjectsProvider, ProjectTemplate } from './projects/types.js';
-import type { BeforeOpenProjectResult, CustomCreateProjectDialogResult } from '../../shared/types.js';
+import type { CustomCreateProjectDialogResult } from '../../shared/types.js';
 /**
  * Shared mutable state for the workbench application.
  * Passed to each IPC module so they can read/write shared state without closures.
@@ -26,14 +25,10 @@ export interface WorkbenchContext {
     preloadPath: string;
     /** Absolute path to the renderer dist directory */
     rendererDir: string;
-    /** Built-in panel IDs to display (default: all) */
-    panels: string[];
     /** Custom API namespace names (e.g. ['qd']) passed to the simulator */
     apiNamespaces: string[];
     /** Branding name shown in title bar and getBranding IPC */
     appName: string;
-    /** Header bar height in px, used for view layout and exposed to the renderer */
-    headerHeight: number;
     /** Host-injected provider for branding info (overrides default appName) */
     brandingProvider?: () => Promise<{
         appName: string;
@@ -46,6 +41,13 @@ export interface WorkbenchContext {
     windows: WindowService;
     /** Unified main → renderer event dispatcher */
     notify: RendererNotifier;
+    /**
+     * Open (or re-focus) the standalone workbench-settings window. First-class
+     * member so contract holders (`MiniappRuntime` / `MenuContext`) can open
+     * settings without reaching into `windows`/`notify` plumbing. Wired by
+     * `createWorkbenchContext` to the real `openSettingsWindow` path.
+     */
+    openSettings: () => Promise<void>;
     /** Single source of truth for project + session + per-project settings */
     workspace: WorkspaceService;
     /**
@@ -72,11 +74,6 @@ export interface WorkbenchContext {
         parentWindow: BrowserWindow;
         templates: ProjectTemplate[];
     }) => Promise<CustomCreateProjectDialogResult>;
-    /**
-     * Optional host gate for opening projects. Runs after basic directory
-     * validation and before the current project session is closed.
-     */
-    beforeOpenProject?: (projectPath: string) => BeforeOpenProjectResult | Promise<BeforeOpenProjectResult>;
     /**
      * Trust predicate consulted by `IpcRegistry` for every incoming IPC.
      * Resolves the currently-trusted senders (main renderer + overlays)
@@ -99,12 +96,6 @@ export interface WorkbenchContext {
      * One registry per context — no process-global crosstalk.
      */
     simulatorApis: SimulatorApiRegistry;
-    /**
-     * Per-context store of host-registered toolbar actions. Populated via
-     * `instance.toolbar.set`; read by the toolbar IPC handlers. One store per
-     * context — no process-global crosstalk.
-     */
-    toolbar: ToolbarStore;
     /** Aggregates dispose handlers for every IPC handler, listener, watcher, and CDP session registered by the workbench. */
     registry: DisposableRegistry;
     /**
@@ -162,29 +153,27 @@ export interface WorkbenchContext {
      * run) and injects its raw Network.* CDP events into the DevTools FRONT-END wc
      * (`window.DevToolsAPI.dispatchMessage`) so the native Network tab renders them;
      * falls back to a `[网络]` service-host console line when the front-end is
-     * unavailable. The ViewManager calls `attachSimulator` + `setDevtoolsHost` from
-     * `attachNativeSimulator` once the simulator WCV + DevTools host exist.
-     * Undefined until bootstrap wires it.
+     * unavailable. The ViewManager calls the forwarder's own `attachSimulator` +
+     * `setDevtoolsHost` from `attachNativeSimulator` once the simulator WCV +
+     * DevTools host exist. Undefined until bootstrap wires it.
      */
     networkForward?: NetworkForwarder;
 }
 /**
  * Inputs for `createWorkbenchContext`. The scalar config fields it shares with
- * `WorkbenchConfig` (`adapter` / `apiNamespaces` / `appName` / `headerHeight`)
+ * `WorkbenchConfig` (`adapter` / `apiNamespaces` / `appName`)
  * are derived from there via `Pick` so the two stay in lockstep — no
  * field-by-field re-declaration. The remaining fields are kept explicit
  * because their shapes intentionally differ from the config:
  *  - `preloadPath` / `rendererDir` are REQUIRED here (the caller resolves the
  *    defaults before constructing the context) but optional in the config;
- *  - `panels` is the structural `string[]` (the context stores raw ids);
  *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` use
  *    the main-process types, not the structural mirrors in `shared/types`.
  */
-export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' | 'apiNamespaces' | 'appName' | 'headerHeight'> {
+export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' | 'apiNamespaces' | 'appName'> {
     mainWindow: BrowserWindow;
     preloadPath: string;
     rendererDir: string;
-    panels?: string[];
     brandingProvider?: WorkbenchContext['brandingProvider'];
     /** Host-supplied project list backend. Defaults to LocalProjectsProvider. */
     projectsProvider?: ProjectsProvider;
@@ -195,8 +184,6 @@ export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' |
     /** Host-supplied "新建项目" dialog hook. */
     customCreateProjectDialog?: WorkbenchContext['customCreateProjectDialog'];
 }
-export declare function hasBuiltinPanel(ctx: Pick<WorkbenchContext, 'panels'>, panelId: string): boolean;
-export declare function getDefaultTab(ctx: Pick<WorkbenchContext, 'panels'>): string;
 export declare function createWorkbenchContext(opts: CreateContextOptions): WorkbenchContext;
 export { sanitizeTemplates };
 //# sourceMappingURL=workbench-context.d.ts.map