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

package/dist/main/services/views/console-filter.js

@@ -0,0 +1,190 @@
+/**
+ * Hides dimina framework internal log lines from the right-panel
+ * (user-facing) Console, WITHOUT occupying the panel's visible text-filter
+ * box (see console-forward/internal-log.ts for the prefix judge this
+ * mirrors). The framework prints these via a plain `console.log` call INSIDE
+ * the inspected service host itself; main has no interception point for a
+ * native console line (see console-forward/index.ts's header comment), so the
+ * lever has to live inside the front-end.
+ *
+ * ── Why not the text-filter box ──────────────────────────────────────────
+ * Writing `-/^\[service\]/` into the Console's filter input does hide the
+ * lines, but the string then sits in the box the developer uses for their own
+ * filtering: it looks like something they typed, it silently comes back after
+ * every re-point (an empty box is indistinguishable from "never set", so
+ * clearing it just invites the next injection to rewrite it), and it consumes
+ * the one filter slot the panel offers. Driving the panel's own visibility
+ * judge instead leaves the box genuinely empty and under the developer's sole
+ * control.
+ *
+ * ── Mechanism ────────────────────────────────────────────────────────────
+ * `Console.ConsoleView.instance().filter.currentFilter` is the ConsoleFilter
+ * object the panel consults for every message, through its prototype method
+ * `shouldBeVisible(viewMessage)`. Wrapping that PROTOTYPE method (not the
+ * instance) rejects internal-log lines ahead of the panel's normal logic:
+ *   - `currentFilter` is not the only ConsoleFilter the panel judges with:
+ *     `ConsoleFilter.clone()` returns `new ConsoleFilter(...)`, and the
+ *     sidebar filters through those clones. They share the prototype, so one
+ *     patch covers all of them — and keeps covering them if the panel ever
+ *     replaces `currentFilter` outright. (Editing the filter box does NOT
+ *     replace it today: `ConsoleViewFilter` builds `currentFilter` once in its
+ *     constructor and `updateCurrentFilter()` mutates that same instance's
+ *     `parsedFilters` / `levelsMask` / `executionContext` in place.)
+ *   - The wrapper delegates to the original for everything else, so a
+ *     developer's own filter keeps working exactly as before — this only ever
+ *     subtracts internal-log lines.
+ * Verified end-to-end against the real bundled front-end
+ * (e2e/console-filter-live.spec.ts): filter box reads empty, a `[service]`
+ * line logged afterwards stays hidden, an ordinary business log stays visible.
+ *
+ * This patches only the realm of the wc it is injected into — the right-panel
+ * front-end. The standalone floating debug window is a separate front-end with
+ * its own realm, and its content arrives by a different route entirely
+ * (main-side CDP capture → console-forward → global-console-mirror, which is
+ * deliberately UNFILTERED), so framework internals stay fully visible there.
+ * That window is the escape hatch for anyone who needs to read them.
+ *
+ * ── Timing ───────────────────────────────────────────────────────────────
+ * `Console.ConsoleView` has no lifecycle EVENT marking "fully constructed" —
+ * only the checkable condition of whether `.instance()` and the reach into
+ * `.filter.currentFilter` throw. The injection therefore retries on a bounded
+ * interval (see `LIVE_FILTER_POLL_MAX_ATTEMPTS`/`_INTERVAL_MS`) rather than
+ * guessing a fixed delay, and stops as soon as the wrapper is installed.
+ *
+ * Every tick gates on the front-end bootstrap probe BEFORE touching
+ * `ConsoleView.instance()`: an early construction transitively creates
+ * IssuesManager and permanently kills the front-end's own bootstrap
+ * (`ensureFirst` conflict in MainImpl.#createAppUI) — see
+ * frontend-bootstrap-gate.ts for the full mechanism. The main process
+ * additionally holds this whole injection behind `whenFrontendBootstrapped`;
+ * the in-realm probe is defense in depth for any other caller.
+ */
+/**
+ * First-arg prefix marking a dimina SERVICE-layer framework log. A line counts
+ * as internal when its text IS this tag or starts with the tag plus a space —
+ * the same shape console-forward/internal-log.ts requires of the first arg, so
+ * a business line like '[service]业务状态' stays visible on both sides.
+ * These entries are captured
+ * directly by the native CDP `Runtime.consoleAPICalled` attach on the service
+ * host (service-host/preload.cjs deliberately does not monkeypatch
+ * `console.*` there — see its header comment — so there is no main-owned code
+ * between the framework's call and the attached DevTools), which is why the
+ * front-end is the only place they can be hidden.
+ *
+ * RENDER-layer framework noise (`[system]`) needs nothing here:
+ * `console-forward/index.ts`'s `forwardRenderToServiceHost` gates on
+ * `isInternalLogMessage` and never injects those entries into the service
+ * host's console at all — filtered at the source, in main-owned code.
+ */
+export const INTERNAL_LOG_HIDDEN_PREFIX = '[service]';
+/** Marker property stamped on the patched prototype, so a re-point re-running
+ *  this script wraps once rather than nesting a wrapper per injection. Also
+ *  the signal e2e specs read to tell "wrapper installed" from "not yet". */
+export const INTERNAL_LOG_WRAPPER_MARK = '__diminaInternalLogHidden';
+// Bound on how long the in-realm poll retries before giving up — mirrors this
+// module's other bounded waits (e.g. internal-devtools-window's
+// CLOSE_WATCHDOG_MS): wait for the real condition, but never forever.
+const LIVE_FILTER_POLL_MAX_ATTEMPTS = 100;
+const LIVE_FILTER_POLL_INTERVAL_MS = 100;
+/**
+ * Build the `executeJavaScript` source that installs the internal-log
+ * visibility wrapper described in this module's header comment.
+ *
+ * Failure is loud but non-fatal: a front-end whose ConsoleFilter prototype has
+ * no `shouldBeVisible` (a future Chromium reshuffle) warns once and gives up
+ * rather than retrying a structurally absent surface — the panel then simply
+ * shows framework lines, which is the pre-existing behavior, not a breakage.
+ */
+export function buildInternalLogHideScript(hiddenPrefix = INTERNAL_LOG_HIDDEN_PREFIX) {
+    const prefixJson = JSON.stringify(hiddenPrefix);
+    const markJson = JSON.stringify(INTERNAL_LOG_WRAPPER_MARK);
+    const maxAttempts = JSON.stringify(LIVE_FILTER_POLL_MAX_ATTEMPTS);
+    const intervalMs = JSON.stringify(LIVE_FILTER_POLL_INTERVAL_MS);
+    return `(function(){
+    var PREFIX = ${prefixJson};
+    var MARK = ${markJson};
+    var attempts = 0;
+    function bootstrapReady() {
+      try {
+        var eui = globalThis.EUI;
+        if (!eui || !eui.ShortcutRegistry || !eui.ShortcutRegistry.ShortcutRegistry) return false;
+        eui.ShortcutRegistry.ShortcutRegistry.instance();
+        return true;
+      } catch (_) { return false; }
+    }
+    function isInternalLog(viewMessage) {
+      try {
+        var msg = viewMessage && typeof viewMessage.consoleMessage === 'function' ? viewMessage.consoleMessage() : null;
+        var text = msg ? String(msg.messageText == null ? '' : msg.messageText) : '';
+        // Exact tag (the rest of the line is in later arguments), or the tag
+        // followed by a space — same shape as main's isInternalLogMessage. A
+        // bare prefix test would also swallow '[service]业务状态', an ordinary
+        // business log the panel must keep showing.
+        return text === PREFIX || text.indexOf(PREFIX + ' ') === 0;
+      } catch (_) { return false; }
+    }
+    function tryApply() {
+      attempts++;
+      var scheduleRetry = attempts < ${maxAttempts};
+      // Distinguishes the two halves of this script when the tail throws:
+      // future messages are already handled once the wrapper is on the
+      // prototype, even if re-judging the rows already on screen keeps failing.
+      var wrapperInstalled = false;
+      // In-realm bootstrap probe FIRST (defense in depth on top of the
+      // main-process whenFrontendBootstrapped gate): touching
+      // Console.ConsoleView.instance() before the front-end's own MainImpl
+      // bootstrap completes constructs IssuesManager early and permanently
+      // kills that bootstrap (ensureFirst conflict) — the probe throws BEFORE
+      // constructing anything, so a not-ready tick costs nothing.
+      if (!bootstrapReady()) {
+        if (scheduleRetry) { setTimeout(tryApply, ${intervalMs}); return; }
+        console.warn('[console-filter] gave up hiding internal logs after ' + attempts + ' attempts — the front-end bootstrap never completed');
+        return;
+      }
+      try {
+        var ConsoleNS = globalThis.Console;
+        var view = ConsoleNS && ConsoleNS.ConsoleView ? ConsoleNS.ConsoleView.instance() : null;
+        var f = view ? view.filter : null;
+        var currentFilter = f ? f.currentFilter : null;
+        if (!currentFilter) {
+          if (scheduleRetry) { setTimeout(tryApply, ${intervalMs}); return; }
+          console.warn('[console-filter] gave up hiding internal logs after ' + attempts + ' attempts — Console.ConsoleView never became usable');
+          return;
+        }
+        // The prototype, NOT the instance: clone() mints further ConsoleFilters
+        // that judge the same messages, and they all share this one.
+        var proto = Object.getPrototypeOf(currentFilter);
+        if (!proto || typeof proto.shouldBeVisible !== 'function') {
+          console.warn('[console-filter] cannot hide internal logs — ConsoleFilter has no shouldBeVisible to wrap; framework log lines will show in the right panel');
+          return;
+        }
+        if (!proto[MARK]) {
+          var original = proto.shouldBeVisible;
+          proto.shouldBeVisible = function(viewMessage) {
+            if (isInternalLog(viewMessage)) return false;
+            return original.apply(this, arguments);
+          };
+          proto[MARK] = true;
+        }
+        wrapperInstalled = true;
+        // Re-run the panel's visibility pass so lines already on screen when
+        // the wrapper lands are re-judged, not just future ones.
+        if (view && typeof view.onFilterChanged === 'function') view.onFilterChanged();
+      } catch(err) {
+        if (scheduleRetry) { setTimeout(tryApply, ${intervalMs}); return; }
+        // Name which half survived: a wrapper that installed but could never
+        // refresh still hides everything logged from now on, and the panel is
+        // left holding the internal lines printed before it landed. Reporting
+        // that as plain "gave up" would send the next reader looking for a
+        // filter that is in fact working.
+        if (wrapperInstalled) {
+          console.warn('[console-filter] internal logs are hidden from here on, but the rows already on screen could not be re-judged:', err);
+        } else {
+          console.warn('[console-filter] gave up hiding internal logs after ' + attempts + ' attempts:', err);
+        }
+      }
+    }
+    tryApply();
+  })()`;
+}
+//# sourceMappingURL=console-filter.js.map

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/frontend-bootstrap-gate.d.ts

