@parallax-rn/sdk 0.0.0-stage → 0.1.0-beta.2

package/dist/navigation.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAV_LIMITS = void 0;
+exports.scrubParams = scrubParams;
+exports.scrubPath = scrubPath;
+exports.entryOf = entryOf;
+exports.followNavigation = followNavigation;
+// The `navigation` source (plan 0013, 13.6): the state of a React Navigation container, read through its ref (duck-typed: `getRootState`, `addListener('state', fn)`; the SDK
+// never imports the library). `entryOf` is the SDK copy of the reader the server injects without the SDK (`core/src/app/nav/nav-script.ts`); a test runs both on the same states.
+const protocol_1 = require("@parallax-rn/protocol");
+exports.NAV_LIMITS = { depth: 8, routes: 50, paramDepth: 3, keys: 30, chars: 200, rootStateChars: 16000 };
+/** Params without secrets: keys by the picker's word rule, values shaped like a credential, long strings cut, depth and width capped, getters and functions never run. */
+function scrubParams(value, depth = 0, seen = []) {
+    if (typeof value === 'string')
+        return (0, protocol_1.looksRandom)(value) ? protocol_1.REDACTED_TEXT : value.length > exports.NAV_LIMITS.chars ? `${value.slice(0, exports.NAV_LIMITS.chars)}…` : value;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value === 'boolean' || value === null || value === undefined)
+        return value;
+    if (typeof value === 'function')
+        return '[function]';
+    if (typeof value !== 'object')
+        return String(value);
+    if (seen.indexOf(value) >= 0)
+        return '[circular]';
+    const isArray = Array.isArray(value);
+    if (depth >= exports.NAV_LIMITS.paramDepth)
+        return isArray ? `[array ${value.length}]` : '[object]';
+    seen.push(value);
+    const keys = Object.keys(value);
+    const out = {};
+    const list = [];
+    for (let i = 0; i < keys.length && i < exports.NAV_LIMITS.keys; i++) {
+        const key = keys[i];
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        const item = !descriptor || !('value' in descriptor) ? '[getter]' : !isArray && (0, protocol_1.isSecretKey)(key) ? protocol_1.REDACTED_TEXT : scrubParams(descriptor.value, depth + 1, seen);
+        if (isArray)
+            list.push(item);
+        else
+            out[key] = item;
+    }
+    seen.pop();
+    if (keys.length > exports.NAV_LIMITS.keys) {
+        const more = `… ${keys.length - exports.NAV_LIMITS.keys} more`;
+        if (isArray)
+            list.push(more);
+        else
+            out['…'] = more;
+    }
+    return isArray ? list : out;
+}
+/** A route's `path` (a deep link) with the value of every secret-looking query parameter masked. */
+function scrubPath(path) {
+    const at = path.indexOf('?');
+    if (at < 0)
+        return path;
+    const pairs = path.slice(at + 1).split('&');
+    const masked = pairs.map(pair => {
+        const eq = pair.indexOf('=');
+        return eq < 0 || !((0, protocol_1.isSecretKey)(pair.slice(0, eq)) || (0, protocol_1.looksRandom)(pair.slice(eq + 1))) ? pair : `${pair.slice(0, eq)}=${protocol_1.REDACTED_TEXT}`;
+    });
+    return `${path.slice(0, at)}?${masked.join('&')}`;
+}
+const isObject = (value) => typeof value === 'object' && value !== null;
+function reduceState(state, depth) {
+    const routes = state.routes;
+    if (!Array.isArray(routes) || depth >= exports.NAV_LIMITS.depth)
+        return null;
+    const out = { index: typeof state.index === 'number' ? state.index : routes.length - 1, routes: [] };
+    if (typeof state.type === 'string')
+        out.type = state.type;
+    for (let i = 0; i < routes.length && i < exports.NAV_LIMITS.routes; i++) {
+        const route = routes[i];
+        if (!isObject(route))
+            continue;
+        const reduced = { name: typeof route.name === 'string' ? route.name : '', key: typeof route.key === 'string' ? route.key : '' };
+        if (route.params !== undefined)
+            reduced.params = scrubParams(route.params);
+        if (typeof route.path === 'string')
+            reduced.path = scrubPath(route.path);
+        const nested = isObject(route.state) ? reduceState(route.state, depth + 1) : null;
+        if (nested)
+            reduced.state = nested;
+        out.routes.push(reduced);
+    }
+    return out;
+}
+/** The entry for one root state: the focused route (the deepest one following each navigator's `index`), its params and path, the route names from the root, the reduced state (dropped past 16,000 characters). Null: no routes. */
+function entryOf(rootState) {
+    var _a;
+    if (!isObject(rootState))
+        return null;
+    const root = reduceState(rootState, 0);
+    if (!root || root.routes.length === 0)
+        return null;
+    const stack = [];
+    let focused = null;
+    for (let node = root; node;) {
+        focused = (_a = node.routes[node.index]) !== null && _a !== void 0 ? _a : null;
+        if (!focused)
+            break;
+        stack.push(focused.name);
+        node = focused.state;
+    }
+    if (!focused)
+        return null;
+    const entry = { kind: 'state', route: focused.name, stack };
+    if (focused.params !== undefined)
+        entry.params = focused.params;
+    if (focused.path !== undefined)
+        entry.path = focused.path;
+    if (JSON.stringify(root).length <= exports.NAV_LIMITS.rootStateChars)
+        entry.rootState = root;
+    return entry;
+}
+/**
+ * Follows a container ref: `emit` gets an entry now and after every state change that differs from the last one. Returns the stop function. A ref that throws is ignored (the
+ * app must never see the SDK fail).
+ */
+function followNavigation(ref, emit) {
+    let last = '';
+    const read = () => {
+        try {
+            const entry = entryOf(ref.getRootState());
+            const text = entry ? JSON.stringify(entry) : '';
+            if (entry && text !== last) {
+                last = text;
+                emit({ ...entry, producer: 'adapter' });
+            }
+        }
+        catch {
+            /* the app's navigation must never break because of us */
+        }
+    };
+    let off;
+    try {
+        off = ref.addListener('state', read);
+    }
+    catch {
+        off = undefined;
+    }
+    read();
+    return () => {
+        if (typeof off === 'function') {
+            try {
+                off();
+            }
+            catch {
+                /* already gone */
+            }
+        }
+    };
+}

