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

package/dist/main/services/views/devtools-tabs.d.ts

@@ -35,10 +35,14 @@
  */
 /**
  * Canonical DevTools panel view ids kept in the DEFAULT tab bar (stable front-end
- * ids, unchanged for many Chromium releases): `elements`, `console`, `network`,
- * `sources`. Sources stays so a source-link click that isn't routed to Monaco
- * (build/runtime chunks, framework frames) still has a panel to reveal in instead
- * of silently no-op'ing.
+ * ids, unchanged for many Chromium releases): `elements`, `console`, `sources`,
+ * `network`. Sources stays so a source-link click NOT routed to Monaco (build/
+ * runtime chunks, framework frames) still has a panel to reveal in instead of
+ * silently no-op'ing. ORDERING NOTE: these stay in DevTools' DEFAULT visual
+ * order (Sources between Console and Network). We deliberately do NOT move
+ * Sources after Network: reordering the DOM nodes desyncs the front-end's
+ * click→panel mapping (it indexes tabs by child position), which made clicking
+ * Network activate Sources.
  */
 export declare const DEVTOOLS_KEPT_VIEW_IDS: readonly string[];
 /**
@@ -47,4 +51,20 @@ export declare const DEVTOOLS_KEPT_VIEW_IDS: readonly string[];
  * (never interpolated as bare code), same discipline as the other injectors.
  */
 export declare function buildCustomizeTabsScript(keptIds?: readonly string[]): string;
+/**
+ * Build the `executeJavaScript` source that forces the DevTools front-end to
+ * render its context menus as PAGE menus (soft menus) instead of asking the
+ * host via `showContextMenuAtPoint()`.
+ *
+ * The embedded DevTools front-end decides per-menu in `ContextMenu#show()`:
+ * `this.useSoftMenu || InspectorFrontendHostInstance.isHostedMode()`. On a
+ * self-built WebContentsView Electron leaves both false and does not answer
+ * `showContextMenuAtPoint()`, so right-click menus (复制为 cURL / Copy / …)
+ * never appear. Forcing the host-wide `isHostedMode()` true instead breaks the
+ * front-end's target data flow (Console/Network panels go empty), so we take
+ * the narrow path: patch the ContextMenu prototype so every menu shows as a
+ * page-rendered soft menu — same rendering the VS Code embedding uses, without
+ * touching the host-mode flag or any other front-end behaviour.
+ */
+export declare function buildDevtoolsSoftMenuScript(): string;
 //# sourceMappingURL=devtools-tabs.d.ts.map

package/dist/main/services/views/devtools-tabs.js

@@ -35,12 +35,16 @@
  */
 /**
  * Canonical DevTools panel view ids kept in the DEFAULT tab bar (stable front-end
- * ids, unchanged for many Chromium releases): `elements`, `console`, `network`,
- * `sources`. Sources stays so a source-link click that isn't routed to Monaco
- * (build/runtime chunks, framework frames) still has a panel to reveal in instead
- * of silently no-op'ing.
+ * ids, unchanged for many Chromium releases): `elements`, `console`, `sources`,
+ * `network`. Sources stays so a source-link click NOT routed to Monaco (build/
+ * runtime chunks, framework frames) still has a panel to reveal in instead of
+ * silently no-op'ing. ORDERING NOTE: these stay in DevTools' DEFAULT visual
+ * order (Sources between Console and Network). We deliberately do NOT move
+ * Sources after Network: reordering the DOM nodes desyncs the front-end's
+ * click→panel mapping (it indexes tabs by child position), which made clicking
+ * Network activate Sources.
  */
