@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/main/services/views/miniapp-partition.js

@@ -1,159 +1,2 @@
-/**
- * Per-project session partition for the native-host miniapp runtime (P0 debt).
- *
- * Historically every project's miniapp webContents — the simulator content
- * WebContentsView, its nested render-host `<webview>` guests, AND the
- * service-host window — shared ONE hard-coded `persist:simulator` Electron
- * session. Cookies / localStorage / cache / IndexedDB written by project A were
- * visible to (and clobbered by) project B; two projects open at once cross-
- * contaminate and "clear storage" on one nukes the other.
- *
- * The fix derives a STABLE per-project partition from the project identity:
- * the miniapp `appId` (which flows in via the simulator URL `?appId=` and the
- * spawn path's `appId`) PLUS the project path. appId alone is insufficient —
- * it comes from the project manifest, so two DIFFERENT project paths can declare
- * the SAME appId and would otherwise share a partition; folding the path in
- * isolates them. Same project (same appId + path) → same partition (storage
- * survives a relaunch); different projects → different partitions (no cross-
- * contamination). The shape mirrors the IDE state of the art (WeChat's static
- * partition, ByteDance's `persist:miniapp-<id>` dynamic partition).
- *
- * The protocol handlers (`difile://`, `dmb-resource`) and webRequest policies
- * (referer / CORS) that the simulator runtime needs were installed once on the
- * single `persist:simulator` session. With per-project partitions those have to
- * be (re)applied to EACH project session the first time it is used. The setup
- * sites register a partition-agnostic configurator here; `configureMiniappSession`
- * runs every registered configurator exactly once per partition.
- *
- * Partition CLEANUP (reclaiming on-disk `persist:` data) is intentionally NOT
- * done here — leaving the data on disk is the whole point of a `persist:`
- * partition (cache/storage survives a relaunch). That is a separate concern.
- *
- * MIGRATION (intentional one-time reset): folding the project path into the key
- * means a project that previously ran on the appId-only `persist:miniapp-<appId>`
- * now runs on `persist:miniapp-<appId>-p<hash>` and starts with empty
- * cookies/localStorage/cache. Old data is NOT migrated — a best-effort copy
- * could carry already-cross-contaminated state into the newly isolated space,
- * which defeats the isolation. The reset is accepted as a one-time cost.
- */
-import * as electron from 'electron';
-/** The legacy single-session partition. Still used by the pre-warm pool (which
- * is intentionally NOT isolation-aware — see `serviceHostSpec`) and as the
- * fallback when a project key cannot be derived. */
-export const SHARED_MINIAPP_PARTITION = 'persist:simulator';
-const PARTITION_PREFIX = 'persist:miniapp-';
-/**
- * Derive a stable, filesystem-safe partition key from a project `appId`.
- *
- * `appId` is the project identity (e.g. a `wxapp…` id). We pass through the
- * characters Electron is happy to put in a session partition / on-disk folder
- * name (`[A-Za-z0-9_-]`) verbatim so the common case is human-legible, and fold
- * anything else into a short deterministic hash suffix so two appIds that differ
- * only in stripped characters never collide. The same `appId` always yields the
- * same key (so storage survives a relaunch); different `appId`s yield different
- * keys.
- */
-export function miniappPartitionKey(appId, projectPath) {
-    const safe = appId.replace(/[^A-Za-z0-9_-]/g, '');
-    // Folding may have dropped distinguishing characters; if the input was not
-    // already fully safe, append a deterministic hash of the RAW appId so two
-    // distinct appIds can never alias onto the same key.
-    const base = safe === appId && safe.length > 0
-        ? safe
-        : safe.length > 0
-            ? `${safe}-${djb2(appId).toString(36)}`
-            : djb2(appId).toString(36);
-    // `appId` comes from the project manifest, not the path — two DIFFERENT
-    // project paths can declare the SAME appId. Fold the project path into the key
-    // so those projects get isolated partitions (no storage/cache cross-talk),
-    // while the same path always yields the same suffix (a relaunch reuses its
-    // storage). Path characters aren't partition-safe, so always hash. Omitting
-    // projectPath preserves the legacy appId-only key (pre-warm pool / callers
-    // that have no project identity).
-    if (!projectPath)
-        return base;
-    return `${base}-p${djb2(projectPath).toString(36)}`;
-}
-/**
- * The Electron session partition for a project. Returns the SHARED partition
- * when `appId` is empty/unknown (so the runtime still has a session to load on,
- * matching the legacy behavior) and a `persist:miniapp-<key>` partition
- * otherwise.
- */
-export function miniappPartition(appId, projectPath) {
-    if (!appId)
-        return SHARED_MINIAPP_PARTITION;
-    return `${PARTITION_PREFIX}${miniappPartitionKey(appId, projectPath)}`;
-}
-/** Small, stable string hash (djb2). Not cryptographic — only needs to be
- * deterministic and collision-resistant enough to disambiguate appIds. */
-function djb2(input) {
-    let h = 5381;
-    for (let i = 0; i < input.length; i++) {
-        h = ((h << 5) + h + input.charCodeAt(i)) >>> 0;
-    }
-    return h;
-}
-const configurators = new Set();
-const configuredPartitions = new Set();
-/**
- * Register a configurator that runs against every miniapp partition session.
- * Already-configured partitions are (re)configured immediately so registration
- * order does not matter. Returns a disposer that unregisters the configurator
- * (it does not undo work already applied to live sessions).
- */
-export function registerMiniappSessionConfigurator(fn) {
-    configurators.add(fn);
-    for (const partition of configuredPartitions) {
-        try {
-            fn(electron.session.fromPartition(partition), partition);
-        }
-        catch (err) {
-            console.warn('[miniapp-partition] configurator failed for', partition, err);
-        }
-    }
-    return () => {
-        configurators.delete(fn);
-    };
-}
-/**
- * Ensure a partition's session has every registered configurator applied. Safe
- * to call repeatedly per partition (idempotent — each partition is configured
- * once). Call this before loading project content on `partition`.
- *
- * Returns `null` when there is nothing to configure (no configurator registered)
- * so the partition derivation stays independent of any live Electron session —
- * the partition is a constructor-time fact, not a side effect of touching the
- * session API. Setup sites register configurators at app boot; in unit tests
- * that mock `electron` without a `session` export this short-circuits cleanly.
- */
-export function configureMiniappSession(partition) {
-    // Record that this partition should be configured even if no configurator is
-    // registered YET — a later `registerMiniappSessionConfigurator` back-fills it.
-    const alreadyConfigured = configuredPartitions.has(partition);
-    configuredPartitions.add(partition);
-    if (configurators.size === 0)
-        return null;
-    const sess = electron.session.fromPartition(partition);
-    if (alreadyConfigured)
-        return sess;
-    for (const fn of configurators) {
-        try {
-            fn(sess, partition);
-        }
-        catch (err) {
-            console.warn('[miniapp-partition] configurator failed for', partition, err);
-        }
-    }
-    return sess;
-}
-/**
- * Test-only: drop the configurator + configured-partition bookkeeping so each
- * test starts from a clean slate. (Module-level state otherwise leaks across
- * unit tests that mock `electron`.)
- */
-export function __resetMiniappSessionConfigForTests() {
-    configurators.clear();
-    configuredPartitions.clear();
-}
+export * from '@dimina-kit/electron-runtime/main/miniapp-partition';
 //# sourceMappingURL=miniapp-partition.js.map

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

