cocos-web-inspector-mcp 2.2.1 → 2.4.0

package/dist/src/browser-data.d.ts

@@ -13,11 +13,26 @@ export declare function consoleMessages(page: Page, options: {
     textContains?: string | undefined;
     limit?: number | undefined;
 }): Promise<unknown>;
-export declare function networkRequests(page: Page, options: {
+export declare function networkRequests(page: Page, options: RequestFilter): Promise<unknown>;
+type RequestRow = {
+    url: string;
+    resourceType: string;
+    status: number | null;
+    failure?: string;
+};
+type RequestFilter = {
     urlContains?: string | undefined;
     resourceType?: string | undefined;
     failedOnly?: boolean | undefined;
     limit?: number | undefined;
-}): Promise<unknown>;
+};
+/** Filters request rows and keeps the newest `limit`; shared by the browser and native network tools. */
+export declare function selectRequests<T extends RequestRow>(rows: T[], options: RequestFilter, note: string): {
+    requests: T[];
+    matched: number;
+    truncated: boolean;
+    note: string;
+};
 export declare function networkRequest(page: Page, id: number, includeBody: boolean): Promise<unknown>;
 export declare function storage(page: Page, area: 'local' | 'session' | 'cookies', keyContains?: string, limit?: number): Promise<unknown>;
+export {};

package/dist/src/browser-data.js

