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

package/dist/main/services/elements-forward/index.d.ts

@@ -60,7 +60,7 @@
 import type { WebContents } from 'electron';
 import type { ConnectionRegistry } from '@dimina-kit/electron-deck/main';
 import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
-import { type NetworkBodyProvider } from '../network-forward/index.js';
+import type { NetworkBodyProvider } from '../network-forward/index.js';
 import { type CdpSessionBroker } from '../cdp-session/index.js';
 /**
  * Which target a front-end CDP command is routed to.
@@ -108,7 +108,7 @@ export declare const NETWORK_BODY_METHODS: readonly string[];
  * equivalent test driven by the same literals, so the two cannot drift.
  *
  * A non-string / missing requestId routes to 'service': only the
- * `dimina:sim:` namespace is ours to answer, and the real backend is the
+ * simulator and native HTTP namespaces is ours to answer, and the real backend is the
  * correct authority for its own ids.
  */
 export declare function routeOutboundCommand(method: string, params: unknown): CdpRoute;

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

@@ -1,5 +1,5 @@
 import { isFrontendSettled } from '../views/inject-when-ready.js';
-import { VIRTUAL_REQUEST_ID_PREFIX } from '../network-forward/index.js';
+import { BODY_REQUEST_ID_PREFIXES } from '../network-forward/request-ids.js';
 import { buildSingleDispatchScript, createFrontendReplyChannel, answerNetworkBodyCommand, drainOutboundBatch } from '../network-forward/frontend-dispatch.js';
 import { createCdpSessionBroker } from '../cdp-session/index.js';
 /**
@@ -56,7 +56,7 @@ export const NETWORK_BODY_METHODS = [
  * equivalent test driven by the same literals, so the two cannot drift.
  *
  * A non-string / missing requestId routes to 'service': only the
- * `dimina:sim:` namespace is ours to answer, and the real backend is the
+ * simulator and native HTTP namespaces is ours to answer, and the real backend is the
  * correct authority for its own ids.
  */
 export function routeOutboundCommand(method, params) {
@@ -64,7 +64,7 @@ export function routeOutboundCommand(method, params) {
         return 'render';
     if (NETWORK_BODY_METHODS.includes(method)) {
         const requestId = params?.requestId;
-        if (typeof requestId === 'string' && requestId.startsWith(VIRTUAL_REQUEST_ID_PREFIX)) {
+        if (typeof requestId === 'string' && BODY_REQUEST_ID_PREFIXES.some((prefix) => requestId.startsWith(prefix))) {
             return 'network';
         }
     }
@@ -87,13 +87,13 @@ export function routeOutboundCommand(method, params) {
 export function buildElementsHookScript() {
     const prefixes = JSON.stringify(RENDER_DOMAIN_PREFIXES);
     const netMethods = JSON.stringify(NETWORK_BODY_METHODS);
-    const vprefix = JSON.stringify(VIRTUAL_REQUEST_ID_PREFIX);
+    const vprefix = JSON.stringify(BODY_REQUEST_ID_PREFIXES);
     return `(function(){try{
     if (globalThis.__diminaElementsHookInstalled) return 'already';
     var OUT = (globalThis.__diminaElementsOutbound = globalThis.__diminaElementsOutbound || []);
     var PREFIXES = ${prefixes};
     var NET_METHODS = ${netMethods};
-    var VPREFIX = ${vprefix};
+    var VPREFIXES = ${vprefix};
     function isRender(method){
       if (!method) return false;
       for (var i=0;i<PREFIXES.length;i++){ if (method.indexOf(PREFIXES[i])===0) return true; }
@@ -104,7 +104,7 @@ export function buildElementsHookScript() {
       if (isRender(m.method)) return 'render';
       if (NET_METHODS.indexOf(m.method) >= 0 && m.params
           && typeof m.params.requestId === 'string'
-          && m.params.requestId.indexOf(VPREFIX) === 0) return 'network';
+          && VPREFIXES.some(function(prefix){ return m.params.requestId.indexOf(prefix) === 0; })) return 'network';
       return 'service';
     }
     var IFH = globalThis.InspectorFrontendHost;

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

@@ -60,6 +60,8 @@ export declare class PrefetchCache<V> {
      */
     prime(id: string, fetch: () => Promise<V>): boolean;
     lookup(id: string): Promise<V>;
+    /** Retire a previous redirect hop without disturbing unrelated cached requests. */
+    delete(id: string): void;
     clear(): void;
     get size(): number;
     private isExpired;

package/dist/main/services/network-forward/body-cache.js

@@ -134,6 +134,10 @@ export class PrefetchCache {
         this.map.set(id, e);
         return Promise.resolve(v);
     }
+    /** Retire a previous redirect hop without disturbing unrelated cached requests. */
+    delete(id) {
+        this.map.delete(id);
+    }
     clear() {
         this.map.clear();
     }

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

@@ -12,7 +12,7 @@
  * 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
+ * `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) ───────────────

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

@@ -1,5 +1,5 @@
 import { isFrontendSettled } from '../views/inject-when-ready.js';
-import { VIRTUAL_REQUEST_ID_PREFIX } from './index.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'];
@@ -12,16 +12,16 @@ const DRAIN_INTERVAL_MS = 150;
  */
 export function buildNetworkOnlyHookScript() {
     const netMethods = JSON.stringify(NETWORK_BODY_METHODS);
-    const vprefix = JSON.stringify(VIRTUAL_REQUEST_ID_PREFIX);
+    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 VPREFIX = ${vprefix};
+    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' && m.params.requestId.indexOf(VPREFIX) === 0);
+      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){

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

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

@@ -0,0 +1,162 @@
+/**
+ * Synthesize Chrome DevTools Protocol `Network.request*`/`Network.loading*`
+ * messages from the main-process HTTP request trace stream (see
+ * electron-runtime `native-request/trace.ts`).
+ *
+ * Why this exists: `wx.request` runs on Node http/https in the MAIN process
+ * (see native-request's design notes — this replaced a renderer `fetch()`
+ * specifically to stop Chromium's Fetch/CORS algorithm from attaching a
+ * spurious OPTIONS preflight to it) — no `webContents.debugger` can observe
+ * it, so the embedded DevTools Network tab would otherwise show nothing for
+ * every wx.request call. The trace stream gives one ordered fact per
+ * lifecycle moment; this module re-shapes each fact into the CDP events the
+ * front-end already renders natively for an XHR-classified resource
+ * (`requestWillBeSent` creates the row, `responseReceived` fills in
+ * status/headers, `loadingFinished`/`loadingFailed` settles it).
+ *
+ * Ordering contract this module relies on (guaranteed by the trace layer):
+ * `sent` strictly precedes every other event for its requestId, and exactly
+ * one of `loadingFinished`/`loadingFailed` terminates each sent request. The
+ * front-end silently drops loading events for an unknown requestId, so this
+ * module mirrors that discipline defensively: any non-`sent` event for an
+ * unknown requestId is dropped rather than synthesized.
+ *
+ * Pure and self-contained (no Electron imports) so it is unit-testable.
+ */
+import { NATIVE_HTTP_REQUEST_ID_PREFIX } from "./request-ids.js";
+import { isUserFacingRequest } from "./user-facing.js";
+/** CDP `Network.ResourceType` this forwarder classifies every wx.request
+ * call as — the same bucket the real front-end uses for `XMLHttpRequest`/
+ * `fetch()` business calls, so it renders with the matching icon/filter. */
+const RESOURCE_TYPE = "XHR";
+export class RequestTraceSynthesizer {
+    options;
+    requests = new Map();
+    seq = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * 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, event) {
+        const key = `${sessionId} ${event.requestId}`;
+        if (event.type === "sent" || event.type === "redirect") {
+            return this.synthesizeRequest(key, event);
+        }
+        const state = this.requests.get(key);
+        if (!state)
+            return null;
+        const { requestId, userFacing } = state;
+        const timestamp = event.time / 1000;
+        switch (event.type) {
+            case "response":
+                return {
+                    method: "Network.responseReceived",
+                    params: {
+                        requestId,
+                        loaderId: requestId,
+                        timestamp,
+                        type: RESOURCE_TYPE,
+                        response: {
+                            url: state.url,
+                            status: event.status,
+                            statusText: event.statusText,
+                            headers: event.headers,
+                            // Chromium uses these together to replace provisional headers
+                            // and expose the verbatim source. ExtraInfo has no raw request
+                            // text and would override this response snapshot in the frontend.
+                            ...(event.requestHeaders && event.requestHeadersText ? {
+                                requestHeaders: event.requestHeaders,
+                                requestHeadersText: event.requestHeadersText,
+                            } : {}),
+                            mimeType: mimeTypeOf(event.headers),
+                            connectionReused: false,
+                            connectionId: 0,
+                            encodedDataLength: 0,
+                            fromDiskCache: false,
+                            fromServiceWorker: false,
+                        },
+                    },
+                    userFacing,
+                };
+            case "finished":
+                // Terminal: release the id mapping so a long-lived owner can't grow it.
+                this.requests.delete(key);
+                return {
+                    method: "Network.loadingFinished",
+                    params: {
+                        requestId,
+                        timestamp,
+                        encodedDataLength: event.encodedDataLength,
+                    },
+                    userFacing,
+                    ...(event.body !== undefined ? { body: { base64Encoded: event.bodyBase64Encoded, body: event.body } } : {}),
+                };
+            case "failed":
+                this.requests.delete(key);
+                return {
+                    method: "Network.loadingFailed",
+                    params: {
+                        requestId,
+                        timestamp,
+                        type: RESOURCE_TYPE,
+                        errorText: event.errorText,
+                    },
+                    userFacing,
+                };
+        }
+    }
+    synthesizeRequest(key, event) {
+        const previous = this.requests.get(key);
+        if (event.type === "redirect" && !previous)
+            return null;
+        const requestId = event.type === "redirect" ? previous.requestId
+            : `${NATIVE_HTTP_REQUEST_ID_PREFIX}${this.options.epoch}:${this.seq++}`;
+        const userFacing = event.type === "redirect" ? previous.userFacing : isUserFacingRequest(event.url, this.options.internalOrigins?.());
+        this.requests.set(key, { requestId, url: event.url, userFacing });
+        const timestamp = event.time / 1000;
+        const hasPostData = event.hasPostData ?? event.postData !== undefined;
+        const message = {
+            method: "Network.requestWillBeSent",
+            params: {
+                requestId,
+                loaderId: requestId,
+                documentURL: event.url,
+                request: {
+                    url: event.url,
+                    method: event.method,
+                    headers: event.headers,
+                    hasPostData,
+                    ...(hasPostData ? { postData: event.postData } : {}),
+                },
+                timestamp,
+                wallTime: timestamp,
+                initiator: { type: "script" },
+                type: RESOURCE_TYPE,
+                ...(event.type === "redirect" ? { redirectResponse: {
+                        ...event.redirectResponse,
+                        mimeType: mimeTypeOf(event.redirectResponse.headers),
+                        connectionReused: false, connectionId: 0, encodedDataLength: 0,
+                    } } : {}),
+            },
+            userFacing,
+        };
+        if (hasPostData)
+            message.postData = event.postData;
+        return message;
+    }
+}
+/** `Content-Type: application/json; charset=utf-8` → `application/json`. Case
+ * -insensitive header lookup, matching HTTP semantics. */
+function mimeTypeOf(headers) {
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() !== "content-type")
+            continue;
+        return value.split(";")[0]?.trim() ?? "";
+    }
+    return "";
+}
+//# sourceMappingURL=http.js.map

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

@@ -74,18 +74,11 @@
  *     transport) arrive as trace events via `reportWebSocketTrace` and are
  *     synthesized into `Network.webSocket*` CDP messages (see websocket.ts).
  */
