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

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

@@ -1,20 +1,15 @@
-import { SyncDisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
-import { isFrontendSettled } from '../views/inject-when-ready.js';
-import { packDispatchBatch } from './dispatch-batch.js';
-import { PrefetchCache, DEFAULT_PER_ENTRY_MAX_CHARS } from './body-cache.js';
-import { PROBE_DEVTOOLS_API, MAX_SINGLE_DISPATCH_CHARS, CHUNK_CHARS, buildChunkedDispatchScript } from './frontend-dispatch.js';
-import { createCdpSessionBroker } from '../cdp-session/index.js';
-import { isUserFacingRequest } from './user-facing.js';
-import { installGlobalNetworkBodyGate } from './global-body-gate.js';
-import { WebSocketTraceSynthesizer } from './websocket.js';
-/**
- * Namespace prefix of every virtual requestId this forwarder injects into the
- * DevTools front-end. SINGLE SOURCE for the literal: the front-end outbound
- * gate (elements-forward) keys its `Network.getResponseBody` /
- * `Network.getRequestPostData` interception on this exact prefix, so the two
- * modules can never drift apart on what counts as "one of ours".
- */
-export const VIRTUAL_REQUEST_ID_PREFIX = 'dimina:sim:';
+import { SyncDisposableRegistry, toDisposable, } from "@dimina-kit/electron-deck/main";
+import { isFrontendSettled } from "../views/inject-when-ready.js";
+import { packDispatchBatch } from "./dispatch-batch.js";
+import { PrefetchCache, DEFAULT_PER_ENTRY_MAX_CHARS } from "./body-cache.js";
+import { PROBE_DEVTOOLS_API, MAX_SINGLE_DISPATCH_CHARS, CHUNK_CHARS, buildChunkedDispatchScript, } from "./frontend-dispatch.js";
+import { createCdpSessionBroker, } from "../cdp-session/index.js";
+import { isUserFacingRequest } from "./user-facing.js";
+import { installGlobalNetworkBodyGate } from "./global-body-gate.js";
+import { WebSocketTraceSynthesizer } from "./websocket.js";
+import { RequestTraceSynthesizer } from "./http.js";
+import { VIRTUAL_REQUEST_ID_PREFIX } from "./request-ids.js";
+export { VIRTUAL_REQUEST_ID_PREFIX } from "./request-ids.js";
 // ── requestId namespacing (pure, testable) ──────────────────────────────────
 /**
  * CDP events whose `params.requestId` we rewrite into the virtual namespace.
@@ -24,32 +19,32 @@ export const VIRTUAL_REQUEST_ID_PREFIX = 'dimina:sim:';
  * included for that reason (rewrite-only today, not forwarded).
  */
 export const REWRITE_REQUEST_ID_METHODS = new Set([
-    'Network.requestWillBeSent',
-    'Network.requestWillBeSentExtraInfo',
-    'Network.responseReceived',
-    'Network.responseReceivedExtraInfo',
-    'Network.dataReceived',
-    'Network.loadingFinished',
-    'Network.loadingFailed',
-    'Network.requestServedFromCache',
-    'Network.resourceChangedPriority',
+    "Network.requestWillBeSent",
+    "Network.requestWillBeSentExtraInfo",
+    "Network.responseReceived",
+    "Network.responseReceivedExtraInfo",
+    "Network.dataReceived",
+    "Network.loadingFinished",
+    "Network.loadingFailed",
+    "Network.requestServedFromCache",
+    "Network.resourceChangedPriority",
     // 二期 (when WebSocket/EventSource forwarding lands): Network.webSocket*,
     // Network.eventSourceMessageReceived — keep ids namespaced once added here.
 ]);
 /** The Network.* methods this one-shot pass forwards to the front-end. */
 export const FORWARDED_METHODS = new Set([
-    'Network.requestWillBeSent',
-    'Network.requestWillBeSentExtraInfo',
-    'Network.responseReceived',
-    'Network.responseReceivedExtraInfo',
-    'Network.loadingFinished',
-    'Network.loadingFailed',
+    "Network.requestWillBeSent",
+    "Network.requestWillBeSentExtraInfo",
+    "Network.responseReceived",
+    "Network.responseReceivedExtraInfo",
+    "Network.loadingFinished",
+    "Network.loadingFailed",
     // `dataReceived` deliberately omitted (二期) — see header.
 ]);
 /** Methods that mark a request finished, so its id mapping can age out. */
 const TERMINAL_METHODS = new Set([
-    'Network.loadingFinished',
-    'Network.loadingFailed',
+    "Network.loadingFinished",
+    "Network.loadingFailed",
 ]);
 /**
  * Bounded, TTL'd raw→virtual requestId map with an active/retired split.
@@ -157,7 +152,7 @@ export function rewriteRequestId(method, params, ns) {
     if (!REWRITE_REQUEST_ID_METHODS.has(method))
         return { method, params };
     const p = params;
-    if (!p || typeof p.requestId !== 'string')
+    if (!p || typeof p.requestId !== "string")
         return { method, params };
     const virtual = ns.resolve(p.requestId);
     if (TERMINAL_METHODS.has(method))
@@ -174,12 +169,12 @@ export function rewriteRequestId(method, params, ns) {
  */
 function buildDispatchScript(messages) {
     const arr = JSON.stringify(messages);
-    return `(()=>{try{`
-        + `if(!${PROBE_DEVTOOLS_API})return false;`
-        + `const ms=JSON.parse(${JSON.stringify(arr)});`
-        + `for(const m of ms){try{window.DevToolsAPI.dispatchMessage(m)}catch(_){}}`
-        + `return true;`
-        + `}catch(_){return false}})()`;
+    return (`(()=>{try{` +
+        `if(!${PROBE_DEVTOOLS_API})return false;` +
+        `const ms=JSON.parse(${JSON.stringify(arr)});` +
+        `for(const m of ms){try{window.DevToolsAPI.dispatchMessage(m)}catch(_){}}` +
+        `return true;` +
+        `}catch(_){return false}})()`);
 }
 /**
  * Upper bound on the COMBINED size (in UTF-16 chars) of the messages packed into
@@ -197,13 +192,13 @@ const MAX_BATCH_CHARS = 512 * 1024;
  */
 function buildForwardScript(record) {
     const json = JSON.stringify(record);
-    return `(()=>{try{const r=JSON.parse(${JSON.stringify(json)});`
-        + `const tag='[网络]['+r.source+']';`
-        + `const head=r.method+' '+(r.status||'-')+' '+r.url;`
-        + `if(r.errorText){console.warn(tag,head,r.errorText)}`
-        + `else if(r.status>=400){console.warn(tag,head)}`
-        + `else{console.log(tag,head)}`
-        + `}catch(_){}})()`;
+    return (`(()=>{try{const r=JSON.parse(${JSON.stringify(json)});` +
+        `const tag='[网络]['+r.source+']';` +
+        `const head=r.method+' '+(r.status||'-')+' '+r.url;` +
+        `if(r.errorText){console.warn(tag,head,r.errorText)}` +
+        `else if(r.status>=400){console.warn(tag,head)}` +
+        `else{console.log(tag,head)}` +
+        `}catch(_){}})()`);
 }
 /** Cap so a long session can't grow the fallback pending map unboundedly. */
 const MAX_PENDING = 1000;
@@ -261,11 +256,19 @@ export function createNetworkForwarder(bridge) {
             return;
         pendingPrefetchCount++;
         let released = false;
-        const release = () => { if (!released) {
-            released = true;
-            pendingPrefetchCount--;
-        } };
-        const started = cache.prime(id, () => fetch().then((v) => { release(); return v; }, (err) => { release(); throw err; }));
+        const release = () => {
+            if (!released) {
+                released = true;
+                pendingPrefetchCount--;
+            }
+        };
+        const started = cache.prime(id, () => fetch().then((v) => {
+            release();
+            return v;
+        }, (err) => {
+            release();
+            throw err;
+        }));
         if (!started)
             release();
     }
@@ -300,7 +303,8 @@ export function createNetworkForwarder(bridge) {
     // Own (and dispose on this forwarder's own dispose()) a private broker only
     // when the caller didn't supply a shared one.
     const ownsBroker = !bridge.broker;
-    const broker = bridge.broker ?? createCdpSessionBroker({ connections: bridge.connections });
+    const broker = bridge.broker ??
+        createCdpSessionBroker({ connections: bridge.connections });
     // The DevTools front-end host wc (primary sink), set by the ViewManager.
     let devtoolsWc = null;
     // Teardown for the wc 'destroyed' watcher on the current host (clears the host).
@@ -380,7 +384,9 @@ export function createNetworkForwarder(bridge) {
             for (const msg of chunked)
                 dispatchChunked(target, msg);
             if (batch.length > 0) {
-                target.executeJavaScript(buildDispatchScript(batch), true).catch(() => { });
+                target.executeJavaScript(buildDispatchScript(batch), true).catch(() => {
+                    /* best-effort */
+                });
             }
         }
         globalPendingOverflowWarned = false;
@@ -418,18 +424,20 @@ export function createNetworkForwarder(bridge) {
             clearGlobalPending();
         };
         const reg = bridge.connections;
-        if (reg && typeof target.once === 'function') {
+        if (reg && typeof target.once === "function") {
             const owned = reg.acquire(target).own(onHostDestroyed);
             globalDevtoolsHostDisposable = toDisposable(() => owned.dispose());
         }
         else {
-            if (typeof target.once === 'function')
-                target.once('destroyed', onHostDestroyed);
+            if (typeof target.once === "function")
+                target.once("destroyed", onHostDestroyed);
             globalDevtoolsHostDisposable = toDisposable(() => {
                 try {
-                    target.removeListener?.('destroyed', onHostDestroyed);
+                    target.removeListener?.("destroyed", onHostDestroyed);
+                }
+                catch {
+                    /* gone */
                 }
-                catch { /* gone */ }
             });
         }
         globalBodyGateStop = installGlobalNetworkBodyGate(target, {
@@ -466,10 +474,14 @@ export function createNetworkForwarder(bridge) {
             dispatchChunked(globalDevtoolsWc, json);
             return;
         }
-        globalDevtoolsWc.executeJavaScript(buildDispatchScript([json]), true).catch(() => { });
+        globalDevtoolsWc
+            .executeJavaScript(buildDispatchScript([json]), true)
+            .catch(() => {
+            /* best-effort */
+        });
     }
     // ── Native-sink state machine ─────────────────────────────────────────────
-    let sink = 'idle';
+    let sink = "idle";
     // Buffered completed-request records while 'probing' — flushed to console if we
     // degrade, dropped if we go ready (so a request shows in exactly one sink).
     let probeConsoleBuffer = [];
@@ -497,22 +509,22 @@ export function createNetworkForwarder(bridge) {
     }
     /** Enter the 'probing' state and arm the ready-timeout (idempotent). */
     function beginProbing() {
-        if (sink === 'probing')
+        if (sink === "probing")
             return;
-        sink = 'probing';
+        sink = "probing";
         probeDeadline = Date.now() + DEVTOOLS_READY_TIMEOUT_MS;
         if (readyTimeoutTimer)
             clearTimeout(readyTimeoutTimer);
         readyTimeoutTimer = setTimeout(() => {
             readyTimeoutTimer = null;
             // Still not ready after the grace period → abandon native for this host.
-            if (sink === 'probing')
+            if (sink === "probing")
                 degradeToConsole();
         }, DEVTOOLS_READY_TIMEOUT_MS);
     }
     /** Native path confirmed live: console buffer is moot, drop it. */
     function markReady() {
-        sink = 'ready';
+        sink = "ready";
         probeDeadline = null;
         if (readyTimeoutTimer) {
             clearTimeout(readyTimeoutTimer);
@@ -531,7 +543,7 @@ export function createNetworkForwarder(bridge) {
      * and flush the buffered completed-request records to the console sink.
      */
     function degradeToConsole() {
-        sink = 'degraded';
+        sink = "degraded";
         probeDeadline = null;
         dispatchQueue = [];
         if (readyTimeoutTimer) {
@@ -562,9 +574,9 @@ export function createNetworkForwarder(bridge) {
     function trimQueue() {
         if (dispatchQueue.length <= MAX_DISPATCH_QUEUE)
             return;
-        const isOpener = (json) => json.includes('"Network.requestWillBeSent"')
-            || json.includes('"Network.requestWillBeSentExtraInfo"')
-            || json.includes('"Network.webSocketCreated"');
+        const isOpener = (json) => json.includes('"Network.requestWillBeSent"') ||
+            json.includes('"Network.requestWillBeSentExtraInfo"') ||
+            json.includes('"Network.webSocketCreated"');
         // First pass: drop oldest non-opener events.
         const kept = [];
         let over = dispatchQueue.length - MAX_DISPATCH_QUEUE;
@@ -587,7 +599,7 @@ export function createNetworkForwarder(bridge) {
         flushScheduled = false;
         if (dispatchQueue.length === 0)
             return;
-        if (sink === 'degraded') {
+        if (sink === "degraded") {
             dispatchQueue = [];
             return;
         }
@@ -610,7 +622,7 @@ export function createNetworkForwarder(bridge) {
             scheduleReadyRetry();
             return;
         }
-        if (sink === 'idle')
+        if (sink === "idle")
             beginProbing();
         // Pack greedily up to MAX_BATCH_CHARS so one executeJavaScript stays sized;
         // oversized single messages go via the chunked transport (see packDispatchBatch).
@@ -639,24 +651,26 @@ export function createNetworkForwarder(bridge) {
         dispatchQueue = remaining;
         if (remaining.length > 0)
             scheduleFlush();
-        wc.executeJavaScript(script, true).then((ok) => {
+        wc.executeJavaScript(script, true)
+            .then((ok) => {
             if (ok === true) {
-                if (sink !== 'ready')
+                if (sink !== "ready")
                     markReady();
                 return;
             }
             // API not present yet — front-end still booting. Re-queue this batch ahead
             // of any newer events and poll until ready (or the timeout degrades us).
-            if (sink === 'degraded')
+            if (sink === "degraded")
                 return;
             dispatchQueue = batch.concat(dispatchQueue);
             trimQueue();
             scheduleReadyRetry();
-        }).catch(() => {
+        })
+            .catch(() => {
             // wc navigated / torn down mid-call, OR the script overflowed IPC. Re-queue
             // (bounded) and let the next flush re-resolve the host. Best-effort; the
             // ready-timeout still governs giving up. Backoff is via the retry timer.
-            if (sink === 'degraded')
+            if (sink === "degraded")
                 return;
             dispatchQueue = batch.concat(dispatchQueue);
             trimQueue();
@@ -676,10 +690,12 @@ export function createNetworkForwarder(bridge) {
         catch {
             return;
         }
-        wc.executeJavaScript(script, true).catch(() => { });
+        wc.executeJavaScript(script, true).catch(() => {
+            /* best-effort */
+        });
     }
     function scheduleReadyRetry() {
-        if (readyRetryTimer || sink === 'ready' || sink === 'degraded')
+        if (readyRetryTimer || sink === "ready" || sink === "degraded")
             return;
         // Self-terminate on the same deadline readyTimeoutTimer enforces, instead of
         // trusting that timer to win a same-instant race against this one (see the
@@ -690,7 +706,7 @@ export function createNetworkForwarder(bridge) {
         }
         readyRetryTimer = setTimeout(() => {
             readyRetryTimer = null;
-            if (sink === 'degraded')
+            if (sink === "degraded")
                 return;
             if (probeDeadline !== null && Date.now() >= probeDeadline) {
                 degradeToConsole();
@@ -707,9 +723,9 @@ export function createNetworkForwarder(bridge) {
         // requests — queueing them would let them double-render if a host later
         // arrives / swaps in. resolveDevtoolsWc() guards the idle case where a host
         // is set on the bridge but applyDevtoolsHost hasn't run yet.
-        if (sink === 'degraded')
+        if (sink === "degraded")
             return;
-        if (sink === 'idle' && !resolveDevtoolsWc())
+        if (sink === "idle" && !resolveDevtoolsWc())
             return;
         let json;
         try {
@@ -759,7 +775,9 @@ export function createNetworkForwarder(bridge) {
             try {
                 ad.disposeAll();
             }
-            catch { /* best-effort teardown */ }
+            catch {
+                /* best-effort teardown */
+            }
         }
         lease?.dispose();
         // Drop any queued-but-unflushed messages so a new attach starts clean, and
@@ -768,7 +786,7 @@ export function createNetworkForwarder(bridge) {
         probeConsoleBuffer = [];
         // A new simulator attach restarts the native sink: 'idle' until the next
         // event re-probes the (possibly already-set) host.
-        sink = 'idle';
+        sink = "idle";
         probeDeadline = null;
         if (readyRetryTimer) {
             clearTimeout(readyRetryTimer);
@@ -819,7 +837,7 @@ export function createNetworkForwarder(bridge) {
             // — global-body-gate answers Network.getResponseBody/getRequestPostData
             // from this same cache, and it must not 404 just because the
             // user-facing sink happens to be closed/degraded.
-            const userSinkUsable = sink !== 'degraded' && !(sink === 'idle' && !resolveDevtoolsWc());
+            const userSinkUsable = sink !== "degraded" && !(sink === "idle" && !resolveDevtoolsWc());
             const globalUsable = globalDevtoolsWc !== null && !globalDevtoolsWc.isDestroyed();
             if (!userSinkUsable && !globalUsable)
                 return;
@@ -831,23 +849,24 @@ export function createNetworkForwarder(bridge) {
             // is a best-effort heuristic (encodedDataLength is the ON-THE-WIRE size;
             // a decompressed body can be larger), not a hard guarantee — the
             // concurrency cap below is what actually bounds worst-case memory.
-            const knownOversized = typeof encodedDataLength === 'number' && encodedDataLength > DEFAULT_PER_ENTRY_MAX_CHARS;
+            const knownOversized = typeof encodedDataLength === "number" &&
+                encodedDataLength > DEFAULT_PER_ENTRY_MAX_CHARS;
             if (!knownOversized) {
                 primeWithAdmission(bodyCache, virtualId, async () => {
-                    const raw = await wc.debugger.sendCommand('Network.getResponseBody', { requestId: rawId });
+                    const raw = await wc.debugger.sendCommand("Network.getResponseBody", { requestId: rawId });
                     const r = raw;
-                    if (!r || typeof r.body !== 'string')
-                        throw new Error('response body unavailable');
+                    if (!r || typeof r.body !== "string")
+                        throw new Error("response body unavailable");
                     return { body: r.body, base64Encoded: r.base64Encoded === true };
                 });
             }
             if (!postDataWanted.delete(rawId))
                 return;
             primeWithAdmission(postDataCache, virtualId, async () => {
-                const raw = await wc.debugger.sendCommand('Network.getRequestPostData', { requestId: rawId });
+                const raw = await wc.debugger.sendCommand("Network.getRequestPostData", { requestId: rawId });
                 const r = raw;
-                if (!r || typeof r.postData !== 'string')
-                    throw new Error('post data unavailable');
+                if (!r || typeof r.postData !== "string")
+                    throw new Error("post data unavailable");
                 return { postData: r.postData };
             });
         };
@@ -859,10 +878,15 @@ export function createNetworkForwarder(bridge) {
                 return;
             if (pending.size >= MAX_PENDING)
                 pending.clear();
-            pending.set(p.requestId, { url: p.request.url, method: p.request.method, status: 0 });
+            pending.set(p.requestId, {
+                url: p.request.url,
+                method: p.request.method,
+                status: 0,
+            });
             // A body announced but not inlined is the one case the panel will
             // round-trip `Network.getRequestPostData` — flag it for prefetch.
-            if (p.request.hasPostData === true && typeof p.request.postData !== 'string') {
+            if (p.request.hasPostData === true &&
+                typeof p.request.postData !== "string") {
                 if (postDataWanted.size >= MAX_PENDING)
                     postDataWanted.clear();
                 postDataWanted.add(p.requestId);
@@ -887,12 +911,17 @@ export function createNetworkForwarder(bridge) {
         }
         function onLoadingFinished(params) {
             const p = params;
-            if (typeof p?.requestId === 'string')
+            if (typeof p?.requestId === "string")
                 prefetchBodies(p.requestId, p.encodedDataLength);
             const req = retirePending(p?.requestId);
             if (!req)
                 return;
-            maybeFallback({ source, url: req.url, method: req.method, status: req.status });
+            maybeFallback({
+                source,
+                url: req.url,
+                method: req.method,
+                status: req.status,
+            });
         }
         function onLoadingFailed(params) {
             const p = params;
@@ -905,14 +934,14 @@ export function createNetworkForwarder(bridge) {
                 url: req.url,
                 method: req.method,
                 status: req.status,
-                errorText: p.canceled ? 'canceled' : (p.errorText || 'failed'),
+                errorText: p.canceled ? "canceled" : p.errorText || "failed",
             });
         }
         const FALLBACK_HANDLERS = {
-            'Network.requestWillBeSent': onRequestWillBeSent,
-            'Network.responseReceived': onResponseReceived,
-            'Network.loadingFinished': onLoadingFinished,
-            'Network.loadingFailed': onLoadingFailed,
+            "Network.requestWillBeSent": onRequestWillBeSent,
+            "Network.responseReceived": onResponseReceived,
+            "Network.loadingFinished": onLoadingFinished,
+            "Network.loadingFailed": onLoadingFailed,
         };
         /**
          * Resolve (and, on `requestWillBeSent`, record) whether `rawId` is
@@ -925,10 +954,14 @@ export function createNetworkForwarder(bridge) {
          * than silently hiding it.
          */
         function resolveUserFacing(method, params, rawId) {
-            if (method === 'Network.requestWillBeSent') {
-                const url = params?.request?.url;
-                const verdict = typeof url === 'string'
-                    ? isUserFacingRequest(url, [bridge.getResourceServerBaseUrl?.(), bridge.getSimulatorServerBaseUrl?.()])
+            if (method === "Network.requestWillBeSent") {
+                const url = params?.request
+                    ?.url;
+                const verdict = typeof url === "string"
+                    ? isUserFacingRequest(url, [
+                        bridge.getResourceServerBaseUrl?.(),
+                        bridge.getSimulatorServerBaseUrl?.(),
+                    ])
                     : true;
                 if (rawId) {
                     if (userFacingByRawId.size >= MAX_PENDING)
@@ -950,7 +983,7 @@ export function createNetworkForwarder(bridge) {
             // classification is even known. Every OTHER "rawId never seen" case
             // (e.g. capture attached mid-flight, no requestWillBeSent ever coming)
             // keeps failing open — there is no better signal available there.
-            if (method === 'Network.requestWillBeSentExtraInfo')
+            if (method === "Network.requestWillBeSentExtraInfo")
                 return false;
             return true;
         }
@@ -964,8 +997,9 @@ export function createNetworkForwarder(bridge) {
                 // User-facing sink: only requests isUserFacingRequest() judged as the
                 // developer's own business traffic — internal/framework resource
                 // loads are mirrored to the global window ONLY.
-                const rawId = params?.requestId;
-                const userFacing = resolveUserFacing(method, params, typeof rawId === 'string' ? rawId : undefined);
+                const rawId = params
+                    ?.requestId;
+                const userFacing = resolveUserFacing(method, params, typeof rawId === "string" ? rawId : undefined);
                 if (userFacing) {
                     enqueueNative(rewritten.method, rewritten.params);
                 }
@@ -978,12 +1012,14 @@ export function createNetworkForwarder(bridge) {
             // ── Fallback bookkeeping (used only when native dispatch is unusable) ──
             FALLBACK_HANDLERS[method]?.(params);
         };
-        wc.debugger.on('message', onMessage);
+        wc.debugger.on("message", onMessage);
         attach.add(() => {
             try {
-                wc.debugger.removeListener('message', onMessage);
+                wc.debugger.removeListener("message", onMessage);
+            }
+            catch {
+                /* wc gone */
             }
-            catch { /* wc gone */ }
         });
     }
     /** Drop one guest's wiring (message listener + broker lease). Attach/detach
@@ -1093,7 +1129,7 @@ export function createNetworkForwarder(bridge) {
         guestRetryGeneration.delete(wc.id);
         const teardown = new SyncDisposableRegistry();
         guestWired.set(wc.id, teardown);
-        wireNetworkCapture(wc, 'render', teardown, `g${wc.id}-${Date.now()}`);
+        wireNetworkCapture(wc, "render", teardown, `g${wc.id}-${Date.now()}`);
         const detachSub = lease.onDetach(() => {
             cleanupGuest(wc.id);
             scheduleRenderGuestRetry(wc);
@@ -1102,8 +1138,8 @@ export function createNetworkForwarder(bridge) {
             detachSub.dispose();
             lease.dispose();
         });
-        void lease.send('Network.enable').catch((err) => {
-            console.warn('[network-forward] guest Network.enable failed:', err instanceof Error ? err.message : err);
+        void lease.send("Network.enable").catch((err) => {
+            console.warn("[network-forward] guest Network.enable failed:", err instanceof Error ? err.message : err);
         });
     }
     function attachRenderGuest(wc) {
@@ -1127,14 +1163,14 @@ export function createNetworkForwarder(bridge) {
         detachSimulator();
         const lease = broker.acquire(wc);
         if (!lease) {
-            console.warn('[network-forward] debugger session unavailable; simulator network not captured');
+            console.warn("[network-forward] debugger session unavailable; simulator network not captured");
             return;
         }
         simWc = wc;
         simLease = lease;
         const attach = new SyncDisposableRegistry();
         attachDisposables = attach;
-        wireNetworkCapture(wc, 'service', attach, String(Date.now()));
+        wireNetworkCapture(wc, "service", attach, String(Date.now()));
         const detachSub = lease.onDetach(() => {
             if (simWc !== wc)
                 return;
@@ -1149,12 +1185,14 @@ export function createNetworkForwarder(bridge) {
                 try {
                     ad.disposeAll();
                 }
-                catch { /* best-effort teardown */ }
+                catch {
+                    /* best-effort teardown */
+                }
             }
         });
         attach.add(() => detachSub.dispose());
-        void lease.send('Network.enable').catch((err) => {
-            console.warn('[network-forward] Network.enable failed:', err instanceof Error ? err.message : err);
+        void lease.send("Network.enable").catch((err) => {
+            console.warn("[network-forward] Network.enable failed:", err instanceof Error ? err.message : err);
         });
     }
     /**
@@ -1170,18 +1208,18 @@ export function createNetworkForwarder(bridge) {
         // 'idle' but a host is resolvable (set via the bridge, applyDevtoolsHost not
         // run): the native path is in play, so promote to 'probing' instead of
         // console — otherwise this completion would later double-render natively.
-        if (sink === 'idle' && resolveDevtoolsWc())
+        if (sink === "idle" && resolveDevtoolsWc())
             beginProbing();
         switch (sink) {
-            case 'ready':
+            case "ready":
                 return;
-            case 'probing':
+            case "probing":
                 if (probeConsoleBuffer.length >= MAX_PENDING)
                     probeConsoleBuffer.shift();
                 probeConsoleBuffer.push(record);
                 return;
-            case 'degraded':
-            case 'idle':
+            case "degraded":
+            case "idle":
             default:
                 forwardToConsole(record);
         }
@@ -1207,7 +1245,7 @@ export function createNetworkForwarder(bridge) {
         if (!devtoolsWc) {
             // No host → 'idle': completions go straight to console; native queue is
             // moot, drop it so it can't double-render if a host later appears.
-            sink = 'idle';
+            sink = "idle";
             dispatchQueue = [];
             return;
         }
@@ -1215,7 +1253,9 @@ export function createNetworkForwarder(bridge) {
         // WITHOUT touching view-manager (host-destroyed cleanup lives here). Begin
         // probing and flush anything already queued.
         const host = devtoolsWc;
-        const onHostDestroyed = () => { applyDevtoolsHost(null); };
+        const onHostDestroyed = () => {
+            applyDevtoolsHost(null);
+        };
         // Route host-destroyed teardown through the connection registry when present
         // (the Connection fires onHostDestroyed on wc destroy / reset, and the
         // returned Disposable releases the ownership early on host swap/clear);
@@ -1227,18 +1267,20 @@ export function createNetworkForwarder(bridge) {
         // gated by the SAME `typeof host.once === 'function'` guard the fallback
         // uses — otherwise a minimal/fake DevTools host (no emitter) throws on the
         // connection path where the fallback would safely no-op.
-        if (reg && typeof host.once === 'function') {
+        if (reg && typeof host.once === "function") {
             const owned = reg.acquire(host).own(onHostDestroyed);
             devtoolsHostDisposable = toDisposable(() => owned.dispose());
         }
         else {
-            if (typeof host.once === 'function')
-                host.once('destroyed', onHostDestroyed);
+            if (typeof host.once === "function")
+                host.once("destroyed", onHostDestroyed);
             devtoolsHostDisposable = toDisposable(() => {
                 try {
-                    host.removeListener?.('destroyed', onHostDestroyed);
+                    host.removeListener?.("destroyed", onHostDestroyed);
+                }
+                catch {
+                    /* gone */
                 }
-                catch { /* gone */ }
             });
         }
         // A host swap while still 'probing' the OLD host must not inherit its
@@ -1246,12 +1288,14 @@ export function createNetworkForwarder(bridge) {
         // (re-)arming readyTimeoutTimer/probeDeadline for the NEW host, leaving it
         // probing forever with no timeout. Force through 'idle' so beginProbing()
         // always arms a fresh window for whichever host is now current.
-        sink = 'idle';
+        sink = "idle";
         beginProbing();
         if (dispatchQueue.length > 0)
             scheduleFlush();
     }
-    registry.add(() => { disposed = true; });
+    registry.add(() => {
+        disposed = true;
+    });
     registry.add(() => {
         devtoolsHostDisposable?.dispose();
         devtoolsHostDisposable = null;
@@ -1303,7 +1347,10 @@ export function createNetworkForwarder(bridge) {
     // per-socket verdict cache mirrors resolveUserFacing's decide-once rule.
     const wsSynthesizer = new WebSocketTraceSynthesizer({
         epoch: String(Date.now()),
-        internalOrigins: () => [bridge.getResourceServerBaseUrl?.(), bridge.getSimulatorServerBaseUrl?.()],
+        internalOrigins: () => [
+            bridge.getResourceServerBaseUrl?.(),
+            bridge.getSimulatorServerBaseUrl?.(),
+        ],
     });
     function reportWebSocketTrace(sessionId, event) {
         if (disposed)
@@ -1318,6 +1365,44 @@ export function createNetworkForwarder(bridge) {
         if (message.userFacing)
             enqueueNative(message.method, message.params);
     }
+    // ── Main-process HTTP request trace → synthesized Network.request*/
+    // Network.loading* CDP ──────────────────────────────────────────────────
+    // Same shape as the WebSocket trace bridge above, for the same reason:
+    // wx.request now runs on Node http/https in this process (that's what
+    // stops Chromium's Fetch/CORS algorithm from attaching a spurious OPTIONS
+    // preflight to it), so no webContents.debugger can observe it either.
+    const httpSynthesizer = new RequestTraceSynthesizer({
+        epoch: String(Date.now()),
+        internalOrigins: () => [
+            bridge.getResourceServerBaseUrl?.(),
+            bridge.getSimulatorServerBaseUrl?.(),
+        ],
+    });
+    function reportNativeRequestTrace(sessionId, event) {
+        if (disposed)
+            return;
+        const message = httpSynthesizer.synthesize(sessionId, event);
+        if (!message)
+            return;
+        const params = message.params;
+        if (event.type === "redirect") {
+            bodyCache.delete(params.requestId);
+            postDataCache.delete(params.requestId);
+        }
+        // The response is already fully buffered in-process at `finished` — prime
+        // the SAME cache a simulator-CDP prefetch would populate, so the
+        // front-end's Get Response Body click resolves without a debugger
+        // round-trip that (for this requestId) has nowhere to go.
+        if (message.body) {
+            bodyCache.prime(params.requestId, () => Promise.resolve(message.body));
+        }
+        if (message.postData !== undefined) {
+            postDataCache.prime(params.requestId, () => Promise.resolve({ postData: message.postData }));
+        }
+        dispatchToGlobal(message.method, message.params);
+        if (message.userFacing)
+            enqueueNative(message.method, message.params);
+    }
     return {
         attachSimulator,
         detachSimulator,
@@ -1328,6 +1413,7 @@ export function createNetworkForwarder(bridge) {
         // natively — surface it via the console fallback line.
         report: (record) => forwardToConsole(record),
         reportWebSocketTrace,
+        reportNativeRequestTrace,
         bodies: {
             getResponseBody: (requestId) => bodyCache.lookup(requestId),
             getRequestPostData: (requestId) => postDataCache.lookup(requestId),