@@ -1,11 +1,13 @@
-import { WebContentsView } from 'electron';
+import { WebContentsView, webContents as electronWebContents } from 'electron';
 import { buildDevtoolsProjectSourceLinksScript, decodeOpenInEditorUrl, projectSourceContextFromServiceHostUrl, } from '../../../shared/open-in-editor.js';
-import { buildCustomizeTabsScript } from './devtools-tabs.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
@@ -37,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`,
@@ -54,6 +55,7 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
     // (`rebuildDevtoolsHostView`) rather than target it again.
     let devtoolsHostUsed = false;
     let unsubscribeNativeRenderEvents = null;
+    let unsubscribeNativeServiceHostReady = null;
     // Disposer for the Elements-forward feature (routes the front-end's Elements
     // CDP traffic at the active render guest). Installed in
     // `attach`, stopped on detach / host destroyed.
@@ -64,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.
@@ -106,6 +116,13 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
             catch { /* ignore */ }
             unsubscribeNativeRenderEvents = null;
         }
+        if (unsubscribeNativeServiceHostReady) {
+            try {
+                unsubscribeNativeServiceHostReady();
+            }
+            catch { /* ignore */ }
+            unsubscribeNativeServiceHostReady = null;
+        }
         closeNativeDevtoolsSource();
     }
     function injectOpenResourceHandler(serviceWc, devtoolsWc) {
@@ -158,6 +175,37 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
         }
         catch { /* wc surface incomplete / torn down; degrade silently */ }
     }
+    // User-facing Console de-noise: hide dimina
+    // 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 (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
+    // frontend-bootstrap-gate.ts). Gate resolving false = degrade silently,
+    // this module's standing convention.
+    function applyConsoleFilter(devtoolsWc) {
+        try {
+            if (devtoolsWc.isDestroyed())
+                return;
+            const inject = () => {
+                void whenFrontendBootstrapped(devtoolsWc).then((ready) => {
+                    if (!ready || devtoolsWc.isDestroyed())
+                        return;
+                    try {
+                        void devtoolsWc.executeJavaScript(buildInternalLogHideScript()).catch(() => { });
+                    }
+                    catch { /* wc torn down mid-call */ }
+                });
+            };
+            injectWhenReady(devtoolsWc, 'console-filter', 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.
@@ -211,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;
         }
@@ -246,6 +297,9 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
             // Re-applied on every re-point so a service-host pool swap (fresh
             // openDevTools) re-asserts the custom tab bar.
             customizeDevtoolsTabs(simulatorView.webContents);
+            // De-noise the user-facing Console: hide
+            // dimina framework internal log lines from THIS panel by default.
+            applyConsoleFilter(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
@@ -286,8 +340,25 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
             return false;
         return pointNativeDevtoolsAtServiceWc(wc);
     }
-    function scheduleNativeDevtoolsFollow(appId, attempt = 0) {
-        if (attempt >= 20)
+    // Bound on how long the FALLBACK poll (below) keeps retrying before giving
+    // up — a pure safety valve, not the real mechanism. The real mechanism is
+    // `onNativeServiceHostReady` (an event, not a poll): it fires the moment
+    // `ctx.bridge.getServiceWc` is GUARANTEED to resolve, so this fallback only
+    // exists for the residual gap where `followNativeDevtoolsServiceHost` runs
+    // from a render event that races ahead of that event somehow. A fixed short
+    // attempt count here (originally 20×50ms = 1s) was the actual production
+    // bug this module was fixed for: under real machine load,
+    // `ctx.bridge.getServiceWc(appId)` can take longer than 1s to resolve, and
+    // once the fixed budget ran out the right-panel DevTools attach was
+    // silently, permanently lost for the rest of that session (confirmed via
+    // real reproduction + timing instrumentation). Bounded by WALL-CLOCK time
+    // (generous — normal resolution is well under a second) rather than a
+    // small attempt count, since the fallback's whole job is to outlast a slow
+    // machine, not a slow algorithm.
+    const NATIVE_DEVTOOLS_FALLBACK_POLL_MAX_MS = 60_000;
+    const NATIVE_DEVTOOLS_FALLBACK_POLL_INTERVAL_MS = 50;
+    function scheduleNativeDevtoolsFollow(appId, startedAt = Date.now()) {
+        if (Date.now() - startedAt >= NATIVE_DEVTOOLS_FALLBACK_POLL_MAX_MS)
             return;
         if (!ctx.bridge?.isNativeHost())
             return;
@@ -300,8 +371,8 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
                 return;
             if (pointNativeDevtoolsAtActiveServiceHost(appId))
                 return;
-            scheduleNativeDevtoolsFollow(appId, attempt + 1);
-        }, 50);
+            scheduleNativeDevtoolsFollow(appId, startedAt);
+        }, NATIVE_DEVTOOLS_FALLBACK_POLL_INTERVAL_MS);
     }
     function followNativeDevtoolsServiceHost(appId) {
         clearNativeDevtoolsRetry();
@@ -309,10 +380,53 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
             return;
         scheduleNativeDevtoolsFollow(appId);
     }
+    // The real mechanism: fires the moment a service host's `service.html`
+    // did-finish-load's, i.e. the exact instant `serviceWcId` is guaranteed
+    // resolvable — no polling, no race against a fixed retry budget. Resolves
+    // the wc DIRECTLY via the id the event carries (never re-resolving through
+    // `getServiceWc(appId)`, which during same-app respawn overlap returns the
+    // newest session, not necessarily the one that fired this event), then
+    // validates the event against that same authority before acting — see the
+    // generation gate below.
+    function onNativeServiceHostReady(event) {
+        if (!ctx.bridge?.isNativeHost())
+            return;
+        if (!simulatorView || simulatorView.webContents.isDestroyed())
+            return;
+        const wc = electronWebContents.fromId(event.serviceWcId);
+        if (!wc || wc.isDestroyed())
+            return;
+        // Generation gate: `getServiceWc` resolves the NEWEST live session
+        // (bridge-router's findAppSessionByAppId is last-inserted-wins), so an
+        // event it CONTRADICTS is a superseded session's late-arriving ready —
+        // repointing there would resurrect a dying host (the newer session's own
+        // ready does/did the real repoint). An authority that cannot resolve at
+        // all fails OPEN: the event is the only signal available, and dropping
+        // it would strand the attach on nothing. Fail-open cannot stick to a
+        // dying wc in practice — the direct emit is same-tick with bootServiceHost
+        // (session still registered), the catch-up path re-validates the session
+        // before delivering, and even a hypothetical miss just makes point()
+        // return false into the wall-clock-bounded fallback.
+        const current = ctx.bridge.getServiceWc(event.appId);
+        if (current && current.id !== event.serviceWcId)
+            return;
+        // Only a SUCCESSFUL repoint may retire the standing fallback poll — a
+        // failed attempt (service wc torn down mid-point is the common race)
+        // must leave/re-arm it, or this very event cancels the retry that would
+        // have eventually attached.
+        if (pointNativeDevtoolsAtServiceWc(wc)) {
+            clearNativeDevtoolsRetry();
+            return;
+        }
+        scheduleNativeDevtoolsFollow(event.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.
+    // at the now-current service host on every such event. Belt-and-suspenders
+    // alongside `onNativeServiceHostReady` — by the time a render event fires,
+    // the service host that produced it is definitionally already resolvable,
+    // so this path should normally resolve immediately (no fallback poll needed).
     function onNativeRenderEvent(event) {
         if (event.kind !== 'activePage' && event.kind !== 'domReady')
             return;
@@ -326,32 +440,53 @@ 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();
         // 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.
+        // Instead drive the front-end's own view manager via `globalThis.EUI`
+        // (the bundle's real exposure of the ui/legacy namespace) — NOT
+        // `globalThis.UI`, which never exists on this front-end build (same
+        // finding devtools-tabs.ts records; an earlier `UI.…`-polling version of
+        // this script was dead code and the panel silently defaulted to
+        // Elements). Gated on frontend bootstrap: `ViewManager.instance()` is a
+        // singleton construction, only safe after the front-end's own MainImpl
+        // finished wiring (see frontend-bootstrap-gate.ts). (A persisted
+        // `panel-selected-tab` preference write is NOT an alternative mechanism —
+        // this custom devtools:// host persists nothing to disk; see
+        // console-filter.ts's header.)
         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);
+        // 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
@@ -377,7 +512,18 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
             // 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 });
+            const thisForward = installElementsForward({
+                devtoolsWc,
+                bridge: ctx.bridge,
+                connections: ctx.connections,
+                // Shared session broker (see cdp-session/index.ts) — undefined falls
+                // back to a private instance owned by this call.
+                broker: ctx.cdpSessionBroker,
+                // Body/post-data lookups for the virtual requestIds the network
+                // forwarder injects — answered from its prefetch cache when the
+                // front-end's Response tab round-trips Network.getResponseBody.
+                network: ctx.networkForward?.bodies,
+            });
             stopElementsForward = thisForward;
             devtoolsWc.once('destroyed', () => {
                 try {
@@ -389,27 +535,39 @@ export function createDevtoolsHost(ctx, reconciler, deps) {
             });
         }
         injectWhenReady(devtoolsWc, 'console-default', () => {
-            devtoolsWc.executeJavaScript(`
-        (function() {
-          try { localStorage.setItem('panel-selectedTab', '"console"') } catch {}
-          let tries = 0
-          const timer = setInterval(() => {
-            tries++
+            void whenFrontendBootstrapped(devtoolsWc).then((ready) => {
+                if (!ready || devtoolsWc.isDestroyed())
+                    return;
+                devtoolsWc.executeJavaScript(`
+          (function() {
             try {
-              const UI = globalThis.UI
-              const vm = UI && UI.ViewManager && typeof UI.ViewManager.instance === 'function'
-                ? UI.ViewManager.instance()
+              var EUI = globalThis.EUI
+              var vm = EUI && EUI.ViewManager && EUI.ViewManager.ViewManager
+                && typeof EUI.ViewManager.ViewManager.instance === 'function'
+                ? EUI.ViewManager.ViewManager.instance()
                 : null
-              if (vm && typeof vm.showView === 'function') {
-                vm.showView('console')
-                clearInterval(timer)
-                return
-              }
-            } catch {}
-            if (tries > 80) clearInterval(timer)
-          }, 50)
-        })()
-      `).catch(() => { });
+              if (vm && typeof vm.showView === 'function') void vm.showView('console')
+            } catch (_) {}
+          })()
+        `).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
@@ -425,39 +583,20 @@ 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()) {
             unsubscribeNativeRenderEvents = ctx.bridge.onRenderEvent(onNativeRenderEvent);
+            unsubscribeNativeServiceHostReady = ctx.bridge.onServiceHostReady(onNativeServiceHostReady);
             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 {
@@ -475,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.d.ts

@@ -15,6 +15,12 @@ import type { ViewManagerContext } from './view-manager.js';
 export interface NativeSimulatorView {
     attachNativeSimulator(simulatorUrl: string, simWidth: number): Promise<void>;
     softReloadNativeSimulator(simulatorUrl: string): boolean;
+    /**
+     * Hot-swap stylesheets in every live render-host guest WITHOUT respawning the
+     * shell (page stack / form state / focus survive). Returns false when no live
+     * guest exists, so the caller falls back to a full reload.
+     */
+    refreshSimulatorStyles(): boolean;
     detachSimulator(): void;
     getSimulatorWebContentsId(): number | null;
     getSimulatorWebContents(): WebContents | null;