@dimina-kit/devtools 0.4.0-dev.20260718143821 → 0.4.0-dev.20260728063215

package/dist/main/services/console-forward/open-gated-relay.d.ts

@@ -0,0 +1,67 @@
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+/**
+ * Generic open/close-gated replay-subscription primitive shared by
+ * `createGlobalConsoleMirror` and `createGlobalDiagnosticsMirror` — both
+ * gate their subscription to a buffered+replayable source
+ * (`ConsoleForwarder`/`DiagnosticsBus`) on whether the standalone "debug the
+ * whole Electron app" window is currently open (`onHostChanged`): each open
+ * re-subscribes with `{replay:true}` so history is never lost even if the
+ * window opens long after boot, and each close disposes that subscription.
+ *
+ * ── Dedup (the e2e-confirmed bug this fixes) ────────────────────────────────
+ * Naively re-subscribing with `{replay:true}` on every reopen double-injects
+ * history: Chromium's own per-frame `ConsoleMessageStorage` is NOT cleared by
+ * closing DevTools (only by navigation), so it natively re-delivers entries
+ * already shown during a PREVIOUS open to the freshly-attached front-end —
+ * and if this relay ALSO blindly replays and re-injects the same buffered
+ * objects, every entry shown once ends up displayed twice on reopen, the
+ * duplicate carrying a fresh (wrong) "just reopened" timestamp instead of
+ * when it actually happened.
+ *
+ * Fix: `state` is a `WeakMap` keyed by OBJECT REFERENCE (never content — two
+ * content-identical-but-distinct entries must each still get injected once)
+ * that persists across the relay's ENTIRE lifetime, not reset by open/close.
+ * A replay that re-delivers an already-CONFIRMED-injected object is skipped;
+ * only entries never physically (and successfully) passed to `inject()`
+ * before (e.g. ones that arrived while the window was closed) actually call
+ * `inject()`. Chromium's own native re-delivery is left to show the
+ * once-injected ones — that is what makes reopening not double them up. This
+ * also composes correctly with the source's own bounded ring buffer: an
+ * evicted entry is simply absent from the next replay batch entirely, so it
+ * can never be double-counted regardless of what `state` holds.
+ *
+ * ── inject() is fallible — only a CONFIRMED success may ever mark "done" ───
+ * `inject()` wraps an async `executeJavaScript` against a possibly-destroyed
+ * or not-yet-settled target, so it reports whether the entry was ACTUALLY
+ * delivered via `boolean | Promise<boolean>`. Marking an entry "injected"
+ * before that outcome is known (the original bug here) means a single
+ * transient failure — target destroyed, front-end not settled, a rejected
+ * `executeJavaScript` — permanently black-holes that entry: every future
+ * replay skips it forever, even though it was never actually shown anywhere
+ * (violates this repo's "state must be marked at the moment the fact
+ * actually happens" principle — this was marking INTENT, not the fact). So
+ * `state` tracks three phases per entry: absent (never attempted, or a prior
+ * attempt failed and was cleared — eligible for `inject()`), `'pending'`
+ * (an `inject()` call is in flight — a concurrent replay of the SAME entry
+ * must not trigger a second concurrent call), `'done'` (confirmed success —
+ * permanently skipped from here on). A `false` result or a rejection resets
+ * the entry back to absent, so the next replay (e.g. the next window reopen)
+ * gets a real retry instead of a silent, permanent loss.
+ */
+export interface OpenGatedRelayOptions {
+    /**
+     * Bounds how long ONE in-flight `inject()` attempt may hold an entry
+     * `'pending'`. An `inject()` promise that never settles (real incident:
+     * `executeJavaScript` against a wc that is simultaneously the inspected
+     * side of `setDevToolsWebContents` AND attached by an external CDP client
+     * hangs forever) would otherwise black-hole the entry permanently — never
+     * shown, never retried. Past this bound the entry becomes retryable again
+     * on the next replay. The timed-out attempt's promise may still settle
+     * LATE; its settlement is generation-stamped and ignored when stale.
+     */
+    injectTimeoutMs?: number;
+}
+export declare function createOpenGatedRelay<TEntry extends object, THost = unknown>(onHostChanged: (handler: (host: THost | null) => void) => () => void, subscribe: (sink: (entry: TEntry) => void, opts: {
+    replay: true;
+}) => Disposable, inject: (entry: TEntry) => boolean | Promise<boolean>, opts?: OpenGatedRelayOptions): Disposable;
+//# sourceMappingURL=open-gated-relay.d.ts.map

