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

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

@@ -0,0 +1,91 @@
+/**
+ * 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 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. */
+export declare const MAX_SINGLE_DISPATCH_CHARS = 1000000;
+export declare const CHUNK_CHARS: number;
+/**
+ * Build the `executeJavaScript` source for a chunked dispatch of one large CDP
+ * message — DevTools' own transport caps a single `dispatchMessage` payload, so
+ * the front-end exposes `dispatchMessageChunk(messageChunk, messageSize)` where
+ * the FIRST chunk carries the total size and EVERY SUBSEQUENT chunk is called
+ * with the chunk ONLY (second arg omitted). This matches Chromium's
+ * `devtools_ui_bindings.cc` DispatchProtocolMessage, whose front-end treats a
+ * call with a second argument as the start of a new message and a call without
+ * one as a continuation. Passing 0 (the previous behaviour) risked the
+ * front-end mis-reading a continuation as a fresh 0-size message. Returns false
+ * 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

@@ -0,0 +1,148 @@
+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. */
+export const MAX_SINGLE_DISPATCH_CHARS = 1_000_000;
+export const CHUNK_CHARS = 256 * 1024;
+/**
+ * Build the `executeJavaScript` source for a chunked dispatch of one large CDP
+ * message — DevTools' own transport caps a single `dispatchMessage` payload, so
+ * the front-end exposes `dispatchMessageChunk(messageChunk, messageSize)` where
+ * the FIRST chunk carries the total size and EVERY SUBSEQUENT chunk is called
+ * with the chunk ONLY (second arg omitted). This matches Chromium's
+ * `devtools_ui_bindings.cc` DispatchProtocolMessage, whose front-end treats a
+ * call with a second argument as the start of a new message and a call without
+ * one as a continuation. Passing 0 (the previous behaviour) risked the
+ * front-end mis-reading a continuation as a fresh 0-size message. Returns false
+ * when the API isn't available.
+ */
+export function buildChunkedDispatchScript(chunks, totalSize) {
+    const arr = JSON.stringify(chunks);
+    return `(()=>{try{`
+        + `if(!(window.DevToolsAPI&&typeof window.DevToolsAPI.dispatchMessageChunk==='function'))return false;`
+        + `const cs=JSON.parse(${JSON.stringify(arr)});`
+        + `for(let i=0;i<cs.length;i++){`
+        + `try{`
+        // First chunk: (chunk, totalSize). Subsequent chunks: (chunk) — second arg
+        // omitted, NOT 0, per Chromium's continuation contract.
+        + `if(i===0){window.DevToolsAPI.dispatchMessageChunk(cs[i], ${totalSize})}`
+        + `else{window.DevToolsAPI.dispatchMessageChunk(cs[i])}`
+        + `}catch(_){}`
+        + `}`
+        + `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;
+    const entries = batch;
+    for (const raw of entries) {
+        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:` and `dimina:http:` 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 { BODY_REQUEST_ID_PREFIXES } from './request-ids.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(BODY_REQUEST_ID_PREFIXES);
+    return `(function(){try{
+    if (globalThis.__diminaGlobalNetworkHookInstalled) return 'already';
+    var OUT = (globalThis.__diminaGlobalNetworkOutbound = globalThis.__diminaGlobalNetworkOutbound || []);
+    var NET_METHODS = ${netMethods};
+    var VPREFIXES = ${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' && VPREFIXES.some(function(prefix){ return m.params.requestId.indexOf(prefix) === 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

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

@@ -0,0 +1,96 @@
+/**
+ * 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 async function flushMicrotasks() {
+    await Promise.resolve();
+    await Promise.resolve();
+}
+export function makeSimWc() {
+    let attached = false;
+    const listeners = new Map();
+    const sendCommand = vi.fn((_method, _params) => Promise.resolve({}));
+    const dbg = {
+        isAttached: () => attached,
+        attach: vi.fn(() => { attached = true; }),
+        detach: vi.fn(() => { attached = false; }),
+        sendCommand,
+        on: (ev, fn) => {
+            if (!listeners.has(ev))
+                listeners.set(ev, new Set());
+            listeners.get(ev).add(fn);
+        },
+        removeListener: (ev, fn) => {
+            listeners.get(ev)?.delete(fn);
+        },
+    };
+    const wc = {
+        isDestroyed: () => false,
+        debugger: dbg,
+        once: () => { },
+        removeListener: () => { },
+    };
+    const emitMessage = (method, params) => {
+        for (const fn of listeners.get('message') ?? [])
+            fn({}, method, params);
+    };
+    return { wc, dbg, sendCommand, emitMessage };
+}
+export function makeServiceWc() {
+    const exec = vi.fn((_script, _userGesture) => Promise.resolve(undefined));
+    const wc = { isDestroyed: () => false, executeJavaScript: exec };
+    return { wc, exec };
+}
+/**
+ * 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 function makeDevtoolsWc(apiReady = true, isLoading = () => false) {
+    const exec = vi.fn((_script, _userGesture) => Promise.resolve(typeof apiReady === 'function' ? apiReady() : apiReady));
+    const destroyedListeners = new Set();
+    const wc = {
+        isDestroyed: () => false,
+        isLoading,
+        getURL: () => 'devtools://devtools/bundled/devtools_app.html',
+        executeJavaScript: exec,
+        once: (ev, fn) => { if (ev === 'destroyed')
+            destroyedListeners.add(fn); },
+        removeListener: (ev, fn) => { if (ev === 'destroyed')
+            destroyedListeners.delete(fn); },
+    };
+    const emitDestroyed = () => { for (const fn of [...destroyedListeners])
+        fn(); };
+    return { wc, exec, emitDestroyed };
+}
+/** Decode the messages array embedded in a buildDispatchScript() source. */
+export function decodeDispatched(script) {
+    const start = script.indexOf('JSON.parse("');
+    if (start < 0)
+        return [];
+    let i = start + 'JSON.parse('.length;
+    const open = i;
+    i++;
+    for (; i < script.length; i++) {
+        if (script[i] === '\\') {
+            i++;
+            continue;
+        }
+        if (script[i] === '"')
+            break;
+    }
+    const literal = script.slice(open, i + 1);
+    const inner = JSON.parse(literal);
+    const arr = JSON.parse(inner);
+    return arr.map((s) => JSON.parse(s));
+}
+/** All events mirrored into a fake devtools host wc across every exec() call. */
+export function allDispatched(exec) {
+    return exec.mock.calls.flatMap((c) => decodeDispatched(String(c[0])));
+}
+//# sourceMappingURL=global-mirror-test-fixtures.js.map

package/dist/main/services/network-forward/http.d.ts

@@ -0,0 +1,47 @@
+import type { NativeRequestTrace } from "../../ipc/bridge-router.js";
+/** One CDP message ready for `DevToolsAPI.dispatchMessage` injection. */
+export interface SynthesizedRequestMessage {
+    method: string;
+    params: unknown;
+    /**
+     * The verdict `isUserFacingRequest` produced for this request's url at
+     * `sent` time, cached for the request's whole lifetime — every later event
+     * reuses it (they carry no url of their own). The user-facing sink gates
+     * on this; the global mirror ignores it.
+     */
+    userFacing: boolean;
+    /** Response body ready to prime the forwarder's body-cache, present only
+     * on the message synthesized from a `finished` trace event. */
+    body?: {
+        base64Encoded: boolean;
+        body: string;
+    };
+    /** Request post data ready to prime the forwarder's post-data cache,
+     * present only on the message synthesized from the `sent` trace event when
+     * the request carried a body. */
+    postData?: string;
+}
+export interface RequestTraceSynthesizerOptions {
+    /** Per-forwarder instance tag keeping virtual ids collision-free. */
+    epoch: string;
+    /**
+     * Origins the app itself serves (resource server / simulator shell), the
+     * same inputs `resolveUserFacing` feeds `isUserFacingRequest` for
+     * simulator-captured HTTP traffic. Re-read at each initial `sent`; redirects retain that verdict.
+     */
+    internalOrigins?: () => ReadonlyArray<string | null | undefined>;
+}
+export declare class RequestTraceSynthesizer {
+    private readonly options;
+    private readonly requests;
+    private seq;
+    constructor(options: RequestTraceSynthesizerOptions);
+    /**
+     * Map one trace event to its CDP message, or null when the event must be
+     * dropped (a non-`sent` event for a requestId this synthesizer never saw
+     * sent — defensive against out-of-order delivery).
+     */
+    synthesize(sessionId: string, event: NativeRequestTrace): SynthesizedRequestMessage | null;
+    private synthesizeRequest;
+}
+//# sourceMappingURL=http.d.ts.map