-export const DEVTOOLS_KEPT_VIEW_IDS = ['elements', 'console', 'network', 'sources'];
+export const DEVTOOLS_KEPT_VIEW_IDS = ['elements', 'console', 'sources', 'network'];
 /**
  * Build the `executeJavaScript` source injected into the DevTools front-end
  * WebContents. The kept ids + display names are carried as JSON data literals
@@ -50,20 +54,15 @@ export function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
     // Kept panels are matched by view id (registry path) and by visible NAME (DOM
     // fallback path); the DevTools UI may be EN or ZH, so include both.
     const NAME_MAP = {
-        elements: ['Elements', '元素'], console: ['Console', '控制台'], network: ['Network', '网络'],
-        sources: ['Sources', '来源', '源代码'],
+        elements: ['Elements', '元素'], console: ['Console', '控制台'],
+        sources: ['Sources', '来源', '源代码'], network: ['Network', '网络'],
     };
     const keepNames = keptIds.flatMap((id) => NAME_MAP[id] ?? [id]);
     const keepIdsJson = JSON.stringify(JSON.stringify([...keptIds]));
     const keepNamesJson = JSON.stringify(JSON.stringify(keepNames));
-    const srcNamesJson = JSON.stringify(JSON.stringify(NAME_MAP.sources));
-    const netNamesJson = JSON.stringify(JSON.stringify(NAME_MAP.network));
     return `(function(){try{
     var KEEPID = new Set(JSON.parse(${keepIdsJson}));
     var KEEPNAME = new Set(JSON.parse(${keepNamesJson}));
-    var SRCNAME = new Set(JSON.parse(${srcNamesJson}));
-    var NETNAME = new Set(JSON.parse(${netNamesJson}));
-    var WANT_SOURCES_LAST = KEEPID.has('sources');
     // (1) Locale infobar — official host-preference suppression (NOT localStorage).
     try { var IFH=globalThis.InspectorFrontendHost; if(IFH&&typeof IFH.setPreference==='function'){ IFH.setPreference('disable-locale-info-bar','true'); } }catch(_){}
     function deepCollect(sel,cap){ var out=[],seen=0,stack=[document]; while(stack.length&&seen<(cap||40000)){ var root=stack.pop(); try{var m=root.querySelectorAll?root.querySelectorAll(sel):[];for(var i=0;i<m.length;i++)out.push(m[i]);}catch(_){} try{var all=root.querySelectorAll?root.querySelectorAll('*'):[];for(var j=0;j<all.length;j++){seen++;if(all[j].shadowRoot)stack.push(all[j].shadowRoot);}}catch(_){} } return out; }
@@ -94,15 +93,6 @@ export function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
         if(!handled){ var FALL=['timeline','resources','heap-profiler','security','lighthouse','chrome-recorder','coverage','linear-memory-inspector','sensors','rendering','animations','autofill-view','medias','issues-pane']; for(var fr=0;fr<FALL.length;fr++){ try{ if(!KEEPID.has(FALL[fr])) maybeRemove(FALL[fr]); }catch(_){} } }
       } else { domFallback(); }
     })();
-    // Keep Sources LAST in the bar (after Network). Default DevTools order puts
-    // Sources between Console and Network; nudge it to just after Network. Runs in
-    // BOTH paths (registry removal leaves the kept tabs in default order). Self-
-    // stable: once Sources follows Network the condition no longer holds.
-    if(WANT_SOURCES_LAST){ var ro=0,rt=setInterval(function(){ ro++; try{
-      var tabs=deepCollect('[role="tab"]'),src=null,net=null;
-      for(var i=0;i<tabs.length;i++){ var n=txt(tabs[i]); if(SRCNAME.has(n))src=tabs[i]; else if(NETNAME.has(n))net=tabs[i]; }
-      if(src&&net&&src.parentElement&&src.parentElement===net.parentElement&&(src.compareDocumentPosition(net)&Node.DOCUMENT_POSITION_FOLLOWING)){ net.parentElement.insertBefore(src,net.nextSibling); }
-    }catch(_){} if(ro>120)clearInterval(rt); },60); }
     // DOM fallback: only if the ESM module couldn't be resolved at all.
     function domFallback(){ var cachedBar=null;
       function findBar(){ if(cachedBar&&cachedBar.isConnected)return cachedBar; cachedBar=null; var tabs=deepCollect('[role="tab"]'); var a=null; for(var i=0;i<tabs.length;i++){if(KEEPNAME.has(txt(tabs[i]))){a=tabs[i];break;}} if(!a)return null; var p=a.parentElement; while(p){try{if(p.querySelectorAll('[role="tab"]').length>1){cachedBar=p;return p;}}catch(_){} p=p.parentElement;} cachedBar=a.parentElement; return cachedBar; }
@@ -110,4 +100,33 @@ export function buildCustomizeTabsScript(keptIds = DEVTOOLS_KEPT_VIEW_IDS) {
       var tr=0,t=setInterval(function(){tr++;try{apply();}catch(_){}if(tr>120)clearInterval(t);},60); try{apply();}catch(_){} }
   }catch(_){}})()`;
 }
+/**
+ * Build the `executeJavaScript` source that forces the DevTools front-end to
+ * render its context menus as PAGE menus (soft menus) instead of asking the
+ * host via `showContextMenuAtPoint()`.
+ *
+ * The embedded DevTools front-end decides per-menu in `ContextMenu#show()`:
+ * `this.useSoftMenu || InspectorFrontendHostInstance.isHostedMode()`. On a
+ * self-built WebContentsView Electron leaves both false and does not answer
+ * `showContextMenuAtPoint()`, so right-click menus (复制为 cURL / Copy / …)
+ * never appear. Forcing the host-wide `isHostedMode()` true instead breaks the
+ * front-end's target data flow (Console/Network panels go empty), so we take
+ * the narrow path: patch the ContextMenu prototype so every menu shows as a
+ * page-rendered soft menu — same rendering the VS Code embedding uses, without
+ * touching the host-mode flag or any other front-end behaviour.
+ */
+export function buildDevtoolsSoftMenuScript() {
+    return `(function(){
+    try {
+      var C = globalThis.EUI && globalThis.EUI.ContextMenu && globalThis.EUI.ContextMenu.ContextMenu;
+      if (C && C.prototype && typeof C.prototype.show === 'function') {
+        var origShow = C.prototype.show;
+        C.prototype.show = function() {
+          this.useSoftMenu = true;
+          return origShow.apply(this, arguments);
+        };
+      }
+    } catch (_) {}
+  })()`;
+}
 //# sourceMappingURL=devtools-tabs.js.map