package/dist/main/services/console-forward/open-gated-relay.js

@@ -0,0 +1,55 @@
+const DEFAULT_INJECT_TIMEOUT_MS = 10_000;
+export function createOpenGatedRelay(onHostChanged, subscribe, inject, opts) {
+    const injectTimeoutMs = opts?.injectTimeoutMs ?? DEFAULT_INJECT_TIMEOUT_MS;
+    // Generation stamp per attempt: only the attempt matching the entry's
+    // CURRENT pending generation may act on settling — a stale (timed-out,
+    // superseded) attempt's late result must neither mark the entry done nor
+    // disturb a newer attempt's pending status.
+    const state = new WeakMap();
+    let generationSeq = 0;
+    const inFlightTimers = new Set();
+    let live = null;
+    function deliver(entry) {
+        if (state.has(entry))
+            return;
+        const generation = ++generationSeq;
+        state.set(entry, { phase: 'pending', generation });
+        const timer = setTimeout(() => {
+            inFlightTimers.delete(timer);
+            const cur = state.get(entry);
+            if (cur && cur.phase === 'pending' && cur.generation === generation)
+                state.delete(entry);
+        }, injectTimeoutMs);
+        timer.unref?.();
+        inFlightTimers.add(timer);
+        const settle = (ok) => {
+            clearTimeout(timer);
+            inFlightTimers.delete(timer);
+            const cur = state.get(entry);
+            if (!cur || cur.phase !== 'pending' || cur.generation !== generation)
+                return;
+            if (ok)
+                state.set(entry, { phase: 'done', generation });
+            else
+                state.delete(entry);
+        };
+        Promise.resolve()
+            .then(() => inject(entry))
+            .then((ok) => settle(ok === true), () => settle(false));
+    }
+    const unregister = onHostChanged((host) => {
+        live?.dispose();
+        live = host !== null ? subscribe(deliver, { replay: true }) : null;
+    });
+    return {
+        dispose: () => {
+            for (const timer of inFlightTimers)
+                clearTimeout(timer);
+            inFlightTimers.clear();
+            live?.dispose();
+            live = null;
+            unregister();
+        },
+    };
+}
+//# sourceMappingURL=open-gated-relay.js.map

package/dist/main/services/diagnostics/index.d.ts