@@ -0,0 +1,59 @@
+import type { WebContents } from 'electron';
+/**
+ * The single "front-end bootstrap finished" gate every DevTools front-end
+ * injector must pass BEFORE running any `.instance()`-style script in the
+ * front-end realm.
+ *
+ * Why this must exist: the bundled front-end's own `MainImpl.#createAppUI`
+ * constructs its singletons in a fixed order, and several of them assert
+ * first-creation (`IssuesManager.instance({ensureFirst: true})`). An injected
+ * script that constructs a panel singleton early — e.g. a bare
+ * `Console.ConsoleView.instance()`, whose field initializers transitively
+ * create IssuesManager — makes that assertion throw, and the front-end's
+ * bootstrap dies as an unhandled rejection it NEVER recovers from:
+ * ActionRegistry/ShortcutRegistry are then never created and the panel
+ * renders no tabs at all (the "Missing actionRegistry for shortcutRegistry"
+ * permanent-failure mode, confirmed against the real bundled front-end with
+ * first-creator stack captures and the matching Chromium 146 source).
+ *
+ * Iron rule for injectors: BEFORE this gate reports ready, an injected
+ * script may only touch registries and InspectorFrontendHost preferences —
+ * never any `.instance()` call. (`customizeDevtoolsTabs` is the one
+ * documented pre-gate exception: it must run before ViewManager snapshots
+ * the view registry, and it only edits the registry.)
+ */
+/**
+ * Side-effect-free in-realm readiness probe, safe to feed directly to
+ * `wc.executeJavaScript`. `ShortcutRegistry.instance()` (no args) throws
+ * BEFORE constructing anything when the registry does not exist yet, so a
+ * false answer costs nothing — and a true answer proves `MainImpl` already
+ * passed the point where every bootstrap singleton (IssuesManager included)
+ * exists, making singleton-touching injections safe. `EUI` is the bundle's
+ * real exposure of the ui/legacy namespace (`globalThis.UI` does not exist
+ * on this front-end build). An expression, not a statement list: the value
+ * `executeJavaScript` resolves is the IIFE's completion value.
+ */
+export declare const FRONTEND_BOOTSTRAP_PROBE_SCRIPT = "(() => {\n  try {\n    const eui = globalThis.EUI\n    if (!eui || !eui.ShortcutRegistry || !eui.ShortcutRegistry.ShortcutRegistry) return false\n    eui.ShortcutRegistry.ShortcutRegistry.instance()\n    return true\n  } catch (_) {\n    return false\n  }\n})()";
+export interface WhenFrontendBootstrappedOptions {
+    /** Wall-clock give-up bound. Past it the promise resolves false with a
+     * single warn — callers degrade silently, matching the surrounding
+     * modules' convention. */
+    timeoutMs?: number;
+    /** Probe cadence while the front-end is still booting. */
+    intervalMs?: number;
+}
+/**
+ * Poll the probe against `wc` until the front-end bootstrap is provably
+ * complete. Resolves true on readiness; false on timeout (one warn) or a
+ * destroyed wc — never rejects, and never leaves a live timer behind after
+ * settling. A rejected probe call (execution context torn down mid-load,
+ * navigation in flight) counts as "not ready yet", not as an error.
+ *
+ * The timeout is an INDEPENDENT hard deadline racing the poll — not a check
+ * inside the poll chain. A probe `executeJavaScript` promise that never
+ * settles (frame destroyed mid-call / a wc permanently stuck loading) would
+ * stall a chain-embedded check forever; the deadline settles this promise
+ * regardless.
+ */
+export declare function whenFrontendBootstrapped(wc: WebContents, opts?: WhenFrontendBootstrappedOptions): Promise<boolean>;
+//# sourceMappingURL=frontend-bootstrap-gate.d.ts.map

