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

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/index.d.ts

@@ -128,6 +128,26 @@ export interface NetworkForwarderBridge {
      * `setDevtoolsHost`. Null until the DevTools host view exists.
      */
     getDevtoolsWc?(): WebContents | null;
+    /**
+     * The dimina resource server's baseUrl (e.g. `'http://127.0.0.1:54321/'`),
+     * when running — consulted by `isUserFacingRequest` so the framework
+     * bundle it serves is classified as host-internal, not business traffic.
+     * Absent → that origin check is simply skipped (the scheme rule alone
+     * still filters out file:// / difile:// / devtools:// framework loads).
+     */
+    getResourceServerBaseUrl?(): string | null;
+    /**
+     * The simulator's own static-asset server baseUrl (serves `simulator.html`
+     * + its JS/CSS — a devkit-owned server, independent from the resource
+     * server above, on its own dynamically-assigned port), when a project is
+     * open — consulted by `isUserFacingRequest` alongside
+     * `getResourceServerBaseUrl` so the simulator SHELL's own asset loading
+     * (captured because `attachSimulator` CDP-observes that whole
+     * WebContentsView, not just the mini-app's own `wx.request` calls) isn't
+     * misclassified as the developer's business traffic. Absent → that origin
+     * check is simply skipped.
+     */
+    getSimulatorServerBaseUrl?(): string | null;
     /**
      * Optional connection-layer registry (`@dimina-kit/electron-deck/main`). When
      * present, per-webContents teardowns route through `acquire(wc).own(d)` so the
@@ -179,6 +199,17 @@ export interface NetworkForwarder extends Disposable {
      * we fall back to the console line. Re-callable across DevTools re-creates.
      */
     setDevtoolsHost(wc: WebContents | null): void;
+    /**
+     * Point the forwarder at the WebContents hosting the standalone internal
+     * (app-wide) DevTools window's front-end — the global mirror sink.
+     * Unlike `setDevtoolsHost` (the user-facing sink), this has NO probing/
+     * ready/degraded state machine and NO console fallback: every
+     * FORWARDED_METHODS event is mirrored here raw and UNFILTERED (no
+     * `isUserFacingRequest` gating) whenever a host is set, best-effort (a
+     * failed dispatch is silently dropped — nobody depends on this path having
+     * a fallback). Pass null when the window closes.
+     */
+    setGlobalDevtoolsHost(wc: WebContents | null): void;
     /**
      * Manually surface a request that no `webContents.debugger` can observe
      * (e.g. a main-process direct send). Uses the console fallback sink.

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

@@ -4,6 +4,8 @@ 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';
 /**
  * Namespace prefix of every virtual requestId this forwarder injects into the
  * DevTools front-end. SINGLE SOURCE for the literal: the front-end outbound
@@ -302,6 +304,169 @@ export function createNetworkForwarder(bridge) {
     let devtoolsWc = null;
     // Teardown for the wc 'destroyed' watcher on the current host (clears the host).
     let devtoolsHostDisposable = null;
+    // ── Global mirror sink ──────────────────────────────────────────────────────
+    // The standalone internal (app-wide) DevTools window's front-end host wc.
+    // Deliberately NO probing/ready/degraded state machine and NO console
+    // fallback — see setGlobalDevtoolsHost's doc comment.
+    let globalDevtoolsWc = null;
+    let globalDevtoolsHostDisposable = null;
+    // Dedicated network-only outbound gate (body/post-data lookups) for the
+    // CURRENT global host — never elements-forward's gate, see
+    // global-body-gate.ts's header for why. Stopped whenever the host changes
+    // or clears.
+    let globalBodyGateStop = null;
+    // Bounded in-order hold for global-mirror messages arriving while the
+    // global host's front-end has not settled yet (its boot window) — without
+    // it those events are silently unrecoverable, breaking the window's
+    // full-stream promise. Scoped strictly to the CURRENT host: cleared when
+    // the host changes/clears, never replayed into a different host.
+    const MAX_GLOBAL_PENDING_QUEUE = 2000;
+    let globalPendingQueue = [];
+    let globalPendingOverflowWarned = false;
+    let globalFlushTimer = null;
+    // Wall-clock bound on the settle-poll (not on the queue itself): a
+    // front-end that never settles stops being polled after this, and the
+    // still-held queue flushes via the next incoming event instead.
+    const GLOBAL_FLUSH_POLL_MAX_MS = 60_000;
+    function clearGlobalPending() {
+        globalPendingQueue = [];
+        globalPendingOverflowWarned = false;
+        if (globalFlushTimer) {
+            clearTimeout(globalFlushTimer);
+            globalFlushTimer = null;
+        }
+    }
+    function scheduleGlobalFlush(startedAt = Date.now()) {
+        if (globalFlushTimer)
+            return;
+        if (Date.now() - startedAt >= GLOBAL_FLUSH_POLL_MAX_MS)
+            return;
+        // unref'd like scheduleRenderGuestRetry's timer: a settle-poll must
+        // never be what keeps the process (or a test file) alive.
+        globalFlushTimer = setTimeout(() => {
+            globalFlushTimer = null;
+            if (globalPendingQueue.length === 0)
+                return;
+            if (!globalDevtoolsWc || globalDevtoolsWc.isDestroyed()) {
+                clearGlobalPending();
+                return;
+            }
+            if (!isFrontendSettled(globalDevtoolsWc)) {
+                scheduleGlobalFlush(startedAt);
+                return;
+            }
+            flushGlobalPending();
+        }, READY_RETRY_MS);
+        globalFlushTimer.unref?.();
+    }
+    /** Drain the pending queue into the (settled) global host, oldest first,
+     * packed greedily under the same per-script size bound as the native sink —
+     * and through the SAME chunked transport for messages past
+     * MAX_SINGLE_DISPATCH_CHARS: a single oversized message stitched into one
+     * giant executeJavaScript overflows the IPC/script limit and the whole
+     * call rejects into a silent drop. */
+    function flushGlobalPending() {
+        if (globalPendingQueue.length === 0)
+            return;
+        const target = globalDevtoolsWc;
+        if (!target || target.isDestroyed()) {
+            clearGlobalPending();
+            return;
+        }
+        while (globalPendingQueue.length > 0) {
+            const { batch, chunked, remaining } = packDispatchBatch(globalPendingQueue, MAX_SINGLE_DISPATCH_CHARS, MAX_BATCH_CHARS);
+            globalPendingQueue = remaining;
+            for (const msg of chunked)
+                dispatchChunked(target, msg);
+            if (batch.length > 0) {
+                target.executeJavaScript(buildDispatchScript(batch), true).catch(() => { });
+            }
+        }
+        globalPendingOverflowWarned = false;
+    }
+    function enqueueGlobalPending(json) {
+        if (globalPendingQueue.length >= MAX_GLOBAL_PENDING_QUEUE) {
+            globalPendingQueue.shift();
+            // Not silent: dropping past the cap means the window's full-stream
+            // promise is degraded — say so once per overflow episode, not per event.
+            if (!globalPendingOverflowWarned) {
+                globalPendingOverflowWarned = true;
+                console.warn(`[network-forward] global mirror queue overflow (cap ${MAX_GLOBAL_PENDING_QUEUE}): dropping oldest events while the debug window front-end is still loading`);
+            }
+        }
+        globalPendingQueue.push(json);
+        scheduleGlobalFlush();
+    }
+    function applyGlobalDevtoolsHost(host) {
+        globalDevtoolsHostDisposable?.dispose();
+        globalDevtoolsHostDisposable = null;
+        globalBodyGateStop?.();
+        globalBodyGateStop = null;
+        // Queued events belong to the PREVIOUS host's boot window — never carry
+        // them across a host change (or into "no host").
+        clearGlobalPending();
+        globalDevtoolsWc = host && !host.isDestroyed() ? host : null;
+        if (!globalDevtoolsWc)
+            return;
+        const target = globalDevtoolsWc;
+        const onHostDestroyed = () => {
+            if (globalDevtoolsWc === target)
+                globalDevtoolsWc = null;
+            globalBodyGateStop?.();
+            globalBodyGateStop = null;
+            clearGlobalPending();
+        };
+        const reg = bridge.connections;
+        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);
+            globalDevtoolsHostDisposable = toDisposable(() => {
+                try {
+                    target.removeListener?.('destroyed', onHostDestroyed);
+                }
+                catch { /* gone */ }
+            });
+        }
+        globalBodyGateStop = installGlobalNetworkBodyGate(target, {
+            getResponseBody: (requestId) => bodyCache.lookup(requestId),
+            getRequestPostData: (requestId) => postDataCache.lookup(requestId),
+        });
+    }
+    /** Best-effort mirror of one raw CDP message into the global host. */
+    function dispatchToGlobal(method, params) {
+        if (!globalDevtoolsWc || globalDevtoolsWc.isDestroyed())
+            return;
+        let json;
+        try {
+            json = JSON.stringify({ method, params });
+        }
+        catch {
+            return;
+        }
+        // Same settled gate every other injection point in this file uses: an
+        // unsettled front-end wipes its state on load anyway, and executeJavaScript
+        // against it queues one did-stop-loading waiter per call — piling toward
+        // the MaxListeners ceiling during the global host's boot window. Unlike
+        // those injection points, the events here are NOT re-derivable later, so
+        // they queue for a post-settle flush instead of dropping.
+        if (!isFrontendSettled(globalDevtoolsWc)) {
+            enqueueGlobalPending(json);
+            return;
+        }
+        // Anything still queued flushes first so delivery order matches arrival.
+        flushGlobalPending();
+        // Oversized single messages take the chunked transport, mirroring the
+        // native sink's flushDispatch — see flushGlobalPending's doc.
+        if (json.length > MAX_SINGLE_DISPATCH_CHARS) {
+            dispatchChunked(globalDevtoolsWc, json);
+            return;
+        }
+        globalDevtoolsWc.executeJavaScript(buildDispatchScript([json]), true).catch(() => { });
+    }
     // ── Native-sink state machine ─────────────────────────────────────────────
     let sink = 'idle';
     // Buffered completed-request records while 'probing' — flushed to console if we