-import type { WebContents } from 'electron';
-import { type ConnectionRegistry, type Disposable } from '@dimina-kit/electron-deck/main';
-import { type CdpSessionBroker } from '../cdp-session/index.js';
-import type { NativeWebSocketTrace } from '../../ipc/bridge-router.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 declare const VIRTUAL_REQUEST_ID_PREFIX = "dimina:sim:";
+import type { WebContents } from "electron";
+import { type ConnectionRegistry, type Disposable } from "@dimina-kit/electron-deck/main";
+import { type CdpSessionBroker } from "../cdp-session/index.js";
+import type { NativeRequestTrace, NativeWebSocketTrace } from "../../ipc/bridge-router.js";
+export { VIRTUAL_REQUEST_ID_PREFIX } from "./request-ids.js";
 /** CDP `Network.getResponseBody` result shape (served from the prefetch cache). */
 export interface CdpResponseBody {
     body: string;
@@ -106,7 +99,7 @@ export interface NetworkBodyProvider {
     }>;
 }
 /** Which layer a captured request came from (tags the fallback log line). */
-export type NetworkSource = 'service' | 'render';
+export type NetworkSource = "service" | "render";
 /** A normalized completed network request, used only by the console fallback. */
 export interface NetworkRequestRecord {
     source: NetworkSource;
@@ -227,6 +220,19 @@ export interface NetworkForwarder extends Disposable {
      * user-facing. Best-effort like every injection point — never throws.
      */
     reportWebSocketTrace(sessionId: string, event: NativeWebSocketTrace): void;
+    /**
+     * Surface one main-process HTTP request trace event (wx.request traffic
+     * runs on Node http/https, invisible to any debugger, precisely so it
+     * skips Chromium's Fetch/CORS algorithm and its OPTIONS preflight) as a
+     * synthesized `Network.request*`/`Network.loading*` CDP event, through the
+     * SAME channels as forwarded simulator traffic: the global mirror
+     * unfiltered, plus the user-facing native sink when the request's url
+     * classified user-facing. `finished` primes the body cache (the response is
+     * already fully buffered in-process, no CDP round-trip needed); `sent`
+     * primes the post-data cache when the request carried a body. Best-effort
+     * like every injection point — never throws.
+     */
+    reportNativeRequestTrace(sessionId: string, event: NativeRequestTrace): void;
     /**
      * Body/post-data lookups for the virtual requestIds this forwarder injected,
      * backed by the loadingFinished-time prefetch cache. Keyed by virtual id, so