package/dist/main/services/views/frontend-bootstrap-gate.js

@@ -0,0 +1,117 @@
+/**
+ * The single "front-end bootstrap finished" gate every DevTools front-end
+ * injector must pass BEFORE running any `.instance()`-style script in the
+ * front-end realm.
+ *
+ * Why this must exist: the bundled front-end's own `MainImpl.#createAppUI`
+ * constructs its singletons in a fixed order, and several of them assert
+ * first-creation (`IssuesManager.instance({ensureFirst: true})`). An injected
+ * script that constructs a panel singleton early — e.g. a bare
+ * `Console.ConsoleView.instance()`, whose field initializers transitively
+ * create IssuesManager — makes that assertion throw, and the front-end's
+ * bootstrap dies as an unhandled rejection it NEVER recovers from:
+ * ActionRegistry/ShortcutRegistry are then never created and the panel
+ * renders no tabs at all (the "Missing actionRegistry for shortcutRegistry"
+ * permanent-failure mode, confirmed against the real bundled front-end with
+ * first-creator stack captures and the matching Chromium 146 source).
+ *
+ * Iron rule for injectors: BEFORE this gate reports ready, an injected
+ * script may only touch registries and InspectorFrontendHost preferences —
+ * never any `.instance()` call. (`customizeDevtoolsTabs` is the one
+ * documented pre-gate exception: it must run before ViewManager snapshots
+ * the view registry, and it only edits the registry.)
+ */
+/**
+ * Side-effect-free in-realm readiness probe, safe to feed directly to
+ * `wc.executeJavaScript`. `ShortcutRegistry.instance()` (no args) throws
+ * BEFORE constructing anything when the registry does not exist yet, so a
+ * false answer costs nothing — and a true answer proves `MainImpl` already
+ * passed the point where every bootstrap singleton (IssuesManager included)
+ * exists, making singleton-touching injections safe. `EUI` is the bundle's
+ * real exposure of the ui/legacy namespace (`globalThis.UI` does not exist
+ * on this front-end build). An expression, not a statement list: the value
+ * `executeJavaScript` resolves is the IIFE's completion value.
+ */
+export const FRONTEND_BOOTSTRAP_PROBE_SCRIPT = `(() => {
+  try {
+    const eui = globalThis.EUI
+    if (!eui || !eui.ShortcutRegistry || !eui.ShortcutRegistry.ShortcutRegistry) return false
+    eui.ShortcutRegistry.ShortcutRegistry.instance()
+    return true
+  } catch (_) {
+    return false
+  }
+})()`;
+// Matches the e2e suite's own bootstrap-wait window (console-filter-live's
+// 45s probe poll) so a slow-but-alive bootstrap never lands in a band where
+// production has given up while the spec still expects the injections.
+const DEFAULT_TIMEOUT_MS = 45_000;
+const DEFAULT_INTERVAL_MS = 150;
+/**
+ * Poll the probe against `wc` until the front-end bootstrap is provably
+ * complete. Resolves true on readiness; false on timeout (one warn) or a
+ * destroyed wc — never rejects, and never leaves a live timer behind after
+ * settling. A rejected probe call (execution context torn down mid-load,
+ * navigation in flight) counts as "not ready yet", not as an error.
+ *
+ * The timeout is an INDEPENDENT hard deadline racing the poll — not a check
+ * inside the poll chain. A probe `executeJavaScript` promise that never
+ * settles (frame destroyed mid-call / a wc permanently stuck loading) would
+ * stall a chain-embedded check forever; the deadline settles this promise
+ * regardless.
+ */
+export function whenFrontendBootstrapped(wc, opts) {
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const intervalMs = opts?.intervalMs ?? DEFAULT_INTERVAL_MS;
+    return new Promise((resolve) => {
+        let timer = null;
+        let settled = false;
+        const finish = (ready) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            resolve(ready);
+        };
+        const deadline = setTimeout(() => {
+            // Within one call "ready" was never observed — a dead bootstrap and a
+            // merely-slow one are indistinguishable from out here; say so.
+            console.warn(`[frontend-bootstrap-gate] front-end bootstrap probe never reported ready within ${timeoutMs}ms — bootstrap-gated injections stay skipped for this host`);
+            finish(false);
+        }, timeoutMs);
+        deadline.unref?.();
+        const attempt = () => {
+            if (wc.isDestroyed()) {
+                finish(false);
+                return;
+            }
+            Promise.resolve()
+                .then(() => wc.executeJavaScript(FRONTEND_BOOTSTRAP_PROBE_SCRIPT))
+                .then((ready) => ready === true, () => false)
+                .then((ready) => {
+                if (settled)
+                    return;
+                // Destroyed-check BEFORE honoring a ready answer: a probe that was
+                // in flight when the wc got destroyed can still resolve true, and
+                // reporting "bootstrapped" for a dead target contradicts this
+                // function's contract (destroyed ⇒ false).
+                if (wc.isDestroyed()) {
+                    finish(false);
+                    return;
+                }
+                if (ready) {
+                    finish(true);
+                    return;
+                }
+                timer = setTimeout(attempt, intervalMs);
+                timer.unref?.();
+            });
+        };
+        attempt();
+    });
+}
+//# sourceMappingURL=frontend-bootstrap-gate.js.map