package/dist/network-capture.d.ts

@@ -0,0 +1,13 @@
+import type { NetworkEntry } from '@parallax-rn/protocol';
+import type { HostGlobal } from './host.js';
+import type { Installed } from './console-capture.js';
+export interface NetworkCaptureOptions {
+    readonly now: () => number;
+    /** The most characters of a request or response body kept; a longer one is cut (`responseBodyState: 'cut'`) and its size stays in `*BodyBytes`. */
+    readonly bodyChars: number;
+    readonly headerChars: number;
+    readonly stackChars: number;
+    onEntry(entry: NetworkEntry, time: number): void;
+}
+export declare function installNetworkCapture(host: HostGlobal, options: NetworkCaptureOptions): Installed | null;
+//# sourceMappingURL=network-capture.d.ts.map

package/dist/network-capture.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installNetworkCapture = installNetworkCapture;
+const format_js_1 = require("./format.js");
+const network_redact_js_1 = require("./network-redact.js");
+/** The SDK's own wrappers (named so, apart from the app's `open`), and the engine's frames, come first in a stack taken inside them; the app's call is the first frame after. */
+const OWN_FRAME = /^\s*at (\S+\.)?prn(Begin|Open|Fetch)\b|InternalBytecode|\(native\)/;
+function callSite(stack, max) {
+    if (!stack)
+        return undefined;
+    const lines = stack.split('\n').slice(1);
+    let first = 0;
+    while (first < lines.length && OWN_FRAME.test(lines[first]))
+        first++;
+    return (0, format_js_1.cap)(lines.slice(first).join('\n'), max).text;
+}
+const BINARY = /^(image|audio|video|font)\/|\/(octet-stream|pdf|zip|gzip|x-protobuf|wasm)$/i;
+const STREAM = /event-stream/i;
+function parseHeaders(raw) {
+    const out = {};
+    if (!raw)
+        return out;
+    const lines = raw.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const colon = lines[i].indexOf(':');
+        if (colon <= 0)
+            continue;
+        const name = lines[i].slice(0, colon).trim();
+        const value = lines[i].slice(colon + 1).trim();
+        out[name] = name in out ? `${out[name]}, ${value}` : value;
+    }
+    return out;
+}
+const headerOf = (headers, wanted) => {
+    const names = Object.keys(headers);
+    for (let i = 0; i < names.length; i++)
+        if (names[i].toLowerCase() === wanted)
+            return headers[names[i]];
+    return undefined;
+};
+/** The size and text of a request body as the app handed it to `send` / `fetch`: a string is the text; FormData, Blob and ArrayBuffer are described, never read. */
+function describeBody(body) {
+    if (body === undefined || body === null)
+        return {};
+    if (typeof body === 'string')
+        return { text: body, bytes: body.length };
+    const b = body;
+    if (Array.isArray(b._parts))
+        return { text: `[FormData ${b._parts.length} parts]` };
+    if (typeof b.size === 'number')
+        return { text: `[Blob ${b.size} bytes]`, bytes: b.size };
+    if (typeof b.byteLength === 'number')
+        return { text: `[binary ${b.byteLength} bytes]`, bytes: b.byteLength };
+    if (typeof b.append === 'function' && typeof b.toString === 'function')
+        return { text: b.toString() }; // URLSearchParams
+    return {};
+}
+function installNetworkCapture(host, options) {
+    const proto = typeof host.XMLHttpRequest === 'function' ? host.XMLHttpRequest.prototype : undefined;
+    const hasXhr = !!proto && typeof proto.open === 'function' && typeof proto.setRequestHeader === 'function' && typeof proto.send === 'function';
+    const originalFetch = typeof host.fetch === 'function' ? host.fetch : undefined;
+    if (!hasXhr && !originalFetch)
+        return null;
+    const pending = new WeakMap();
+    const restores = [];
+    let active = true;
+    let counter = 0;
+    let xhrSends = 0;
+    let fetchSite; // the caller of a `fetch` while it runs: React Native's fetch opens its XHR from inside its own frames
+    function emit(p, fields) {
+        var _a;
+        if (!active)
+            return;
+        try {
+            const entry = { id: p.id, method: p.method, url: (0, network_redact_js_1.redactUrl)(p.url), startedAt: p.startedAt, via: 'sdk', ...fields };
+            if (p.initiator !== undefined)
+                entry.initiator = p.initiator;
+            if (Object.keys(p.headers).length > 0)
+                entry.requestHeaders = p.headers;
+            if (p.requestBody !== undefined) {
+                const body = (0, format_js_1.cap)(p.requestBody, options.bodyChars);
+                entry.requestBody = body.text;
+                entry.requestBodyBytes = (_a = p.requestBodyBytes) !== null && _a !== void 0 ? _a : p.requestBody.length;
+            }
+            options.onEntry(entry, options.now());
+        }
+        catch {
+            /* capture must never break the app */
+        }
+    }
+    function prnBegin(method, url) {
+        return {
+            id: String(++counter),
+            method: typeof method === 'string' ? method.toUpperCase() : 'GET',
+            url: typeof url === 'string' ? url : String(url),
+            startedAt: options.now(),
+            initiator: fetchSite !== null && fetchSite !== void 0 ? fetchSite : callSite(new Error().stack, options.stackChars),
+            headers: {},
+            requestBody: undefined,
+            requestBodyBytes: undefined,
+            contentType: '',
+            ended: false,
+        };
+    }
+    function setBody(p, body) {
+        const described = describeBody(body);
+        if (described.text === undefined)
+            return;
+        p.requestBody = (0, network_redact_js_1.redactBody)(described.text.length > 256 * 1024 ? described.text.slice(0, 256 * 1024) : described.text, p.contentType);
+        if (described.bytes !== undefined)
+            p.requestBodyBytes = described.bytes;
+    }
+    function setResponse(fields, headers, text, bytes) {
+        var _a;
+        fields.responseHeaders = (0, network_redact_js_1.redactHeaders)(headers, options.headerChars);
+        const type = ((_a = headerOf(headers, 'content-type')) !== null && _a !== void 0 ? _a : '').split(';')[0].trim().toLowerCase();
+        if (type)
+            fields.mimeType = type;
+        const length = Number(headerOf(headers, 'content-length'));
+        if (Number.isFinite(length) && length >= 0)
+            fields.encodedBytes = length;
+        if (text === undefined) {
+            fields.responseBodyState = BINARY.test(type) ? 'binary' : 'unavailable';
+            if (bytes !== undefined)
+                fields.responseBodyBytes = bytes;
+            return;
+        }
+        fields.responseBodyBytes = bytes !== null && bytes !== void 0 ? bytes : text.length;
+        if (BINARY.test(type)) {
+            fields.responseBodyState = 'binary';
+            return;
+        }
+        const body = (0, format_js_1.cap)((0, network_redact_js_1.redactBody)(text.length > 256 * 1024 ? text.slice(0, 256 * 1024) : text, type), options.bodyChars);
+        fields.responseBody = body.text;
+        fields.responseBodyState = body.truncated || text.length > 256 * 1024 ? 'cut' : 'kept';
+    }
+    function finish(self, p, kind) {
+        if (p.ended)
+            return;
+        p.ended = true;
+        try {
+            describe(self, p, kind);
+        }
+        catch {
+            /* capture must never break the app */
+        }
+    }
+    function describe(self, p, kind) {
+        var _a, _b, _c;
+        var _d;
+        const fields = { durationMs: Math.max(0, options.now() - p.startedAt) };
+        if (kind === 'abort')
+            fields.canceled = true;
+        if (kind === 'error' || kind === 'timeout') {
+            fields.failed = true;
+            fields.errorText = kind === 'timeout' ? 'timeout' : 'network error';
+        }
+        if (self.status > 0) {
+            fields.status = self.status;
+            if (self.statusText)
+                fields.statusText = self.statusText;
+            let text;
+            let bytes;
+            const type = self.responseType;
+            if (type === '' || type === 'text')
+                text = typeof self.responseText === 'string' ? self.responseText : undefined;
+            else if (type === 'json')
+                text = self.response === undefined || self.response === null ? undefined : JSON.stringify(self.response);
+            else
+                bytes = typeof ((_a = self.response) === null || _a === void 0 ? void 0 : _a.size) === 'number' ? self.response.size : (_b = self.response) === null || _b === void 0 ? void 0 : _b.byteLength;
+            const headers = parseHeaders((_c = self.getAllResponseHeaders) === null || _c === void 0 ? void 0 : _c.call(self));
+            // React Native's fetch is an XHR with responseType 'blob' (L27: every fetch body was empty): a text body is read back from the Blob before the entry is emitted
+            const Reader = host.FileReader;
+            const mime = ((_d = headerOf(headers, 'content-type')) !== null && _d !== void 0 ? _d : '').split(';')[0].trim().toLowerCase();
+            if (type === 'blob' && typeof Reader === 'function' && self.response && !BINARY.test(mime) && (bytes !== null && bytes !== void 0 ? bytes : 0) <= 1024 * 1024) {
+                try {
+                    const reader = new Reader();
+                    const done = (body) => {
+                        setResponse(fields, headers, body, bytes);
+                        emit(p, fields);
+                    };
+                    reader.onload = () => done(typeof reader.result === 'string' ? reader.result : undefined);
+                    reader.onerror = () => done(undefined);
+                    reader.readAsText(self.response);
+                    return;
+                }
+                catch {
+                    /* fall through: the entry without its body */
+                }
+            }
+            setResponse(fields, headers, text, bytes);
+        }
+        emit(p, fields);
+    }
+    if (hasXhr) {
+        const original = {
+            open: proto.open,
+            setRequestHeader: proto.setRequestHeader,
+            send: proto.send,
+        };
+        const prnOpen = function (...args) {
+            const result = original.open.apply(this, args);
+            if (active) {
+                try {
+                    pending.set(this, prnBegin(args[0], args[1]));
+                }
+                catch {
+                    /* capture must never break the app */
+                }
+            }
+            return result;
+        };
+        const setRequestHeader = function (...args) {
+            const result = original.setRequestHeader.apply(this, args);
+            if (active) {
+                try {
+                    const p = pending.get(this);
+                    if (p && typeof args[0] === 'string') {
+                        const value = String(args[1]);
+                        if (args[0].toLowerCase() === 'content-type')
+                            p.contentType = value;
+                        p.headers[args[0]] = args[0] in p.headers ? `${p.headers[args[0]]}, ${value}` : value;
+                    }
+                }
+                catch {
+                    /* capture must never break the app */
+                }
+            }
+            return result;
+        };
+        const send = function (...args) {
+            xhrSends++;
+            if (active) {
+                try {
+                    const self = this;
+                    const p = pending.get(self);
+                    if (p && !p.ended && typeof self.addEventListener === 'function') {
+                        p.startedAt = options.now();
+                        p.headers = (0, network_redact_js_1.redactHeaders)(p.headers, options.headerChars);
+                        setBody(p, args[0]);
+                        self.addEventListener('load', () => finish(self, p, 'load'));
+                        self.addEventListener('error', () => finish(self, p, 'error'));
+                        self.addEventListener('abort', () => finish(self, p, 'abort'));
+                        self.addEventListener('timeout', () => finish(self, p, 'timeout'));
+                    }
+                }
+                catch {
+                    /* capture must never break the app */
+                }
+            }
+            return original.send.apply(this, args);
+        };
+        proto.open = prnOpen;
+        proto.setRequestHeader = setRequestHeader;
+        proto.send = send;
+        // someone may have wrapped the prototype after us: then leave their wrapper in place and just stop capturing
+        restores.push(() => {
+            if (proto.open === prnOpen)
+                proto.open = original.open;
+            if (proto.setRequestHeader === setRequestHeader)
+                proto.setRequestHeader = original.setRequestHeader;
+            if (proto.send === send)
+                proto.send = original.send;
+        });
+    }
+    if (originalFetch) {
+        const prnFetch = function (...args) {
+            const before = xhrSends;
+            const startedAt = options.now();
+            let result;
+            const site = active ? callSite(new Error().stack, options.stackChars) : undefined;
+            fetchSite = site;
+            try {
+                result = originalFetch.apply(this, args);
+            }
+            finally {
+                fetchSite = undefined;
+            }
+            if (active && xhrSends === before) {
+                try {
+                    trackFetch(result, args, startedAt, site);
+                }
+                catch {
+                    /* capture must never break the app */
+                }
+            }
+            return result;
+        };
+        host.fetch = prnFetch;
+        restores.push(() => {
+            if (host.fetch === prnFetch)
+                host.fetch = originalFetch;
+        });
+    }
+    function trackFetch(result, args, startedAt, site) {
+        var _a, _b, _c, _d;
+        const input = args[0];
+        const init = ((_a = args[1]) !== null && _a !== void 0 ? _a : {});
+        const p = prnBegin((_b = init.method) !== null && _b !== void 0 ? _b : (typeof input === 'object' ? input === null || input === void 0 ? void 0 : input.method : undefined), typeof input === 'string' ? input : input === null || input === void 0 ? void 0 : input.url);
+        p.startedAt = startedAt;
+        p.initiator = site; // a fetch that is not an XHR (Expo's native fetch): the call site taken in the wrapper (L27 on the SDK 57 fixture had none)
+        const raw = {};
+        collectHeaders((_c = init.headers) !== null && _c !== void 0 ? _c : (typeof input === 'object' ? input === null || input === void 0 ? void 0 : input.headers : undefined), raw);
+        p.contentType = (_d = headerOf(raw, 'content-type')) !== null && _d !== void 0 ? _d : '';
+        p.headers = (0, network_redact_js_1.redactHeaders)(raw, options.headerChars);
+        setBody(p, init.body);
+        const done = result;
+        if (!done || typeof done.then !== 'function')
+            return;
+        done.then(response => fetched(p, response), error => emit(p, { durationMs: Math.max(0, options.now() - startedAt), failed: true, errorText: error instanceof Error ? error.message : 'network error' }));
+    }
+    function fetched(p, response) {
+        var _a;
+        const res = response;
+        const headers = {};
+        collectHeaders(res.headers, headers);
+        const fields = { durationMs: Math.max(0, options.now() - p.startedAt) };
+        if (typeof res.status === 'number' && res.status > 0)
+            fields.status = res.status;
+        if (res.statusText)
+            fields.statusText = res.statusText;
+        const type = (_a = headerOf(headers, 'content-type')) !== null && _a !== void 0 ? _a : '';
+        if (typeof res.clone !== 'function' || STREAM.test(type) || BINARY.test(type)) {
+            setResponse(fields, headers, undefined, undefined);
+            emit(p, fields);
+            return;
+        }
+        // the body is read from a clone, so the app's own response is untouched; the entry waits for it
+        let text;
+        try {
+            text = res.clone().text();
+        }
+        catch {
+            setResponse(fields, headers, undefined, undefined);
+            emit(p, fields);
+            return;
+        }
+        text.then(body => {
+            setResponse(fields, headers, body, undefined);
+            emit(p, fields);
+        }, () => {
+            setResponse(fields, headers, undefined, undefined);
+            emit(p, fields);
+        });
+    }
+    return {
+        uninstall() {
+            active = false;
+            for (const restore of restores)
+                restore();
+            restores.length = 0;
+        },
+    };
+}
+/** Headers as a Headers object (`forEach`), an array of pairs or a plain object. */
+function collectHeaders(source, into) {
+    if (!source || typeof source !== 'object')
+        return;
+    const s = source;
+    if (typeof s.forEach === 'function' && !Array.isArray(source)) {
+        s.forEach((value, name) => {
+            into[name] = value;
+        });
+    }
+    else if (Array.isArray(source)) {
+        for (let i = 0; i < source.length; i++)
+            if (Array.isArray(source[i]))
+                into[String(source[i][0])] = String(source[i][1]);
+    }
+    else {
+        const names = Object.keys(source);
+        for (let i = 0; i < names.length; i++)
+            into[names[i]] = String(source[names[i]]);
+    }
+}