package/dist/main/services/views/host-toolbar-view.js

@@ -4,11 +4,9 @@ import { HOST_TOOLBAR_RUNTIME_MARKER } from '../../../shared/constants.js';
 import { VIEW_ID, VIEW_LAYER } from '../../../shared/view-ids.js';
 import { acquireHostToolbarSessionRuntime, releaseHostToolbarSessionRuntime, } from './host-toolbar-session-runtime.js';
 import { createHostToolbarPortChannel } from './host-toolbar-port-channel.js';
-import { destroyChildView } from './destroy-child-view.js';
 export function createHostToolbarView(ctx, reconciler, deps) {
     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,
@@ -50,20 +48,11 @@ export function createHostToolbarView(ctx, reconciler, deps) {
         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;
+        // Rebuilding after the host destroyed the underlying webContents first
+        // retires the concrete instance from the native-tree ledger.
+        if (hostToolbarView) {
+            reconciler.destroyView(VIEW_ID.hostToolbar, hostToolbarView);
         }
-        // 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).
-        reconciler.forgetActual(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
@@ -213,7 +202,6 @@ export function createHostToolbarView(ctx, reconciler, deps) {
     reconciler.registerView(VIEW_ID.hostToolbar, {
         getView: () => hostToolbarView,
         ensureView: () => ensureHostToolbarView(),
-        setAdded: (added) => { hostToolbarViewAdded = added; },
         ensureLazy: (desired) => {
             if (desired?.placement.visible && !liveHostToolbarWebContents())
                 ensureHostToolbarView();
@@ -226,9 +214,8 @@ export function createHostToolbarView(ctx, reconciler, deps) {
         hostToolbarPort.dispose();
         // Host-controllable toolbar view: removed from the contentView + its
         // WebContents closed (the host's loaded content is torn down on app exit).
-        destroyChildView(ctx.windows.mainWindow, hostToolbarView);
+        reconciler.destroyView(VIEW_ID.hostToolbar, 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).

package/dist/main/services/views/native-simulator-devtools-host.js

@@ -1,13 +1,13 @@
 import { WebContentsView, webContents as electronWebContents } from 'electron';
 import { buildDevtoolsProjectSourceLinksScript, decodeOpenInEditorUrl, projectSourceContextFromServiceHostUrl, } from '../../../shared/open-in-editor.js';
-import { buildCustomizeTabsScript } from './devtools-tabs.js';
-import { buildConsoleFilterScript, buildLiveConsoleFilterScript } from './console-filter.js';
+import { buildCustomizeTabsScript, buildDevtoolsSoftMenuScript } from './devtools-tabs.js';
+import { buildInternalLogHideScript } from './console-filter.js';
+import { buildClearConsoleFilterScript } from './clear-console-filter.js';
 import { whenFrontendBootstrapped } from './frontend-bootstrap-gate.js';
 import { installElementsForward } from '../elements-forward/index.js';
 import { installServiceConsoleForward } from '../service-console/index.js';
 import { VIEW_ID } from '../../../shared/view-ids.js';
 import { resolveProjectEditorTarget } from './resolve-project-editor-target.js';
-import { destroyChildView } from './destroy-child-view.js';
 import { createLoadDeferredInjector } from './inject-when-ready.js';
 // `webContents.executeJavaScript()` registers a transient `did-stop-loading`
 // listener on the target wc whenever that wc is still loading (Electron's
@@ -39,7 +39,6 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
     // The right-panel Chrome DevTools front-end HOST WebContentsView. Created by
     // rebuildDevtoolsHostView; positioned by the renderer's simulatorDevtools anchor.
     let simulatorView = null;
-    let simulatorViewAdded = false;
     // 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`,
@@ -67,6 +66,14 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
     let stopServiceConsole = null;
     let nativeDevtoolsRetryTimer = null;
     let nativeDevtoolsRetryToken = 0;
+    // When the NEXT host build happens it is a FRESH PROJECT OPEN, so the stale
+    // Console filter (DevTools' own persisted localStorage setting, possibly
+    // leftover from the old filter-box implementation) must be cleared once.
+    // Armed by `attach()` (the project-open path) and disarmed by every re-point,
+    // so a service-host pool swap (hot-reload respawn) rebuilds the host WITHOUT
+    // wiping a filter the developer typed during the session. See
+    // clear-console-filter.ts.
+    let clearFilterOnNextHostBuild = false;
     // Front-end injects re-fire on EVERY re-point; while the host is loading each
     // raw executeJavaScript would queue one did-stop-loading waiter per call.
     // The deferred injector keeps one hook per (wc, kind) with latest-wins.
@@ -172,11 +179,10 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
     // framework internal log lines from THIS right-panel Console — the
     // standalone internal DevTools window (native-only, wired elsewhere) shows
     // them unfiltered. Re-applied on every re-point, same policy as
-    // customizeDevtoolsTabs. Runs BOTH the persisted-preference write (for a
-    // not-yet-constructed panel) AND the live-object drive (for a panel that's
-    // already constructed by the time this injection lands, or finishes
-    // constructing shortly after — see console-filter.ts's header comment for
-    // why the persisted write alone cannot cover that case).
+    // customizeDevtoolsTabs (the injected script wraps once and is idempotent
+    // across re-points). Drives the panel's own visibility judge rather than
+    // its text-filter box, so the developer's filter input stays empty and
+    // entirely theirs — see console-filter.ts's header comment.
     // Bootstrap-gated: the live script touches `Console.ConsoleView.instance()`,
     // which — fired before the front-end's own bootstrap completes —
     // constructs IssuesManager early and permanently kills that bootstrap (see
@@ -191,8 +197,7 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
                     if (!ready || devtoolsWc.isDestroyed())
                         return;
                     try {
-                        void devtoolsWc.executeJavaScript(buildConsoleFilterScript()).catch(() => { });
-                        void devtoolsWc.executeJavaScript(buildLiveConsoleFilterScript()).catch(() => { });
+                        void devtoolsWc.executeJavaScript(buildInternalLogHideScript()).catch(() => { });
                     }
                     catch { /* wc torn down mid-call */ }
                 });
@@ -254,6 +259,9 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
     function pointNativeDevtoolsAtServiceWc(next) {
         if (!simulatorView || simulatorView.webContents.isDestroyed())
             return true;
+        // Any host rebuild triggered from a re-point is a service-host swap, NOT a
+        // fresh project open — the stale Console filter must survive it.
+        clearFilterOnNextHostBuild = false;
         if (nativeDevtoolsSourceWc?.id === next.id && !nativeDevtoolsSourceWc.isDestroyed()) {
             return true;
         }
@@ -432,15 +440,9 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
     // service-host pool swap must repoint onto a fresh host, not reuse the
     // already-navigated one).
     function rebuildDevtoolsHostView() {
-        // Destroy old simulatorView to prevent WebContentsView leak
+        // Destroy the previous host through the native-tree owner before replacing it.
         if (simulatorView) {
-            removeSimulatorDevtoolsView();
-            try {
-                if (!simulatorView.webContents.isDestroyed()) {
-                    simulatorView.webContents.close();
-                }
-            }
-            catch { /* ignore */ }
+            reconciler.destroyView(VIEW_ID.simulatorDevtools, simulatorView);
             simulatorView = null;
         }
         simulatorView = new WebContentsView();
@@ -464,6 +466,27 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
         // queue a pending `did-stop-loading` waiter while the front-end is still
         // loading (see raiseExecuteJavaScriptListenerCeiling).
         raiseExecuteJavaScriptListenerCeiling(devtoolsWc);
+        // The embedded Chrome DevTools front-end renders its context menus ONLY
+        // when the host reports “hosted mode” (page-rendered soft menus — the
+        // VS Code / Web-embedding path). Electron's own devtools:// host injection
+        // leaves `isHostedMode()` false and does not handle
+        // `showContextMenuAtPoint()` for a SELF-BUILT WebContentsView, so
+        // right-click menus (复制为 cURL / Copy / …) never appear — the front-end
+        // asks the host for a menu and nobody answers. Force hosted mode so the
+        // front-end draws its native page menus itself. Re-injected on every
+        // The embedded DevTools front-end asks the host for its context menus via
+        // `showContextMenuAtPoint()` (Electron leaves it unhandled on a self-built
+        // WCV), so right-click menus never appear. Force page-rendered soft menus
+        // via a narrow ContextMenu#show patch (NOT the host-wide isHostedMode()
+        // flag — that one breaks the front-end's target data flow, emptying the
+        // Console/Network panels). Needs the front-end bootstrap for EUI to exist.
+        injectWhenReady(devtoolsWc, 'soft-menu', () => {
+            void whenFrontendBootstrapped(devtoolsWc).then((ready) => {
+                if (!ready || devtoolsWc.isDestroyed())
+                    return;
+                devtoolsWc.executeJavaScript(buildDevtoolsSoftMenuScript()).catch(() => { });
+            });
+        });
         // 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
@@ -529,6 +552,23 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
         `).catch(() => { });
             });
         });
+        // Clear the stale Console filter box on a FRESH project open only (armed by
+        // attach(), disarmed by re-points — see clearFilterOnNextHostBuild). The
+        // value is captured at build time so a later swap cannot re-arm/clear this
+        // host; bootstrap-gated the same way as the console-default inject above.
+        const clearStaleFilter = clearFilterOnNextHostBuild;
+        injectWhenReady(devtoolsWc, 'clear-console-filter', () => {
+            if (!clearStaleFilter)
+                return;
+            void whenFrontendBootstrapped(devtoolsWc).then((ready) => {
+                if (!ready || devtoolsWc.isDestroyed())
+                    return;
+                try {
+                    void devtoolsWc.executeJavaScript(buildClearConsoleFilterScript()).catch(() => { });
+                }
+                catch { /* wc torn down mid-call */ }
+            });
+        });
         // 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
@@ -543,6 +583,10 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
         devtoolsHostUsed = false;
     }
     function attachNativeSimulatorDevtoolsHost() {
+        // This host build is a FRESH PROJECT OPEN: clear the stale Console filter
+        // once (see clearFilterOnNextHostBuild / clear-console-filter.ts). A later
+        // re-point (service-host pool swap) disarms it before ITS rebuild.
+        clearFilterOnNextHostBuild = true;
         stopFollowingNativeServiceHost();
         rebuildDevtoolsHostView();
         if (ctx.bridge?.isNativeHost()) {
@@ -551,32 +595,8 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
             followNativeDevtoolsServiceHost();
         }
     }
-    // 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;
-        }
-        // The instance is being replaced/destroyed — forget its reconciled mount
-        // state so the next rebuilt host is treated as a fresh attach. Without this,
-        // the level-triggered reconciler still records `simulatorDevtools` as
-        // `attached` (the manual removeChildView above bypasses it), so it never
-        // emits the `attach` op for the rebuilt view and the new host is never
-        // addChildView'd — embedded but invisible. Mirrors the hostToolbar /
-        // simulator instance-replacement handling (ensureHostToolbarView /
-        // tearDownNativeSimulatorView).
-        reconciler.forgetActual(VIEW_ID.simulatorDevtools);
-    }
     reconciler.registerView(VIEW_ID.simulatorDevtools, {
         getView: () => simulatorView,
-        setAdded: (added) => { simulatorViewAdded = added; },
         gateHidden: () => !simulatorView,
     });
     return {
@@ -594,9 +614,8 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
             stopElementsForward = null;
         },
         destroyHostView: () => {
-            destroyChildView(ctx.windows.mainWindow, simulatorView);
+            reconciler.destroyView(VIEW_ID.simulatorDevtools, simulatorView);
             simulatorView = null;
-            simulatorViewAdded = false;
         },
     };
 }

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

@@ -13,7 +13,6 @@ import { VIEW_ID } from '../../../shared/view-ids.js';
 export function createNativeSimulatorView(ctx, reconciler, deps) {
     const { safeArea, devtoolsHost, overlayPanels } = deps;
     let nativeSimulatorView = null;
-    let nativeSimulatorViewAdded = false;
     let nativeSimulatorProjectPath = null;
     let settleNativeSimulatorReady = null;
     // Whether the CURRENT simulator view's shell finished its first boot (first
@@ -68,36 +67,20 @@ export function createNativeSimulatorView(ctx, reconciler, deps) {
      * double-dispose. `label` only tags the diagnostic on the async-tail failure.
      */
     function tearDownNativeSimulatorView(label) {
-        if (!nativeSimulatorView)
+        const view = nativeSimulatorView;
+        if (!view)
             return;
-        ctx.simulatorUiExtensions?.detach(nativeSimulatorView.webContents);
-        if (nativeSimulatorViewAdded && !ctx.windows.mainWindow.isDestroyed()) {
-            try {
-                ctx.windows.mainWindow.contentView.removeChildView(nativeSimulatorView);
-            }
-            catch { /* already removed */ }
-        }
+        ctx.simulatorUiExtensions?.detach(view.webContents);
         try {
-            if (!nativeSimulatorView.webContents.isDestroyed()) {
-                ctx.bridge?.disposeSessionsForSimulator?.(nativeSimulatorView.webContents.id)
+            if (!view.webContents.isDestroyed()) {
+                ctx.bridge?.disposeSessionsForSimulator?.(view.webContents.id)
                     ?.catch((err) => console.warn(`[view-manager] dispose sessions (${label}) failed:`, err));
-                nativeSimulatorView.webContents.close();
             }
         }
         catch { /* ignore */ }
+        reconciler.destroyView(VIEW_ID.simulator, view);
         nativeSimulatorView = null;
-        nativeSimulatorViewAdded = false;
         nativeSimulatorShellReady = false;
-        // The instance is being replaced/destroyed — forget its reconciled mount
-        // state so the NEXT rebuilt view is treated as a fresh attach. Without this,
-        // the level-triggered reconciler still records `simulator` as `attached`
-        // (the manual removeChildView above bypasses it), so the next reconcile
-        // classifies the freshly-built WebContentsView as already-attached, never
-        // emits the `attach` op, and the new view is never addChildView'd — a sticky
-        // 100%-invisible simulator after every recompile. Mirrors the hostToolbar
-        // instance-replacement handling in ensureHostToolbarView.
-        reconciler.forgetActual(VIEW_ID.simulator);
-        // The view is gone: gateReadiness now hides it, so reconcile detaches it.
         reconciler.reconcileNow();
     }
     /**
@@ -435,7 +418,6 @@ export function createNativeSimulatorView(ctx, reconciler, deps) {
     }
     reconciler.registerView(VIEW_ID.simulator, {
         getView: () => nativeSimulatorView,
-        setAdded: (added) => { nativeSimulatorViewAdded = added; },
         gateHidden: () => !nativeSimulatorView,
         applyBounds: (view, bounds, extra) => applyNativeSimulatorBounds(view, bounds, extra?.zoom ?? 1),
     });

package/dist/main/services/views/native-view-tree.d.ts

@@ -0,0 +1,25 @@
+import type { BrowserWindow, WebContentsView } from 'electron';
+import type { ViewSlot } from './placement-reconciler.js';
+/**
+ * Single native child-tree owner for devtools. It resolves the current concrete
+ * instance dynamically because a stable viewId may be rebuilt, and updates its
+ * order ledger only after the corresponding Electron call succeeds.
+ */
+interface NativeViewRef {
+    readonly id: string;
+}
+export interface NativeViewTreeHost {
+    addChildView(ref: NativeViewRef): boolean;
+    removeChildView(ref: NativeViewRef): boolean;
+    readonly isDestroyed: boolean;
+    children(): readonly NativeViewRef[];
+    /** Detach and close a concrete instance, then remove it from the ledger. */
+    destroyView(viewId: string, view: WebContentsView | null): void;
+}
+export declare function createNativeViewTreeHost(ctx: {
+    windows: {
+        mainWindow: BrowserWindow;
+    };
+}, slots: Map<string, ViewSlot>): NativeViewTreeHost;
+export {};
+//# sourceMappingURL=native-view-tree.d.ts.map

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

@@ -0,0 +1,69 @@
+export function createNativeViewTreeHost(ctx, slots) {
+    const order = [];
+    const mounted = new Map();
+    function resolve(id) {
+        return slots.get(id)?.getView() ?? null;
+    }
+    return {
+        addChildView(ref) {
+            const view = resolve(ref.id);
+            if (!view || view.webContents.isDestroyed() || ctx.windows.mainWindow.isDestroyed())
+                return false;
+            try {
+                ctx.windows.mainWindow.contentView.addChildView(view);
+            }
+            catch {
+                return false;
+            }
+            const i = order.indexOf(ref.id);
+            if (i >= 0)
+                order.splice(i, 1);
+            order.push(ref.id);
+            mounted.set(ref.id, view);
+            return true;
+        },
+        removeChildView(ref) {
+            const view = mounted.get(ref.id) ?? null;
+            if (!view || ctx.windows.mainWindow.isDestroyed())
+                return false;
+            try {
+                ctx.windows.mainWindow.contentView.removeChildView(view);
+            }
+            catch {
+                return false;
+            }
+            const i = order.indexOf(ref.id);
+            if (i >= 0)
+                order.splice(i, 1);
+            mounted.delete(ref.id);
+            return true;
+        },
+        get isDestroyed() {
+            return ctx.windows.mainWindow.isDestroyed();
+        },
+        children: () => order.map((id) => ({ id })),
+        destroyView(viewId, view) {
+            const isMountedInstance = view !== null && mounted.get(viewId) === view;
+            if (view && !ctx.windows.mainWindow.isDestroyed()) {
+                try {
+                    ctx.windows.mainWindow.contentView.removeChildView(view);
+                }
+                catch { /* detached */ }
+            }
+            if (isMountedInstance) {
+                const i = order.indexOf(viewId);
+                if (i >= 0)
+                    order.splice(i, 1);
+                mounted.delete(viewId);
+            }
+            if (view) {
+                try {
+                    if (!view.webContents.isDestroyed())
+                        view.webContents.close();
+                }
+                catch { /* destroyed concurrently */ }
+            }
+        },
+    };
+}
+//# sourceMappingURL=native-view-tree.js.map

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

@@ -1,9 +1,22 @@
 import type { WebContents } from 'electron';
 import type { PlacementReconciler } from './placement-reconciler.js';
 import type { ViewManagerContext } from './view-manager.js';
+export interface TooltipShowPayload {
+    anchor: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    text: string;
+}
 /**
- * The two main-owned overlay panels: the settings sheet (right-side panel over
- * a transparent backdrop) and the transient popover. Their bounds are
+ * The main-owned overlay panels: the settings sheet (right-side panel over a
+ * transparent backdrop), the transient compile-mode popover, and the tooltip.
+ * Each is an `OverlayPanel` (`@dimina-kit/electron-deck/main`) — the shared
+ * lazy-create/reuse/destroy WebContentsView lifecycle — wired into THIS
+ * module's own placement reconciler (the panel factory owns no z-order/bounds
+ * authority itself; see overlay-panel.ts's doc-comment). Bounds are
  * main-computed and published into the reconciler's `overlayDesired` (top-tier
  * layers, so a reorder keeps them above every base overlay).
  */
@@ -12,15 +25,25 @@ export interface OverlayPanelsView {
     hideSettings(): void;
     showPopover(data: unknown): void;
     hidePopover(): void;
-    /** Re-apply whichever of settings/popover is currently present (window resize / toolbar height change). */
+    prepareTooltip(): void;
+    showTooltip(data: TooltipShowPayload): void;
+    hideTooltip(): void;
+    markOverlayReady(webContentsId: number): void;
+    applyTooltipMeasurement(webContentsId: number, measurement: {
+        requestId: number;
+        width: number;
+        height: number;
+    }): void;
+    /** Re-apply whichever of settings/popover is currently present (window resize / toolbar height change). Tooltip excluded — it re-anchors on its own next show, a stale position while hidden doesn't matter. */
     reapplyPresentOverlays(): void;
     /** Re-apply the settings overlay only (the resize entry point re-applies settings, not popover). */
     applySettingsBoundsIfPresent(): void;
-    /** Destroy the cached settings view (aggregate simulator detach). */
+    /** Destroy the cached settings + tooltip views (aggregate simulator detach). */
     destroySettings(): void;
     getSettingsWebContents(): WebContents | null;
     getSettingsWebContentsId(): number | null;
     getPopoverWebContentsId(): number | null;
+    getTooltipWebContentsId(): number | null;
 }
 export declare function createOverlayPanelsView(ctx: ViewManagerContext, reconciler: PlacementReconciler, deps: {
     /** The host-toolbar strip height that offsets the overlay top edge. */