package/dist/main/services/views/host-dialog-port-channel.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Dialog-specific instantiation of `createHostSlotPortChannel` (see that
+ * module for the full per-load handshake / navigation-invalidation
+ * contract).
+ */
+import type { WebContents } from 'electron';
+import { type HostSlotMessageSubscription, type HostSlotPortChannel } from './host-slot-port-channel.js';
+export type HostDialogMessageSubscription = HostSlotMessageSubscription;
+export type HostDialogPortChannel = HostSlotPortChannel;
+export declare function createHostDialogPortChannel(opts: {
+    /**
+     * Is `wc` still the manager's CURRENT live dialog webContents? Guards a
+     * stale wc's late `did-finish-load` from hijacking the channel after a
+     * rebuild swapped the view out underneath it.
+     */
+    isCurrent: (wc: WebContents) => boolean;
+}): HostDialogPortChannel;
+//# sourceMappingURL=host-dialog-port-channel.d.ts.map

package/dist/main/services/views/host-dialog-port-channel.js

@@ -0,0 +1,15 @@
+/**
+ * Dialog-specific instantiation of `createHostSlotPortChannel` (see that
+ * module for the full per-load handshake / navigation-invalidation
+ * contract).
+ */
+import { ViewChannel } from '../../../shared/ipc-channels-overlays.js';
+import { createHostSlotPortChannel, } from './host-slot-port-channel.js';
+export function createHostDialogPortChannel(opts) {
+    return createHostSlotPortChannel({
+        isCurrent: opts.isCurrent,
+        channel: ViewChannel.HostDialogPort,
+        logPrefix: '[host-dialog]',
+    });
+}
+//# sourceMappingURL=host-dialog-port-channel.js.map