@@ -20,6 +20,15 @@ export interface Diagnostic {
     message: string;
     appSessionId?: string;
     ts: number;
+    /**
+     * Who this diagnostic is for. `'internal'` means devtools-tooling-only
+     * state (e.g. compile-standby's warm-pool lifecycle) that must never reach
+     * the per-project service-host console the right-panel CDP is attached to
+     * — see `console-forward/index.ts`'s `handleDiagnostic` gate. `'user'` or
+     * omitted means the existing behavior: a real diagnostic about the
+     * inspected mini-program, injected into that project's Console panel.
+     */
+    audience?: 'user' | 'internal';
 }
 export interface DiagnosticsBus {
     /** Record one diagnostic: buffers it, mirrors it to the main-process console, and synchronously notifies every live subscriber. No-op after `dispose()`. */
@@ -28,6 +37,7 @@ export interface DiagnosticsBus {
         code: string;
         message: string;
         appSessionId?: string;
+        audience?: 'user' | 'internal';
     }): void;
     /**
      * Register a sink. With `replay` (default true) the sink is first called,

package/dist/main/services/elements-forward/index.js

@@ -1,6 +1,6 @@
 import { isFrontendSettled } from '../views/inject-when-ready.js';
 import { VIRTUAL_REQUEST_ID_PREFIX } from '../network-forward/index.js';
-import { PROBE_DEVTOOLS_API, MAX_SINGLE_DISPATCH_CHARS, CHUNK_CHARS, buildChunkedDispatchScript } from '../network-forward/frontend-dispatch.js';
+import { buildSingleDispatchScript, createFrontendReplyChannel, answerNetworkBodyCommand, drainOutboundBatch } from '../network-forward/frontend-dispatch.js';
 import { createCdpSessionBroker } from '../cdp-session/index.js';
 /**
  * CDP domains that target the RENDER GUEST'S document tree. A command in one of
@@ -153,18 +153,10 @@ function buildReconcileScript() {
         + `})()`;
 }
 // ── main → front-end dispatch (shared transport with network-forward) ───────
-/** Dispatch ONE small CDP message (response or event) into the front-end. */
-function buildDispatchScript(message) {
-    return `(()=>{try{`
-        + `if(!${PROBE_DEVTOOLS_API})return false;`
-        + `window.DevToolsAPI.dispatchMessage(JSON.parse(${JSON.stringify(message)}));`
-        + `return true;`
-        + `}catch(_){return false}})()`;
-}
 /** Script that nudges the front-end to discard its document and lazily re-pull. */
 function buildDocumentUpdatedScript() {
     const msg = JSON.stringify({ method: 'DOM.documentUpdated', params: {} });
-    return buildDispatchScript(msg);
+    return buildSingleDispatchScript(msg);
 }
 // Reconcile cadence: each tick re-asserts the hook (idempotent) and drains the
 // outbound queue. Fast enough that a freshly reloaded front-end is re-hooked
@@ -241,47 +233,12 @@ export function installElementsForward(deps) {
             catch { /* already gone */ }
         }
     };
-    // ── main → front-end dispatch ──────────────────────────────────────────────
-    function dispatchToFrontend(message) {
-        if (disposed || devtoolsWc.isDestroyed())
-            return;
-        // Unified settled gate (same predicate as the reconcile tick): an unsettled
-        // front-end wipes its state on load anyway, so the message is meaningless
-        // there — and the executeJavaScript would queue one did-stop-loading waiter
-        // per push (an activePage burst piles them). The post-settle tick re-primes.
-        if (!isFrontendSettled(devtoolsWc))
-            return;
-        let json;
-        try {
-            json = JSON.stringify(message);
-        }
-        catch {
-            return;
-        }
-        if (json.length > MAX_SINGLE_DISPATCH_CHARS) {
-            const chunks = [];
-            for (let i = 0; i < json.length; i += CHUNK_CHARS) {
-                chunks.push(json.slice(i, i + CHUNK_CHARS));
-            }
-            let script;
-            try {
-                script = buildChunkedDispatchScript(chunks, json.length);
-            }
-            catch {
-                return;
-            }
-            devtoolsWc.executeJavaScript(script, true).catch(() => { });
-            return;
-        }
-        let script;
-        try {
-            script = buildDispatchScript(json);
-        }
-        catch {
-            return;
-        }
-        devtoolsWc.executeJavaScript(script, true).catch(() => { });
-    }
+    // ── main → front-end dispatch (shared transport, see frontend-dispatch.js) ──
+    // Reply to a front-end command id, passing the ORIGINAL id + sessionId
+    // straight through (no mapping) — the same settled-gate + chunking +
+    // reply-shape contract network-forward's global body gate uses, so the two
+    // outbound-gate features can never drift.
+    const { dispatchToFrontend, replyResult, replyError } = createFrontendReplyChannel(devtoolsWc, () => disposed);
     /** Tell the front-end its document is stale → it re-pulls lazily (routed). */
     function pushDocumentUpdated() {
         if (disposed || devtoolsWc.isDestroyed())
@@ -299,22 +256,6 @@ export function installElementsForward(deps) {
         }
         devtoolsWc.executeJavaScript(script, true).catch(() => { });
     }