@@ -625,6 +790,12 @@ export function createNetworkForwarder(bridge) {
         // Fallback bookkeeping: requestId → in-flight request, for the console line
         // when the native dispatch path is unusable.
         const pending = new Map();
+        // User-facing classification, decided ONCE at
+        // requestWillBeSent (the only event carrying a url) and consulted by every
+        // later event on the same rawId — later events (responseReceived/
+        // loadingFinished/loadingFailed) carry no url, so they cannot re-derive
+        // the verdict; they must remember it.
+        const userFacingByRawId = new Map();
         // Raw ids whose requestWillBeSent announced a post body that was NOT
         // inlined (`hasPostData` without `postData`) — the only case the front-end
         // round-trips `Network.getRequestPostData`. Consumed at loadingFinished.
@@ -638,9 +809,15 @@ export function createNetworkForwarder(bridge) {
          * bodies would only burn memory.
          */
         const prefetchBodies = (rawId, encodedDataLength) => {
-            if (sink === 'degraded')
-                return;
-            if (sink === 'idle' && !resolveDevtoolsWc())
+            // Skip only when NEITHER consumer can use the body: the user-facing
+            // sink is unusable (degraded, or idle with no host) AND the global
+            // mirror has no host either. Either alone is enough reason to prefetch
+            // — 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 globalUsable = globalDevtoolsWc !== null && !globalDevtoolsWc.isDestroyed();
+            if (!userSinkUsable && !globalUsable)
                 return;
             const virtualId = ns.resolve(rawId);
             // Skip the CDP round-trip entirely for a response already known (from
@@ -693,23 +870,32 @@ export function createNetworkForwarder(bridge) {
             if (req)
                 req.status = p.response?.status ?? 0;
         }
+        /** Shared "request terminated" bookkeeping for both loadingFinished and
+         *  loadingFailed: drop the classification + pending record, returning the
+         *  pending entry (or undefined if it was already gone/never seen). */
+        function retirePending(rawId) {
+            userFacingByRawId.delete(rawId);
+            const req = pending.get(rawId);
+            if (!req)
+                return undefined;
+            pending.delete(rawId);
+            return req;
+        }
         function onLoadingFinished(params) {
             const p = params;
             if (typeof p?.requestId === 'string')
                 prefetchBodies(p.requestId, p.encodedDataLength);
-            const req = pending.get(p.requestId);
+            const req = retirePending(p?.requestId);
             if (!req)
                 return;
-            pending.delete(p.requestId);
             maybeFallback({ source, url: req.url, method: req.method, status: req.status });
         }
         function onLoadingFailed(params) {
             const p = params;
             postDataWanted.delete(p?.requestId);
-            const req = pending.get(p.requestId);
+            const req = retirePending(p?.requestId);
             if (!req)
                 return;
-            pending.delete(p.requestId);
             maybeFallback({
                 source,
                 url: req.url,
@@ -724,11 +910,61 @@ export function createNetworkForwarder(bridge) {
             'Network.loadingFinished': onLoadingFinished,
             'Network.loadingFailed': onLoadingFailed,
         };
+        /**
+         * Resolve (and, on `requestWillBeSent`, record) whether `rawId` is
+         * user-facing. MUST be computed eagerly here — not deferred to
+         * `onRequestWillBeSent` below, which runs AFTER this in `onMessage` — a
+         * `requestWillBeSent` is itself a FORWARDED_METHODS event whose own
+         * routing decision depends on the very verdict it establishes. Every
+         * later event for the same rawId (no url of its own) just looks up the
+         * recorded verdict; an unknown rawId fails open (user-facing) rather
+         * 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?.()])
+                    : true;
+                if (rawId) {
+                    if (userFacingByRawId.size >= MAX_PENDING)
+                        userFacingByRawId.clear();
+                    userFacingByRawId.set(rawId, verdict);
+                }
+                return verdict;
+            }
+            if (rawId && userFacingByRawId.has(rawId))
+                return userFacingByRawId.get(rawId);
+            // `Network.requestWillBeSentExtraInfo` can arrive BEFORE its own
+            // `requestWillBeSent` (real CDP ordering) — it carries no url, so an
+            // unrecorded rawId here means "classification not yet known", not
+            // "capture attached mid-flight". Fail CLOSED for this one case: the
+            // very next event for the same rawId is (almost always) the real
+            // requestWillBeSent, which establishes the true verdict immediately —
+            // dropping this one early line is a far smaller cost than leaking an
+            // internal resource's ExtraInfo into the user-facing panel before its
+            // 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')
+                return false;
+            return true;
+        }
         const onMessage = (_event, method, params) => {
             // ── Primary sink: forward the raw CDP event into the DevTools front-end ──
             if (FORWARDED_METHODS.has(method)) {
                 const rewritten = rewriteRequestId(method, params, ns);
-                enqueueNative(rewritten.method, rewritten.params);
+                // Global mirror: full, unfiltered — independent of the
+                // user-facing sink's classification and state machine.
+                dispatchToGlobal(rewritten.method, rewritten.params);
+                // 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);
+                if (userFacing) {
+                    enqueueNative(rewritten.method, rewritten.params);
+                }
             }
             else if (REWRITE_REQUEST_ID_METHODS.has(method)) {
                 // Methods we namespace but don't forward (dataReceived): still resolve
@@ -1024,6 +1260,17 @@ export function createNetworkForwarder(bridge) {
             readyRetryTimer = null;
         }
     });
+    registry.add(() => {
+        globalDevtoolsHostDisposable?.dispose();
+        globalDevtoolsHostDisposable = null;
+        globalBodyGateStop?.();
+        globalBodyGateStop = null;
+        globalDevtoolsWc = null;
+        // A live settle-poll timer at dispose time is a real-timer leak (this
+        // suite's flaky-test history: undisposed timers adopted by later tests'
+        // fake clocks).
+        clearGlobalPending();
+    });
     registry.add(() => {
         bodyCache.clear();
         postDataCache.clear();
@@ -1051,6 +1298,7 @@ export function createNetworkForwarder(bridge) {
         detachSimulator,
         attachRenderGuest,
         setDevtoolsHost: (wc) => applyDevtoolsHost(wc),
+        setGlobalDevtoolsHost: (wc) => applyGlobalDevtoolsHost(wc),
         // report() has no observing debugger, so there's no live CDP event to push
         // natively — surface it via the console fallback line.
         report: (record) => forwardToConsole(record),

package/dist/main/services/network-forward/user-facing.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Judges whether a captured network request belongs on the user-facing
+ * (right-panel) DevTools Network tab, or should be hidden there — a
+ * framework/host-internal resource load, visible only in the standalone
+ * internal DevTools window's unfiltered global mirror.
+ *
+ * Single source of truth for the split (network-forward's user-facing sink
+ * and the global mirror both key off this): scheme must be one of
+ * http/https/ws/wss, AND the request's origin must not match ANY of
+ * `internalOrigins` — each is a base URL of a server this app itself runs
+ * whose own traffic is host-internal, not the developer's business traffic.
+ * There are currently two: the resource server (serves the compiled
+ * mini-app bundle) and the simulator's own static-asset server (serves
+ * `simulator.html` + its JS/CSS — a THIRD-PARTY-to-the-user-code origin the
+ * `attachSimulator` CDP session also observes, since it captures the whole
+ * simulator WebContentsView's network activity, not just the mini-app's own
+ * `wx.request` calls). `null`/`undefined` entries (a server not currently
+ * running, e.g. no project open) are skipped, not treated as a match.
+ */
+export declare function isUserFacingRequest(url: string, internalOrigins?: ReadonlyArray<string | null | undefined>): boolean;
+//# sourceMappingURL=user-facing.d.ts.map

package/dist/main/services/network-forward/user-facing.js

@@ -0,0 +1,50 @@
+/** URL schemes that can carry the mini-app author's own business traffic. */
+const USER_FACING_SCHEMES = new Set(['http:', 'https:', 'ws:', 'wss:']);
+/**
+ * Judges whether a captured network request belongs on the user-facing
+ * (right-panel) DevTools Network tab, or should be hidden there — a
+ * framework/host-internal resource load, visible only in the standalone
+ * internal DevTools window's unfiltered global mirror.
+ *
+ * Single source of truth for the split (network-forward's user-facing sink
+ * and the global mirror both key off this): scheme must be one of
+ * http/https/ws/wss, AND the request's origin must not match ANY of
+ * `internalOrigins` — each is a base URL of a server this app itself runs
+ * whose own traffic is host-internal, not the developer's business traffic.
+ * There are currently two: the resource server (serves the compiled
+ * mini-app bundle) and the simulator's own static-asset server (serves
+ * `simulator.html` + its JS/CSS — a THIRD-PARTY-to-the-user-code origin the
+ * `attachSimulator` CDP session also observes, since it captures the whole
+ * simulator WebContentsView's network activity, not just the mini-app's own
+ * `wx.request` calls). `null`/`undefined` entries (a server not currently
+ * running, e.g. no project open) are skipped, not treated as a match.
+ */
+export function isUserFacingRequest(url, internalOrigins) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        // Real CDP `Network.requestWillBeSent.request.url` is always a fully
+        // qualified URL — this only happens for hand-authored test/placeholder
+        // input. Fail OPEN (treat as user-facing): hiding a request the caller
+        // couldn't even classify risks silently swallowing real business
+        // traffic, a worse outcome than occasionally over-showing something.
+        return true;
+    }
+    if (!USER_FACING_SCHEMES.has(parsed.protocol))
+        return false;
+    for (const baseUrl of internalOrigins ?? []) {
+        if (!baseUrl)
+            continue;
+        try {
+            if (parsed.origin === new URL(baseUrl).origin)
+                return false;
+        }
+        catch {
+            // Malformed baseUrl — can't compare, so don't let it hide anything.
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=user-facing.js.map