package/dist/main/services/views/host-dialog-session-runtime.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dialog-specific instantiation of `createHostSlotSessionRuntime` (see that
+ * module for the full ref-counting contract). Kept as a thin, independently
+ * named wrapper — same rationale as `host-toolbar-session-runtime.ts` — so
+ * a dialog-focused test can `vi.resetModules()` this module's state without
+ * touching the toolbar/sidebar's independent ref-counts.
+ */
+export declare function acquireHostDialogSessionRuntime(): void;
+export declare function releaseHostDialogSessionRuntime(): void;
+//# sourceMappingURL=host-dialog-session-runtime.d.ts.map

package/dist/main/services/views/host-dialog-session-runtime.js

@@ -0,0 +1,17 @@
+/**
+ * Dialog-specific instantiation of `createHostSlotSessionRuntime` (see that
+ * module for the full ref-counting contract). Kept as a thin, independently
+ * named wrapper — same rationale as `host-toolbar-session-runtime.ts` — so
+ * a dialog-focused test can `vi.resetModules()` this module's state without
+ * touching the toolbar/sidebar's independent ref-counts.
+ */
+import { createHostSlotSessionRuntime } from './host-slot-session-runtime.js';
+import { hostDialogRuntimePreloadPath } from '../../utils/paths.js';
+const runtime = createHostSlotSessionRuntime(hostDialogRuntimePreloadPath);
+export function acquireHostDialogSessionRuntime() {
+    runtime.acquire();
+}
+export function releaseHostDialogSessionRuntime() {
+    runtime.release();
+}
+//# sourceMappingURL=host-dialog-session-runtime.js.map