-    /**
-     * Reply to a front-end command id, passing the ORIGINAL id + sessionId straight
-     * through (no mapping). Only the front-end-supplied sessionId is echoed back.
-     */
-    function replyResult(cmd, result) {
-        const msg = { id: cmd.id, result };
-        if (cmd.sessionId)
-            msg.sessionId = cmd.sessionId;
-        dispatchToFrontend(msg);
-    }
-    function replyError(cmd, message) {
-        const msg = { id: cmd.id, error: { code: -32000, message } };
-        if (cmd.sessionId)
-            msg.sessionId = cmd.sessionId;
-        dispatchToFrontend(msg);
-    }
     // ── render-guest CDP session (via the shared broker) ────────────────────────
     /** The active render guest, re-resolved fresh (pool/page swaps go stale). */
     function activeRenderWc() {
@@ -450,46 +391,23 @@ export function installElementsForward(deps) {
     /**
      * Answer a network-routed command from the provider. Never touches the render
      * guest: the body lives in the network forwarder's prefetch cache (or
-     * nowhere). A missing provider or a rejected lookup settles the command with
-     * the canonical CDP not-found error so the front-end renders its normal
-     * failure state instead of leaking a forever-pending request.
+     * nowhere). Shared with network-forward's dedicated global body gate — see
+     * answerNetworkBodyCommand's doc comment for the not-found/reply contract.
      */
     function answerNetworkCommand(cmd) {
-        const provider = deps.network;
-        const requestId = cmd.params?.requestId;
-        if (!provider || typeof requestId !== 'string') {
-            replyError(cmd, 'No resource with given identifier found');
-            return;
-        }
-        const lookup = cmd.method === 'Network.getRequestPostData'
-            ? provider.getRequestPostData(requestId)
-            : provider.getResponseBody(requestId);
-        lookup.then((result) => {
-            if (!disposed)
-                replyResult(cmd, result);
-        }, (err) => {
-            if (!disposed)
-                replyError(cmd, err instanceof Error ? err.message : String(err));
-        });
+        answerNetworkBodyCommand(cmd, deps.network, { replyResult, replyError });
     }
     /** Process a drained batch of front-end commands, splitting by route tag. */
     function handleOutbound(batch) {
-        if (!Array.isArray(batch))
-            return;
-        for (const raw of batch) {
-            if (!raw || typeof raw !== 'object')
-                continue;
-            const cmd = raw;
-            if (typeof cmd.method !== 'string')
-                continue;
+        drainOutboundBatch(batch, (cmd) => {
             if (cmd.route === 'network') {
                 answerNetworkCommand(cmd);
-                continue;
+                return;
             }
             // 'render' — and any untagged legacy payload, which only ever carried
             // render-domain commands.
             routeCommand(cmd);
-        }
+        });
     }
     // ── follow the active guest across page switches ───────────────────────────
     const onRenderEvent = (event) => {

package/dist/main/services/network-forward/frontend-dispatch.d.ts

@@ -6,6 +6,7 @@
  * same transport contract; a single copy means the two can never drift on the
  * chunk-continuation protocol.
  */
+import type { WebContents } from 'electron';
 /** Probe the front-end realm exposes `DevToolsAPI.dispatchMessage`. */
 export declare const PROBE_DEVTOOLS_API = "(window.DevToolsAPI && typeof window.DevToolsAPI.dispatchMessage === 'function')";
 /** A single dispatch payload may not exceed this many UTF-16 chars; chunk above. */
@@ -24,4 +25,67 @@ export declare const CHUNK_CHARS: number;
  * when the API isn't available.
  */
 export declare function buildChunkedDispatchScript(chunks: string[], totalSize: number): string;
+/** Build the `executeJavaScript` source that dispatches ONE small CDP message
+ *  (a response or event) into the front-end. Above `MAX_SINGLE_DISPATCH_CHARS`,
+ *  callers must use {@link buildChunkedDispatchScript} instead. */
+export declare function buildSingleDispatchScript(message: string): string;
+/** One CDP command awaiting a reply — the minimal shape every outbound-gate
+ *  (elements-forward, network-forward's global body gate) reads to answer. */
+export interface ReplyableCommand {
+    id: number | null;
+    sessionId: string | null;
+}
+export interface FrontendReplyChannel {
+    /** Push an arbitrary CDP-shaped message (response OR event) into the
+     *  front-end, auto-chunking above the single-dispatch size cap. */
+    dispatchToFrontend(message: unknown): void;
+    /** Reply to a front-end command id with a successful `result`. */
+    replyResult(cmd: ReplyableCommand, result: unknown): void;
+    /** Reply to a front-end command id with the canonical CDP not-found-style
+     *  error shape, so the front-end renders its normal failure state instead
+     *  of leaking a forever-pending request. */
+    replyError(cmd: ReplyableCommand, message: string): void;
+}
+/**
+ * Shared main → front-end reply transport for every outbound CDP gate that
+ * answers commands it intercepted from `InspectorFrontendHost.sendMessageToBackend`
+ * (elements-forward's render/network routing, network-forward's dedicated
+ * global body gate). A single copy means the two features can never drift on
+ * the settled-gate check, the chunking threshold, or the CDP reply shape.
+ */
+export declare function createFrontendReplyChannel(hostWc: WebContents, isDisposed: () => boolean): FrontendReplyChannel;
+/**
+ * Validate + iterate a drained outbound-command batch (the front-end →
+ * main half of every poll-based outbound CDP gate): skips non-array batches,
+ * skips malformed entries, and only ever hands `handle` an item whose
+ * `method` is a string. Shared by elements-forward's render/network router
+ * and network-forward's dedicated global body gate so the two can never
+ * silently diverge on what counts as "well-formed".
+ */
+export declare function drainOutboundBatch<T extends {
+    method: unknown;
+}>(batch: unknown, handle: (cmd: T) => void): void;
+/** Minimal structural shape `answerNetworkBodyCommand` needs — satisfied by
+ *  the real `NetworkBodyProvider` (network-forward/index.ts) without either
+ *  module importing the other (that would be circular: index.ts already
+ *  imports from this file). */
+export interface NetworkBodyLookup {
+    getResponseBody(requestId: string): Promise<unknown>;
+    getRequestPostData(requestId: string): Promise<unknown>;
+}
+/**
+ * Answer one drained front-end command that requested a virtual requestId's
+ * response body / post data — the shared "network" branch every outbound CDP
+ * gate that intercepts `Network.getResponseBody`/`Network.getRequestPostData`
+ * needs (elements-forward's render/network router, network-forward's
+ * dedicated global body gate). A missing provider or a rejected lookup
+ * settles with the canonical CDP not-found error so the front-end renders
+ * its normal failure state instead of leaking a forever-pending request.
+ * `reply.replyResult`/`replyError` (from {@link createFrontendReplyChannel})
+ * already no-op once disposed, so this never needs its own disposed guard.
+ */
+export declare function answerNetworkBodyCommand(cmd: ReplyableCommand & {
+    method: string;
+    params: unknown;
+}, provider: NetworkBodyLookup | undefined, reply: Pick<FrontendReplyChannel, 'replyResult' | 'replyError'>): void;
 //# sourceMappingURL=frontend-dispatch.d.ts.map

package/dist/main/services/network-forward/frontend-dispatch.js

@@ -1,11 +1,4 @@
-/**
- * Shared `executeJavaScript` builders for pushing raw CDP messages into the
- * embedded Chrome DevTools front-end via `window.DevToolsAPI.dispatchMessage`
- * / `dispatchMessageChunk`. Both network-forward (Network tab injection) and
- * elements-forward (Elements tab / render-event re-injection) need the exact
- * same transport contract; a single copy means the two can never drift on the
- * chunk-continuation protocol.
- */
+import { isFrontendSettled } from '../views/inject-when-ready.js';
 /** Probe the front-end realm exposes `DevToolsAPI.dispatchMessage`. */
 export const PROBE_DEVTOOLS_API = `(window.DevToolsAPI && typeof window.DevToolsAPI.dispatchMessage === 'function')`;
 /** A single dispatch payload may not exceed this many UTF-16 chars; chunk above. */
@@ -39,4 +32,116 @@ export function buildChunkedDispatchScript(chunks, totalSize) {
         + `return true;`
         + `}catch(_){return false}})()`;
 }
+/** Build the `executeJavaScript` source that dispatches ONE small CDP message
+ *  (a response or event) into the front-end. Above `MAX_SINGLE_DISPATCH_CHARS`,
+ *  callers must use {@link buildChunkedDispatchScript} instead. */
+export function buildSingleDispatchScript(message) {
+    return `(()=>{try{`
+        + `if(!${PROBE_DEVTOOLS_API})return false;`
+        + `window.DevToolsAPI.dispatchMessage(JSON.parse(${JSON.stringify(message)}));`
+        + `return true;`
+        + `}catch(_){return false}})()`;
+}
+/**
+ * Shared main → front-end reply transport for every outbound CDP gate that
+ * answers commands it intercepted from `InspectorFrontendHost.sendMessageToBackend`
+ * (elements-forward's render/network routing, network-forward's dedicated
+ * global body gate). A single copy means the two features can never drift on
+ * the settled-gate check, the chunking threshold, or the CDP reply shape.
+ */
+export function createFrontendReplyChannel(hostWc, isDisposed) {
+    function dispatchToFrontend(message) {
+        if (isDisposed() || hostWc.isDestroyed())
+            return;
+        // An unsettled front-end wipes its state on load anyway (message would be
+        // meaningless there), and executeJavaScript against it queues one
+        // did-stop-loading waiter per push — skip; the next settled tick re-primes.
+        if (!isFrontendSettled(hostWc))
+            return;
+        let json;
+        try {
+            json = JSON.stringify(message);
+        }
+        catch {
+            return;
+        }
+        if (json.length > MAX_SINGLE_DISPATCH_CHARS) {
+            const chunks = [];
+            for (let i = 0; i < json.length; i += CHUNK_CHARS)
+                chunks.push(json.slice(i, i + CHUNK_CHARS));
+            let script;
+            try {
+                script = buildChunkedDispatchScript(chunks, json.length);
+            }
+            catch {
+                return;
+            }
+            hostWc.executeJavaScript(script, true).catch(() => { });
+            return;
+        }
+        let script;
+        try {
+            script = buildSingleDispatchScript(json);
+        }
+        catch {
+            return;
+        }
+        hostWc.executeJavaScript(script, true).catch(() => { });
+    }
+    function replyResult(cmd, result) {
+        const msg = { id: cmd.id, result };
+        if (cmd.sessionId)
+            msg.sessionId = cmd.sessionId;
+        dispatchToFrontend(msg);
+    }
+    function replyError(cmd, message) {
+        const msg = { id: cmd.id, error: { code: -32000, message } };
+        if (cmd.sessionId)
+            msg.sessionId = cmd.sessionId;
+        dispatchToFrontend(msg);
+    }
+    return { dispatchToFrontend, replyResult, replyError };
+}
+/**
+ * Validate + iterate a drained outbound-command batch (the front-end →
+ * main half of every poll-based outbound CDP gate): skips non-array batches,
+ * skips malformed entries, and only ever hands `handle` an item whose
+ * `method` is a string. Shared by elements-forward's render/network router
+ * and network-forward's dedicated global body gate so the two can never
+ * silently diverge on what counts as "well-formed".
+ */
+export function drainOutboundBatch(batch, handle) {
+    if (!Array.isArray(batch))
+        return;
+    for (const raw of batch) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const cmd = raw;
+        if (typeof cmd.method !== 'string')
+            continue;
+        handle(cmd);
+    }
+}
+/**
+ * Answer one drained front-end command that requested a virtual requestId's
+ * response body / post data — the shared "network" branch every outbound CDP
+ * gate that intercepts `Network.getResponseBody`/`Network.getRequestPostData`
+ * needs (elements-forward's render/network router, network-forward's
+ * dedicated global body gate). A missing provider or a rejected lookup
+ * settles with the canonical CDP not-found error so the front-end renders
+ * its normal failure state instead of leaking a forever-pending request.
+ * `reply.replyResult`/`replyError` (from {@link createFrontendReplyChannel})
+ * already no-op once disposed, so this never needs its own disposed guard.
+ */
+export function answerNetworkBodyCommand(cmd, provider, reply) {
+    const requestId = cmd.params?.requestId;
+    if (!provider || typeof requestId !== 'string') {
+        reply.replyError(cmd, 'No resource with given identifier found');
+        return;
+    }
+    const lookup = cmd.method === 'Network.getRequestPostData'
+        ? provider.getRequestPostData(requestId)
+        : provider.getResponseBody(requestId);
+    lookup.then((result) => reply.replyResult(cmd, result), (err) => reply.replyError(cmd, err instanceof Error ? err.message : String(err)));
+}
 //# sourceMappingURL=frontend-dispatch.js.map

package/dist/main/services/network-forward/global-body-gate.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Dedicated, NETWORK-ONLY outbound CDP gate for the standalone internal
+ * (app-wide) DevTools window's front-end.
+ *
+ * ── Why a SEPARATE gate from elements-forward ───────────────────────────────
+ * elements-forward's `InspectorFrontendHost.sendMessageToBackend` hook
+ * (see ../elements-forward/index.ts) ALSO intercepts DOM/CSS/Overlay commands
+ * and redirects them to the active render guest — correct for the RIGHT-panel
+ * CDP (which inspects the service host but wants Elements to reflect the
+ * render guest's live DOM), but WRONG for the global window: its Elements/
+ * Sources/Console should inspect `mainWindow` NATIVELY, with zero redirection.
+ * Installing the full elements-forward gate here would silently reroute the
+ * global window's Elements panel to the wrong target. This module intercepts
+ * ONLY `Network.getResponseBody` / `Network.getRequestPostData` for
+ * `dimina:sim:` virtual requestIds; every other command (including all
+ * DOM/CSS/Overlay/Runtime/Debugger/…) passes straight through untouched.
+ *
+ * ── Mechanism (same two-way poll bridge as elements-forward) ───────────────
+ * front-end → main: wrap `InspectorFrontendHost.sendMessageToBackend`; a
+ * matching command is pushed onto `globalThis.__diminaGlobalNetworkOutbound`
+ * and NOT forwarded to the original channel; everything else calls through.
+ * main → front-end: answer via `window.DevToolsAPI.dispatchMessage` (chunked
+ * for large bodies), reusing the same transport network-forward's primary
+ * sink uses.
+ *
+ * Degradation: hook unavailable / host destroyed / a lookup rejects → the
+ * command settles with the standard CDP not-found error (same as an unknown
+ * id would get from the real backend) — never throws, never blocks anything
+ * else in the window.
+ */
+import type { WebContents } from 'electron';
+import type { NetworkBodyProvider } from './index.js';
+/**
+ * The JS injected into the DevTools front-end realm. Idempotent (sentinel
+ * guard, distinct from elements-forward's — the two gates coexist on
+ * DIFFERENT host wcs and never share a front-end, but the sentinel is scoped
+ * defensively anyway).
+ */
+export declare function buildNetworkOnlyHookScript(): string;
+/**
+ * Install the gate on `hostWc` (the global window's front-end host).
+ * Returns a disposer that stops the reconcile loop. Best-effort throughout —
+ * never throws, degrades to CDP not-found on any failure.
+ */
+export declare function installGlobalNetworkBodyGate(hostWc: WebContents, bodies: NetworkBodyProvider): () => void;
+//# sourceMappingURL=global-body-gate.d.ts.map

package/dist/main/services/network-forward/global-body-gate.js

@@ -0,0 +1,93 @@
+import { isFrontendSettled } from '../views/inject-when-ready.js';
+import { VIRTUAL_REQUEST_ID_PREFIX } from './index.js';
+import { createFrontendReplyChannel, answerNetworkBodyCommand, drainOutboundBatch } from './frontend-dispatch.js';
+/** The only two Network.* commands this gate ever intercepts. */
+const NETWORK_BODY_METHODS = ['Network.getResponseBody', 'Network.getRequestPostData'];
+const DRAIN_INTERVAL_MS = 150;
+/**
+ * The JS injected into the DevTools front-end realm. Idempotent (sentinel
+ * guard, distinct from elements-forward's — the two gates coexist on
+ * DIFFERENT host wcs and never share a front-end, but the sentinel is scoped
+ * defensively anyway).
+ */
+export function buildNetworkOnlyHookScript() {
+    const netMethods = JSON.stringify(NETWORK_BODY_METHODS);
+    const vprefix = JSON.stringify(VIRTUAL_REQUEST_ID_PREFIX);
+    return `(function(){try{
+    if (globalThis.__diminaGlobalNetworkHookInstalled) return 'already';
+    var OUT = (globalThis.__diminaGlobalNetworkOutbound = globalThis.__diminaGlobalNetworkOutbound || []);
+    var NET_METHODS = ${netMethods};
+    var VPREFIX = ${vprefix};
+    function isNetworkBody(m){
+      if (!m || !m.method) return false;
+      if (NET_METHODS.indexOf(m.method) < 0) return false;
+      return !!(m.params && typeof m.params.requestId === 'string' && m.params.requestId.indexOf(VPREFIX) === 0);
+    }
+    var IFH = globalThis.InspectorFrontendHost;
+    if (IFH && typeof IFH.sendMessageToBackend === 'function' && !IFH.__diminaGlobalNetworkWrapped){
+      var origSend = IFH.sendMessageToBackend.bind(IFH);
+      IFH.sendMessageToBackend = function(message){
+        try {
+          var m = (typeof message === 'string') ? JSON.parse(message) : message;
+          if (isNetworkBody(m)){
+            OUT.push({ id: (m && typeof m.id === 'number') ? m.id : null,
+              method: m.method, params: m.params || {},
+              sessionId: (m && m.sessionId) ? m.sessionId : null });
+            return;
+          }
+        } catch(_){ /* fall through to original on any parse hiccup */ }
+        return origSend(message);
+      };
+      IFH.__diminaGlobalNetworkWrapped = true;
+      globalThis.__diminaGlobalNetworkHookInstalled = true;
+      return 'installed';
+    }
+    return 'partial';
+  }catch(e){ return 'error:' + (e && e.message); }})()`;
+}
+function buildReconcileScript() {
+    return `(function(){`
+        + `var status; try { status = ${buildNetworkOnlyHookScript()}; } catch(e){ status = 'error:'+(e&&e.message); }`
+        + `var batch = []; try { if (globalThis.__diminaGlobalNetworkOutbound) batch = globalThis.__diminaGlobalNetworkOutbound.splice(0); } catch(_){}`
+        + `return { status: status, batch: batch };`
+        + `})()`;
+}
+/**
+ * Install the gate on `hostWc` (the global window's front-end host).
+ * Returns a disposer that stops the reconcile loop. Best-effort throughout —
+ * never throws, degrades to CDP not-found on any failure.
+ */
+export function installGlobalNetworkBodyGate(hostWc, bodies) {
+    let disposed = false;
+    let reconcileTimer = null;
+    const reply = createFrontendReplyChannel(hostWc, () => disposed);
+    function handleOutbound(batch) {
+        drainOutboundBatch(batch, (cmd) => answerNetworkBodyCommand(cmd, bodies, reply));
+    }
+    reconcileTimer = setInterval(() => {
+        if (disposed || hostWc.isDestroyed()) {
+            stop();
+            return;
+        }
+        if (!isFrontendSettled(hostWc))
+            return;
+        hostWc
+            .executeJavaScript(buildReconcileScript())
+            .then((res) => {
+            if (disposed)
+                return;
+            const r = (res ?? {});
+            handleOutbound(r.batch);
+        })
+            .catch(() => { });
+    }, DRAIN_INTERVAL_MS);
+    function stop() {
+        disposed = true;
+        if (reconcileTimer) {
+            clearInterval(reconcileTimer);
+            reconcileTimer = null;
+        }
+    }
+    return stop;
+}
+//# sourceMappingURL=global-body-gate.js.map