@@ -84,7 +84,6 @@ const idOf = (request) => {
     return id;
 };
 export async function networkRequests(page, options) {
-    const limit = options.limit ?? 50;
     const rows = await Promise.all((await page.requests()).map(async (request) => {
         const response = await request.response().catch(() => null);
         const failure = request.failure()?.errorText;
@@ -99,10 +98,15 @@ export async function networkRequests(page, options) {
             ...(timing.responseEnd > 0 ? { durationMs: Math.round(timing.responseEnd) } : {}),
         };
     }));
+    return selectRequests(rows, options, 'Requests since this server attached; Playwright drops old entries to bound memory.');
+}
+/** Filters request rows and keeps the newest `limit`; shared by the browser and native network tools. */
+export function selectRequests(rows, options, note) {
+    const limit = options.limit ?? 50;
     const matched = rows.filter(row => (!options.urlContains || row.url.includes(options.urlContains))
         && (!options.resourceType || row.resourceType === options.resourceType)
         && (!options.failedOnly || row.failure || (row.status ?? 0) >= 400));
-    return { requests: matched.slice(-limit), matched: matched.length, truncated: matched.length > limit, note: 'Requests since this server attached; Playwright drops old entries to bound memory.' };
+    return { requests: matched.slice(-limit), matched: matched.length, truncated: matched.length > limit, note };
 }
 export async function networkRequest(page, id, includeBody) {
     const request = (await page.requests()).find(candidate => requestIds.get(candidate) === id);
@@ -132,6 +136,9 @@ export async function networkRequest(page, id, includeBody) {
 }
 export async function storage(page, area, keyContains, limit = 100) {
     if (area === 'cookies') {
+        // A native (JSB) runtime has no browser context or cookie jar.
+        if (typeof page.context !== 'function')
+            return { area, available: false, reason: 'UNSUPPORTED_PUBLIC_API', entries: [], matched: 0, truncated: false };
         // Cookie values are always withheld; names and attributes are enough to debug expiry and scope.
         const cookies = (await page.context().cookies(page.url())).filter(cookie => !keyContains || cookie.name.includes(keyContains));
         return {
@@ -141,8 +148,11 @@ export async function storage(page, area, keyContains, limit = 100) {
             truncated: cookies.length > limit,
         };
     }
+    // Native (JSB) builds have localStorage only, backed by a SQLite file; there is no sessionStorage or cookie jar.
     const entries = await page.evaluate(store => {
-        const target = store === 'local' ? localStorage : sessionStorage;
+        const target = store === 'local' ? localStorage : globalThis.sessionStorage;
+        if (!target)
+            return null;
         const out = [];
         for (let index = 0; index < target.length && index < 5_000; index++) {
             const key = target.key(index);
@@ -151,6 +161,8 @@ export async function storage(page, area, keyContains, limit = 100) {
         }
         return out;
     }, area);
+    if (!entries)
+        return { area, available: false, reason: 'UNSUPPORTED_PUBLIC_API', entries: [], matched: 0, truncated: false };
     const matched = entries.filter(([key]) => !keyContains || key.includes(keyContains));
     return {
         area,

package/dist/src/browser.js

@@ -82,8 +82,10 @@ export class BrowserConnection {
         if (pageUrl) {
             const wanted = validateLocalUrl(pageUrl, true).href;
             const selected = pages.filter(candidate => new URL(candidate.url()).href === wanted);
-            if (selected.length === 0)
-                throw new InspectorError('PAGE_NOT_FOUND', `Local page not found: ${sanitizeUrl(pageUrl)}`);
+            if (selected.length === 0) {
+                const open = pages.slice(0, 10).map(candidate => sanitizeUrl(candidate.url())).join(', ');
+                throw new InspectorError('PAGE_NOT_FOUND', `Local page not found: ${sanitizeUrl(pageUrl)} (pageUrl must equal the full open page URL including query and fragment; open pages, shown without them: ${open || 'none'})`);
+            }
             if (selected.length > 1)
                 throw new InspectorError('MULTIPLE_PAGES', `Multiple localhost pages match pageUrl: ${sanitizeUrl(pageUrl)}; close duplicate tabs or use a separate Chromium per project`);
             return selected[0];
@@ -139,7 +141,8 @@ export class BrowserConnection {
             const hint = /\b404\b/.test(message)
                 ? '; port is likely held by Chrome built-in remote debugging (chrome://inspect/#remote-debugging), which has no /json/version: turn it off or use another port, check with lsof -nP -iTCP:<port> -sTCP:LISTEN'
                 : '';
-            throw new InspectorError('CDP_UNAVAILABLE', `Unable to connect to Chromium CDP: ${message}${hint}`);
+            const launch = /ECONNREFUSED/.test(message) ? '; no Chromium is listening there: start one with --remote-debugging-port=<port> --user-data-dir=<dir>, or point the server at the right port with --cdp-endpoint / COCOS_CDP_ENDPOINT' : '';
+            throw new InspectorError('CDP_UNAVAILABLE', `Unable to connect to Chromium CDP at ${sanitizeUrl(this.endpoint)}: ${message}${hint}${launch}`);
         });
         this.#connecting = connecting;
         try {

package/dist/src/cli.js

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { chromium } from 'playwright-core';
 import { BrowserConnection, InspectorError, sanitizeUrl, validateLocalUrl } from './browser.js';
 import { devicePresetNames, emulateDevice, inspectCocosPage, networkProfileNames } from './bridge.js';
+import { forwardInspector, NativeConnection } from './native.js';
 const write = (line) => process.stdout.write(`${line}\n`);
 function flags(args, names, booleans = []) {
     const values = {};
@@ -124,10 +125,39 @@ async function launch(args) {
     await exited;
     process.exit(0);
 }
+// Native debug builds: find the inspector port in logcat, forward it over adb, and check the Cocos runtime through it.
+async function nativeDoctor() {
+    const fail = (code, message, fix) => {
+        write(`FAIL  ${code}: ${message}\n      Fix: ${fix}`);
+        process.exitCode = 1;
+    };
+    let port;
+    try {
+        port = await forwardInspector();
+    }
+    catch (error) {
+        return fail('CDP_UNAVAILABLE', error instanceof Error ? error.message : 'adb failed', 'install Android platform-tools, check adb devices, and set ANDROID_SERIAL when several devices are attached');
+    }
+    if (port === undefined)
+        return fail('CDP_UNAVAILABLE', 'no "Debugger listening" line in the device log', 'start a Cocos native build made with Debug checked; release builds have no inspector');
+    write(`ok    debug build listens on device port ${port}; forwarded to 127.0.0.1:${port}`);
+    const endpoint = `http://127.0.0.1:${port}`;
+    const info = await (await new NativeConnection(endpoint).page()).evaluate(inspectCocosPage).catch(error => error);
+    if (info instanceof Error)
+        return fail('CDP_UNAVAILABLE', info.message, 'close Chrome DevTools attached to the game; the inspector takes one session at a time');
+    if (!info.cocos?.detected)
+        return fail('COCOS_NOT_FOUND', 'no Cocos Creator 3.x runtime in the app', 'wait for the game to finish loading');
+    if (!info.cocos.sceneName)
+        return fail('SCENE_NOT_READY', `Cocos ${info.cocos.version} has no active scene yet`, 'wait for the first scene to load');
+    write(`ok    Cocos ${info.cocos.version}, scene "${info.cocos.sceneName}"`);
+    write(`\nAdd it to Claude Code:\n  claude mcp add cocos-native -- npx -y cocos-web-inspector-mcp --native-endpoint ${endpoint}`);
+}
 async function doctor(args) {
-    const { values, positional } = flags(args, ['--cdp-endpoint']);
+    const { values, positional } = flags(args, ['--cdp-endpoint'], ['--native']);
     if (positional.length)
-        throw new Error('Usage: cocos-web-inspector-mcp doctor [--cdp-endpoint <url>]');
+        throw new Error('Usage: cocos-web-inspector-mcp doctor [--cdp-endpoint <url> | --native]');
+    if (values['--native'])
+        return nativeDoctor();
     const endpoint = values['--cdp-endpoint'] ?? process.env.COCOS_CDP_ENDPOINT ?? 'http://127.0.0.1:9222';
     let failed = false;
     const pass = (message) => write(`ok    ${message}`);

package/dist/src/native.d.ts

@@ -1,4 +1,6 @@
 import type { Page } from 'playwright-core';
+import { type Clip } from './bridge.js';
+import { selectRequests } from './browser-data.js';
 type Evaluate = (webSocketUrl: string, expression: string, timeout: number) => Promise<unknown>;
 export declare class NativeConnection {
     #private;
@@ -11,6 +13,16 @@ export declare class NativeConnection {
 }
 export declare function nativeClick(page: Page, uuid: string): Promise<unknown>;
 export declare function nativeDrag(page: Page, uuid: string, dx: number, dy: number, durationMs?: number): Promise<unknown>;
+export declare function nativeCaptureNode(page: Page, uuid: string, maxBytes?: number): Promise<unknown>;
+/** Crops a raw screencap to the clip and encodes an RGB PNG, sampling every n-th pixel until it fits the response. */
+export declare function cropPng(raw: Buffer, clip: Clip, maxBytes?: number): unknown;
+/**
+ * The inspector port from the engine's own "Debugger listening" logcat lines: the latest one, or `expected` only when
+ * some line names it. Any app can log under the Cocos tag, so reconnects pass the port they already used.
+ */
+export declare function inspectorPort(logcat: string, expected?: number): number | undefined;
+/** Forwards the device's inspector port to the same loopback port; returns it, or undefined when no debug build has logged one. */
+export declare function forwardInspector(expected?: number): Promise<number | undefined>;
 /** Parses `logcat -v epoch` lines of the Cocos tag; console.log and console.debug share one level there and map to log. */
 export declare function parseCocosLogcat(output: string): Array<{
     type: string;
@@ -22,5 +34,8 @@ export declare function nativeConsoleMessages(page: Page, options: {
     textContains?: string | undefined;
     limit?: number | undefined;
 }): Promise<unknown>;
+export declare function nativePressKey(_page: Page, key: string): Promise<unknown>;
 export declare function nativeTypeText(page: Page, uuid: string, text: string, submit: boolean): Promise<unknown>;
+export declare function nativeNetworkRequests(page: Page, options: Parameters<typeof selectRequests>[1]): Promise<unknown>;
+export declare function nativeNetworkRequest(page: Page, id: number, includeBody: boolean): Promise<unknown>;
 export {};

package/dist/src/native.js

@@ -1,8 +1,9 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { nodeCenter, runBridge } from './bridge.js';
+import { crc32, deflateSync, gunzipSync } from 'node:zlib';
+import { fitsImage, fitsResponse, nodeCenter, runBridge, visibleClip } from './bridge.js';
 import { InspectorError, validateLocalUrl } from './browser.js';
-import { redactText } from './browser-data.js';
+import { redactBody, redactHeaders, redactText, redactUrl, selectRequests } from './browser-data.js';
 // Cocos native debug builds (V8) run a Node-style inspector: Runtime and Debugger domains only, no pages, one session at a time.
 // ponytail: one WebSocket per call so Chrome DevTools can attach between calls; keep a socket open if per-call latency matters.
 export class NativeConnection {
@@ -27,14 +28,21 @@ export class NativeConnection {
         return this.#page;
     }
     async close() { }
+    async #targets() {
+        const response = await fetch(new URL('/json/list', this.#http), { signal: AbortSignal.timeout(10_000) });
+        return await response.json();
+    }
     async #evaluate(fn, arg) {
         let targets;
         try {
-            const response = await fetch(new URL('/json/list', this.#http), { signal: AbortSignal.timeout(10_000) });
-            targets = await response.json();
+            targets = await this.#targets();
         }
         catch (error) {
-            throw new InspectorError('CDP_UNAVAILABLE', `Unable to reach the native inspector at ${this.#http.host}: ${error instanceof Error ? error.message : 'unknown error'}; run the debug build, find its port in logcat "Debugger listening", then adb forward tcp:<port> tcp:<port>`);
+            // An adb server restart or a USB drop takes the forward with it; restore it once, only to the device port this endpoint names.
+            const restored = await forwardInspector(Number(this.#http.port)).catch(() => undefined);
+            targets = restored === undefined ? [] : await this.#targets().catch(() => []);
+            if (!targets.length)
+                throw new InspectorError('CDP_UNAVAILABLE', `Unable to reach the native inspector at ${this.#http.host}: ${error instanceof Error ? error.message : 'unknown error'}; check that the debug build is running and adb sees the device (run doctor --native)`);
         }
         if (!Array.isArray(targets) || targets.length === 0)
             throw new InspectorError('NO_LOCAL_PAGE', 'Native inspector lists no target');
@@ -79,15 +87,16 @@ async function evaluateOverWebSocket(webSocketUrl, expression, timeout) {
 // Real input and logs go through adb on the device the inspector is forwarded from. adb picks the device itself;
 // with several attached, set ANDROID_SERIAL. Arguments are numbers or a validated package name, never free text.
 const run = promisify(execFile);
-async function adb(args) {
+async function adbBuffer(args) {
     try {
-        return (await run('adb', args, { timeout: 15_000, maxBuffer: 16 * 1024 * 1024 })).stdout;
+        return (await run('adb', args, { encoding: 'buffer', timeout: 15_000, maxBuffer: 16 * 1024 * 1024 })).stdout;
     }
     catch (error) {
         const message = error instanceof Error ? error.message.split('\n')[0] : 'unknown error';
         throw new InspectorError('CDP_UNAVAILABLE', `adb ${args[0]} failed: ${message.slice(0, 300)}; check adb devices, and set ANDROID_SERIAL when several are attached`);
     }
 }
+const adb = async (args) => (await adbBuffer(args)).toString();
 // ponytail: viewport coordinates equal screen pixels only for a full-screen game (the Cocos default); add the window offset for windowed apps.
 const pixel = (value) => String(Math.round(value));
 const settle = () => new Promise(resolve => setTimeout(resolve, 300));
@@ -110,6 +119,65 @@ export async function nativeDrag(page, uuid, dx, dy, durationMs = 300) {
     await settle();
     return { dragged: true, target: { nodeUuid: uuid }, from, to, input: 'adb', runtimeOnly: true };
 }
+// Raw `screencap` output: width, height, and pixel format as uint32 LE, a colorspace word on Android 12+, then RGBA rows
+// in the current display rotation. The device gzips it (18 MB raw takes ~20 s over Wi-Fi adb, ~1.5 s gzipped), and cropping
+// raw pixels needs only zlib here, where decoding `screencap -p` would need a PNG decoder.
+export async function nativeCaptureNode(page, uuid, maxBytes) {
+    const clip = await visibleClip(page, uuid);
+    if ('reason' in clip)
+        return { captured: false, reason: clip.reason };
+    const raw = gunzipSync(await adbBuffer(['exec-out', 'screencap | gzip -1']), { maxOutputLength: 256 * 1024 * 1024 });
+    return cropPng(raw, clip, maxBytes);
+}
+/** Crops a raw screencap to the clip and encodes an RGB PNG, sampling every n-th pixel until it fits the response. */
+export function cropPng(raw, clip, maxBytes) {
+    if (raw.length < 12)
+        return { captured: false, reason: 'SCREENCAP_FAILED' };
+    const screenWidth = raw.readUInt32LE(0);
+    const screenHeight = raw.readUInt32LE(4);
+    const header = raw.length - screenWidth * screenHeight * 4;
+    // 1 is RGBA_8888 and 2 is RGBX_8888; other formats are not 4 bytes per pixel.
+    if (![1, 2].includes(raw.readUInt32LE(8)) || (header !== 12 && header !== 16))
+        return { captured: false, reason: 'UNSUPPORTED_PIXEL_FORMAT' };
+    // ponytail: viewport pixels equal screen pixels only for a full-screen game, as for adb taps; add the window offset for windowed apps.
+    const left = Math.max(0, Math.floor(clip.x));
+    const top = Math.max(0, Math.floor(clip.y));
+    const right = Math.min(screenWidth, Math.ceil(clip.x + clip.width));
+    const bottom = Math.min(screenHeight, Math.ceil(clip.y + clip.height));
+    if (right <= left || bottom <= top)
+        return { captured: false, reason: 'OUTSIDE_VIEWPORT' };
+    // ponytail: nearest-pixel sampling keeps this dependency-free; box filtering would read text better when downscaled.
+    for (const step of [1, 2, 3, 4, 6, 8]) {
+        const width = Math.ceil((right - left) / step);
+        const height = Math.ceil((bottom - top) / step);
+        const rows = Buffer.alloc((width * 3 + 1) * height);
+        for (let y = 0; y < height; y++) {
+            const out = y * (width * 3 + 1) + 1;
+            const source = header + ((top + y * step) * screenWidth + left) * 4;
+            for (let x = 0; x < width; x++)
+                raw.copy(rows, out + x * 3, source + x * step * 4, source + x * step * 4 + 3);
+        }
+        const data = png(width, height, rows).toString('base64');
+        if (fitsImage(data, maxBytes))
+            return { captured: true, mimeType: 'image/png', data, width: right - left, height: bottom - top, ...(step > 1 ? { scale: 1 / step } : {}) };
+    }
+    return { captured: false, reason: 'RESPONSE_LIMIT' };
+}
+function png(width, height, rows) {
+    const chunk = (type, body) => {
+        const head = Buffer.alloc(8);
+        head.writeUInt32BE(body.length, 0);
+        head.write(type, 4, 'ascii');
+        const crc = Buffer.alloc(4);
+        crc.writeUInt32BE(crc32(body, crc32(type)), 0);
+        return Buffer.concat([head, body, crc]);
+    };
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr.set([8, 2, 0, 0, 0], 8); // 8-bit RGB, no interlace
+    return Buffer.concat([Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]), chunk('IHDR', ihdr), chunk('IDAT', deflateSync(rows, { level: 9 })), chunk('IEND', Buffer.alloc(0))]);
+}
 // The app's own process, from its files directory, so logs of other Cocos apps on the device never mix in.
 async function appProcess(page) {
     const path = String(await page.evaluate(() => globalThis.jsb?.fileUtils?.getWritablePath?.() ?? ''));
@@ -121,6 +189,21 @@ async function appProcess(page) {
         throw new InspectorError('CDP_UNAVAILABLE', `App ${name} is not running`);
     return pid;
 }
+/**
+ * The inspector port from the engine's own "Debugger listening" logcat lines: the latest one, or `expected` only when
+ * some line names it. Any app can log under the Cocos tag, so reconnects pass the port they already used.
+ */
+export function inspectorPort(logcat, expected) {
+    const ports = [...logcat.matchAll(/js_app\.html\?v8only=true&ws=[^:\s]+:(\d{2,5})\//g)].map(match => Number(match[1])).filter(port => port >= 1_024 && port <= 65_535);
+    return expected === undefined ? ports.at(-1) : ports.includes(expected) ? expected : undefined;
+}
+/** Forwards the device's inspector port to the same loopback port; returns it, or undefined when no debug build has logged one. */
+export async function forwardInspector(expected) {
+    const port = inspectorPort(await adb(['logcat', '-d', '-s', 'Cocos:D']), expected);
+    if (port !== undefined)
+        await adb(['forward', `tcp:${port}`, `tcp:${port}`]);
+    return port;
+}
 const levels = { V: 'debug', D: 'log', I: 'info', W: 'warning', E: 'error', F: 'error' };
 /** Parses `logcat -v epoch` lines of the Cocos tag; console.log and console.debug share one level there and map to log. */
 export function parseCocosLogcat(output) {
@@ -146,6 +229,17 @@ export async function nativeConsoleMessages(page, options) {
         note: 'Cocos-tagged logcat lines of the app process since it started, bounded by the device log buffer. Engine lines start with D/ or E/; an uncaught JS error spans several error lines (message, then stack).',
     };
 }
+const androidKeys = { Enter: 'KEYCODE_ENTER', Escape: 'KEYCODE_ESCAPE', Tab: 'KEYCODE_TAB', Delete: 'KEYCODE_DEL', Space: 'KEYCODE_SPACE', ArrowUp: 'KEYCODE_DPAD_UP', ArrowDown: 'KEYCODE_DPAD_DOWN', ArrowLeft: 'KEYCODE_DPAD_LEFT', ArrowRight: 'KEYCODE_DPAD_RIGHT', Home: 'KEYCODE_MOVE_HOME', End: 'KEYCODE_MOVE_END', PageUp: 'KEYCODE_PAGE_UP', PageDown: 'KEYCODE_PAGE_DOWN' };
+// The native engine reports AKEYCODE_DEL (the physical Backspace key) as Delete, has no entry for FORWARD_DEL, and reports Backspace only for
+// AKEYCODE_BACK, which leaves the app. So Delete maps to DEL and Backspace is refused rather than sent as a key the game would misread.
+export async function nativePressKey(_page, key) {
+    if (key === 'Backspace')
+        throw new Error('Invalid mutation: native builds deliver Backspace only for the system Back key, which leaves the app; use Delete, which the engine reports for the device Backspace key');
+    // Only validated key names reach adb, never free text.
+    await adb(['shell', 'input', 'keyevent', androidKeys[key] ?? `KEYCODE_${key.toUpperCase()}`]);
+    await settle();
+    return { pressed: true, key, input: 'adb', runtimeOnly: true };
+}
 // Tapping an EditBox on Android opens CocosEditBoxActivity, a native EditText whose every change fires text-changed in the game.
 export async function nativeTypeText(page, uuid, text, submit) {
     // input text only types printable ASCII and turns "%s" into a space, so refuse what it would silently mangle.
@@ -182,3 +276,173 @@ export async function nativeTypeText(page, uuid, text, submit) {
     const matches = typeof properties?.string === 'string' ? properties.string === text : undefined;
     return { typed: true, target: { nodeUuid: uuid }, length: text.length, submitted: submit, after, ...(matches === undefined ? {} : { matches }), ...(matches === false ? { hint: 'The device keyboard changed the text; switch it to a plain English layout without autocorrect' } : {}), input: 'adb', runtimeOnly: true };
 }
+function nativeNetwork(query) {
+    const root = globalThis;
+    const MAX_ENTRIES = 200;
+    const MAX_BODY = 100_000;
+    const clip = (value) => typeof value === 'string' ? value.slice(0, MAX_BODY)
+        : value instanceof ArrayBuffer ? `[binary ${value.byteLength} bytes]` : value == null ? '' : `[${typeof value}]`;
+    let state = root.__cocosWebInspectorNetwork;
+    const installedNow = !state;
+    if (!state) {
+        state = root.__cocosWebInspectorNetwork = { entries: [], nextId: 1, installedAt: Date.now() };
+        const record = (entry) => {
+            entry.id = state.nextId++;
+            state.entries.push(entry);
+            if (state.entries.length > MAX_ENTRIES)
+                state.entries.shift();
+            return entry;
+        };
+        const Xhr = root.XMLHttpRequest;
+        if (typeof Xhr === 'function') {
+            const proto = Xhr.prototype;
+            const open = proto.open;
+            const send = proto.send;
+            const setHeader = proto.setRequestHeader;
+            proto.open = function (method, url, ...rest) {
+                this.__cwi = { method: String(method).toUpperCase(), url: String(url), headers: {} };
+                return open.call(this, method, url, ...rest);
+            };
+            proto.setRequestHeader = function (name, value) {
+                // The ring lives in game memory that other game code can read, so credential headers are masked as they are captured.
+                // ponytail: bodies stay raw in the ring and are redacted only when returned; redact here too if third-party SDKs are a concern.
+                if (this.__cwi)
+                    this.__cwi.headers[String(name)] = /auth|cookie|token|secret|api-?key|password|session/i.test(String(name)) ? '[redacted]' : String(value);
+                return setHeader.call(this, name, value);
+            };
+            proto.send = function (body) {
+                const meta = this.__cwi;
+                if (meta) {
+                    const entry = record({ kind: 'xhr', method: meta.method, url: meta.url, requestHeaders: meta.headers, requestBody: clip(body), startedAt: Date.now() });
+                    this.__cwiDone = (failure) => {
+                        if (entry.endedAt)
+                            return;
+                        entry.endedAt = Date.now();
+                        entry.status = Number(this.status) || null;
+                        if (failure)
+                            entry.failure = failure;
+                        try {
+                            entry.responseHeaders = String(this.getAllResponseHeaders() ?? '').slice(0, 10_000);
+                        }
+                        catch { /* not ready */ }
+                        try {
+                            entry.responseBody = clip(this.responseType === '' || this.responseType === 'text' ? this.responseText : this.response);
+                        }
+                        catch { /* unreadable */ }
+                    };
+                    // Native XHR dispatches only through on* properties, and its addEventListener just assigns them, so listeners
+                    // would replace the game's handlers. Chain through accessors instead; the native side reads them with a plain get.
+                    // ponytail: reading xhr.onload returns the chain, not the game's function; keep a handler map if identity matters.
+                    if (!this.__cwiHooked) {
+                        this.__cwiHooked = true;
+                        const xhr = this;
+                        for (const [name, failure] of [['onload', undefined], ['onerror', 'error'], ['ontimeout', 'timeout'], ['onabort', 'abort']]) {
+                            let handler = this[name];
+                            const chain = function (event) {
+                                try {
+                                    xhr.__cwiDone(failure);
+                                }
+                                catch { /* never break the game */ }
+                                return typeof handler === 'function' ? handler.call(this, event) : undefined;
+                            };
+                            Object.defineProperty(this, name, { configurable: true, get: () => chain, set: (fn) => { handler = fn; } });
+                        }
+                    }
+                }
+                return send.call(this, body);
+            };
+        }
+        const NativeSocket = root.WebSocket;
+        if (typeof NativeSocket === 'function') {
+            // Pass every argument through: native WebSocket takes (url, protocols, caFilePath), and dropping the CA file
+            // changes how the game's TLS connection is verified.
+            const Wrapped = function (...args) {
+                const socket = new NativeSocket(...args);
+                const entry = record({ kind: 'websocket', method: 'GET', url: String(args[0]), startedAt: Date.now(), frames: [], framesSeen: 0 });
+                const frame = (direction, data) => {
+                    entry.framesSeen++;
+                    entry.frames.push({ direction, at: Date.now(), data: clip(data).slice(0, 2_000) });
+                    if (entry.frames.length > 50)
+                        entry.frames.shift();
+                };
+                const send = socket.send;
+                socket.send = function (data) { frame('sent', data); return send.call(socket, data); };
+                // Native sockets dispatch only through on* properties; wrap each handler as the game assigns it.
+                for (const [name, hook] of [
+                    ['onopen', () => { entry.status = 101; }],
+                    ['onmessage', (event) => frame('received', event?.data)],
+                    ['onerror', () => { entry.failure = 'error'; }],
+                    ['onclose', (event) => { entry.endedAt = Date.now(); entry.closeCode = Number(event?.code) || null; }],
+                ]) {
+                    let handler = null;
+                    Object.defineProperty(socket, name, {
+                        configurable: true,
+                        get: () => handler,
+                        set: (fn) => { handler = typeof fn === 'function' ? function (event) { try {
+                            hook(event);
+                        }
+                        catch { /* never break the game */ } return fn.call(this, event); } : fn; },
+                    });
+                }
+                return socket;
+            };
+            Wrapped.prototype = NativeSocket.prototype;
+            for (const key of ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'])
+                Wrapped[key] = NativeSocket[key];
+            root.WebSocket = Wrapped;
+        }
+    }
+    if (query.action === 'list')
+        return { installedAt: state.installedAt, installedNow, entries: state.entries.map(({ requestBody: _b, responseBody: _r, frames: _f, requestHeaders: _h, responseHeaders: _rh, ...summary }) => summary) };
+    const entry = state.entries.find(candidate => candidate.id === query.id);
+    return entry ? { installedAt: state.installedAt, entry } : { installedAt: state.installedAt, entry: null };
+}
+const sinceNote = (installedAt, installedNow) => installedNow
+    ? 'Capture started with this call; make the game send traffic, then list again.'
+    : `Requests and WebSocket frames since capture started at ${new Date(installedAt).toISOString()}; the game keeps the last 200.`;
+export async function nativeNetworkRequests(page, options) {
+    const { installedAt, installedNow, entries } = await page.evaluate(nativeNetwork, { action: 'list' });
+    const rows = entries.map(entry => ({
+        id: entry.id,
+        method: entry.method,
+        url: redactUrl(entry.url),
+        resourceType: entry.kind,
+        status: entry.status ?? null,
+        ...(entry.failure ? { failure: String(entry.failure).slice(0, 300) } : {}),
+        ...(entry.endedAt ? { durationMs: entry.endedAt - entry.startedAt } : {}),
+        ...(entry.kind === 'websocket' ? { frames: entry.framesSeen } : {}),
+    }));
+    return selectRequests(rows, options, sinceNote(installedAt, installedNow));
+}
+export async function nativeNetworkRequest(page, id, includeBody) {
+    const { entry } = await page.evaluate(nativeNetwork, { action: 'get', id });
+    if (!entry)
+        throw new InspectorError('REQUEST_NOT_FOUND', `Request ${id} not found; list requests again, older entries are dropped`);
+    // Split each "name: value" line at its first colon only; dates and URLs carry more.
+    const headers = (raw) => Object.fromEntries(raw.split(/\r?\n/).map(line => /^([^:]+):\s*(.*)$/.exec(line)).filter(match => !!match).map(match => [match[1].trim().toLowerCase(), match[2]]));
+    const frames = entry.kind === 'websocket' && includeBody ? entry.frames.map((frame) => ({ direction: frame.direction, at: new Date(frame.at).toISOString(), data: redactBody(frame.data).body })) : undefined;
+    // Native results skip runBridge, so enforce the response ceiling here: drop the oldest frames, then the bodies.
+    let result = detail(entry, id, includeBody, headers, frames);
+    while (frames?.length && !fitsResponse(result)) {
+        frames.splice(0, Math.max(1, Math.ceil(frames.length / 4)));
+        result = { ...detail(entry, id, includeBody, headers, frames), framesDropped: true };
+    }
+    return fitsResponse(result) ? result : { ...detail(entry, id, false, headers, undefined), truncated: true, truncationReasons: ['RESPONSE_LIMIT'] };
+}
+function detail(entry, id, includeBody, headers, frames) {
+    return {
+        id,
+        method: entry.method,
+        url: redactUrl(entry.url),
+        resourceType: entry.kind,
+        ...(entry.requestHeaders ? { requestHeaders: redactHeaders(entry.requestHeaders) } : {}),
+        ...(includeBody && entry.requestBody ? { requestBody: redactBody(entry.requestBody) } : {}),
+        status: entry.status ?? null,
+        ...(entry.responseHeaders ? { responseHeaders: redactHeaders(headers(entry.responseHeaders)) } : {}),
+        ...(entry.failure ? { failure: String(entry.failure).slice(0, 300) } : {}),
+        ...(entry.closeCode ? { closeCode: entry.closeCode } : {}),
+        ...(includeBody && entry.responseBody ? { responseBody: redactBody(entry.responseBody) } : {}),
+        ...(entry.kind === 'websocket' ? { framesSeen: entry.framesSeen, ...(frames ? { frames } : {}) } : {}),
+        timing: { startedAt: new Date(entry.startedAt).toISOString(), ...(entry.endedAt ? { durationMs: entry.endedAt - entry.startedAt } : {}) },
+    };
+}