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

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/mcp/server.js

@@ -39,7 +39,6 @@ export function startMcpServer(resolvedCdpPort, mcpPort) {
     // Connect to both targets (non-blocking)
     connectTarget('simulator').catch(() => { });
     connectTarget('workbench').catch(() => { });
-    const server = buildServer();
     const transports = new Map();
     const httpServer = createServer(async (req, res) => {
         const url = new URL(req.url ?? '/', `http://localhost`);
@@ -47,7 +46,30 @@ export function startMcpServer(resolvedCdpPort, mcpPort) {
             const transport = new SSEServerTransport('/message', res);
             transports.set(transport.sessionId, transport);
             res.on('close', () => transports.delete(transport.sessionId));
-            await server.connect(transport);
+            try {
+                // A fresh McpServer PER CONNECTION: the SDK's Protocol is strictly
+                // 1:1 with its transport (`connect()` throws "Already connected to a
+                // transport" if `this._transport` is already set), so reusing one
+                // global server across concurrent SSE clients breaks every
+                // connection after the first. Registration only builds tool-call
+                // closures over already-shared module-level state (target-manager's
+                // CDP connections/listeners) — it has no per-call side effects, so
+                // building N servers is cheap and duplicates nothing.
+                await buildServer().connect(transport);
+            }
+            catch (err) {
+                transports.delete(transport.sessionId);
+                // `connect()` calls `transport.start()` (writes the SSE 200 + headers)
+                // BEFORE it can throw, so a post-start failure here has already sent
+                // headers — writeHead would itself throw. End the response instead so
+                // the client's stream closes cleanly rather than hanging forever with
+                // an open connection nothing will ever write to again.
+                if (!res.headersSent)
+                    res.writeHead(500).end('MCP connect failed');
+                else
+                    res.end();
+                console.error('[MCP] SSE connect failed:', err);
+            }
         }
         else if (req.method === 'POST' && url.pathname === '/message') {
             const sessionId = url.searchParams.get('sessionId') ?? '';

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

package/dist/main/services/network-forward/global-mirror-test-fixtures.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Shared test scaffolding for the Phase 2 "global mirror" test suites
+ * (`global-mirror.test.ts` + `global-mirror-bugfixes.test.ts`), split out so
+ * neither test file needs to duplicate these fixtures. Pure test scaffolding,
+ * not the code under test — see network-forward/index.test.ts for the
+ * canonical source these were originally copied from.
+ */
+import { vi } from 'vitest';
+export declare function flushMicrotasks(): Promise<void>;
+export declare function makeSimWc(): {
+    wc: Electron.WebContents;
+    dbg: {
+        isAttached: () => boolean;
+        attach: import("vitest").Mock<() => void>;
+        detach: import("vitest").Mock<() => void>;
+        sendCommand: import("vitest").Mock<(_method: string, _params?: object) => Promise<unknown>>;
+        on: (ev: string, fn: (...args: unknown[]) => void) => void;
+        removeListener: (ev: string, fn: (...args: unknown[]) => void) => void;
+    };
+    sendCommand: import("vitest").Mock<(_method: string, _params?: object) => Promise<unknown>>;
+    emitMessage: (method: string, params: unknown) => void;
+};
+export declare function makeServiceWc(): {
+    wc: Electron.WebContents;
+    exec: import("vitest").Mock<(_script: string, _userGesture?: boolean) => Promise<undefined>>;
+};
+/**
+ * A DevTools FRONT-END host wc. The injected dispatch script returns `true` when
+ * `window.DevToolsAPI.dispatchMessage` is "present", so the fake resolves the
+ * configured value to simulate the API being ready (true) or still booting
+ * (false → forwarder retries / falls back).
+ */
+export declare function makeDevtoolsWc(apiReady?: boolean | (() => boolean), isLoading?: () => boolean): {
+    wc: Electron.WebContents;
+    exec: import("vitest").Mock<(_script: string, _userGesture?: boolean) => Promise<boolean>>;
+    emitDestroyed: () => void;
+};
+/** Decode the messages array embedded in a buildDispatchScript() source. */
+export declare function decodeDispatched(script: string): Array<{
+    method: string;
+    params: unknown;
+}>;
+/** All events mirrored into a fake devtools host wc across every exec() call. */
+export declare function allDispatched(exec: ReturnType<typeof vi.fn>): Array<{
+    method: string;
+    params: unknown;
+}>;
+//# sourceMappingURL=global-mirror-test-fixtures.d.ts.map