package/dist/network-redact.d.ts

@@ -0,0 +1,13 @@
+export declare function redactHeaders(headers: {
+    readonly [name: string]: string;
+}, maxChars: number): {
+    [name: string]: string;
+};
+/** Userinfo, secret query parameters (by key, or a credential-shaped value) and credential-shaped path segments. Plain string work: `URL` is incomplete in React Native. */
+export declare function redactUrl(url: string): string;
+/**
+ * A text body, redacted by what it is: JSON by key (and credential-shaped values), a form by key, anything else by the console-line scrub. `contentType` may be empty; a
+ * body that looks like JSON is treated as JSON. A body too big to parse is scrubbed as text. The caller cuts the result to its cap afterwards.
+ */
+export declare function redactBody(text: string, contentType: string): string;
+//# sourceMappingURL=network-redact.d.ts.map

package/dist/network-redact.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactHeaders = redactHeaders;
+exports.redactUrl = redactUrl;
+exports.redactBody = redactBody;
+// Redaction for the network capture, applied in the app before an entry reaches the ring: nothing secret leaves the app. Everything else stays as captured (the
+// panel shows the detail; the core scrubs again on every path to an agent). The rules are the protocol's (`SECRET_KEY`, `isSecretKey`, `looksRandom`, `scrubLine`) plus the
+// header and URL rules of plan 0013 (Part B, "Scrub"). A cheap guard, not a promise.
+const protocol_1 = require("@parallax-rn/protocol");
+const SECRET_HEADER = /^(authorization|proxy-authorization|cookie|set-cookie|x-api-key|x-auth-.*)$/i;
+const SECRET_PARAM = /^(access_token|sig|signature|code|jwt|key)$/i;
+const JWT = /^eyJ[\w-]+\.[\w-]+\.[\w-]*$/;
+const BEARER = /^(bearer|basic)\s/i;
+/** The most JSON text that is parsed to be redacted by key; a bigger body is cut first and scrubbed as text. */
+const LONG_RUN = /[A-Za-z0-9+/_=-]{200,}/g;
+const MAX_PARSE_CHARS = 256 * 1024;
+const secretName = (name) => protocol_1.SECRET_KEY.test(name) || (0, protocol_1.isSecretKey)(name);
+/** A path segment or value shaped like a credential: a JWT, 32 or more hex characters, or 32 or more mixed-case letters and digits. Wider than `looksRandom` would be for ids. */
+function tokenShaped(value) {
+    if (JWT.test(value) || /^[0-9a-f]{32,}$/i.test(value))
+        return true;
+    return value.length >= 32 && /^[A-Za-z0-9+/_=-]+$/.test(value) && /\d/.test(value) && /[A-Z]/.test(value) && /[a-z]/.test(value);
+}
+function redactHeaders(headers, maxChars) {
+    const out = {};
+    const names = Object.keys(headers);
+    for (let i = 0; i < names.length; i++) {
+        const name = names[i];
+        const value = headers[name];
+        out[name] = SECRET_HEADER.test(name) || secretName(name) || BEARER.test(value) || (0, protocol_1.looksRandom)(value) ? protocol_1.REDACTED_TEXT : value.length > maxChars ? value.slice(0, maxChars) : value;
+    }
+    return out;
+}
+/** Userinfo, secret query parameters (by key, or a credential-shaped value) and credential-shaped path segments. Plain string work: `URL` is incomplete in React Native. */
+function redactUrl(url) {
+    const hash = url.indexOf('#');
+    const fragment = hash === -1 ? '' : url.slice(hash);
+    const rest = hash === -1 ? url : url.slice(0, hash);
+    const q = rest.indexOf('?');
+    let base = q === -1 ? rest : rest.slice(0, q);
+    const query = q === -1 ? '' : rest.slice(q + 1);
+    base = base.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, `$1${protocol_1.REDACTED_TEXT}@`);
+    const schemeEnd = base.indexOf('://');
+    const pathStart = schemeEnd === -1 ? 0 : base.indexOf('/', schemeEnd + 3);
+    if (pathStart !== -1) {
+        const segments = base.slice(pathStart).split('/');
+        for (let i = 0; i < segments.length; i++)
+            if (tokenShaped(segments[i]))
+                segments[i] = protocol_1.REDACTED_TEXT;
+        base = base.slice(0, pathStart) + segments.join('/');
+    }
+    return base + (q === -1 ? '' : `?${redactPairs(query, 'param')}`) + fragment;
+}
+function decode(text) {
+    try {
+        return decodeURIComponent(text.replace(/\+/g, ' '));
+    }
+    catch {
+        return text;
+    }
+}
+/** `a=1&b=2`: a pair goes by its key (parameters also by the extra names of a URL) or by a credential-shaped value. */
+function redactPairs(text, kind) {
+    const pairs = text.split('&');
+    for (let i = 0; i < pairs.length; i++) {
+        const eq = pairs[i].indexOf('=');
+        if (eq === -1)
+            continue;
+        const key = pairs[i].slice(0, eq);
+        const value = pairs[i].slice(eq + 1);
+        const name = decode(key);
+        if (secretName(name) || (kind === 'param' && SECRET_PARAM.test(name)) || (0, protocol_1.looksRandom)(decode(value)))
+            pairs[i] = `${key}=${protocol_1.REDACTED_TEXT}`;
+    }
+    return pairs.join('&');
+}
+function redactValue(value, depth) {
+    if (typeof value === 'string')
+        return (0, protocol_1.looksRandom)(value) ? protocol_1.REDACTED_TEXT : value;
+    if (depth > 20 || value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(item => redactValue(item, depth + 1));
+    const out = {};
+    const keys = Object.keys(value);
+    for (let i = 0; i < keys.length; i++)
+        out[keys[i]] = secretName(keys[i]) ? protocol_1.REDACTED_TEXT : redactValue(value[keys[i]], depth + 1);
+    return out;
+}
+/**
+ * A text body, redacted by what it is: JSON by key (and credential-shaped values), a form by key, anything else by the console-line scrub. `contentType` may be empty; a
+ * body that looks like JSON is treated as JSON. A body too big to parse is scrubbed as text. The caller cuts the result to its cap afterwards.
+ */
+function redactBody(text, contentType) {
+    const trimmed = text.trimStart();
+    if (text.length <= MAX_PARSE_CHARS && (/json/i.test(contentType) || trimmed.charAt(0) === '{' || trimmed.charAt(0) === '[')) {
+        try {
+            return JSON.stringify(redactValue(JSON.parse(text), 0));
+        }
+        catch {
+            /* not JSON after all: scrubbed as text below */
+        }
+    }
+    if (/x-www-form-urlencoded/i.test(contentType))
+        return redactPairs(text, 'form');
+    // the console-line scrub backtracks on a very long run of one word (quadratic): such a run is no readable text, it goes first
+    return (0, protocol_1.scrubLine)(text.replace(LONG_RUN, protocol_1.REDACTED_TEXT));
+}