rea-agents 2.0.0 → 2.2.0

package/dist/application/WindowsCapabilities.js

@@ -0,0 +1,86 @@
+import { constants } from "node:fs";
+import { mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { probeProcessCaptureCapability, } from "./ProcessCaptureCapability.js";
+/** Probe named prerequisites without converting missing controls into support. */
+export const probeWindowsCapabilities = async (dependencies = systemDependencies()) => {
+    const [symlinkCreation, pty] = await Promise.all([
+        dependencies.probeSymlinkCreation(),
+        dependencies.probePty(),
+    ]);
+    return {
+        platform: dependencies.platform,
+        architecture: dependencies.architecture,
+        capabilities: {
+            symlink_creation: symlinkCreation,
+            no_follow_open: dependencies.probeNoFollowOpen(),
+            private_acl: dependencies.probePrivateAcl(),
+            unix_domain_socket: dependencies.probeUnixDomainSocket(),
+            pty: {
+                available: pty.available,
+                reason: pty.available ? null : pty.reason,
+            },
+        },
+    };
+};
+const systemDependencies = () => ({
+    platform: process.platform,
+    architecture: process.arch,
+    probeSymlinkCreation,
+    probeNoFollowOpen: () => systemNoFollowOpenCapability(process.platform, constants.O_NOFOLLOW),
+    probePrivateAcl: () => ({
+        available: false,
+        reason: "Windows ACL enforcement is not implemented by this REA build",
+    }),
+    probeUnixDomainSocket: () => process.platform === "win32"
+        ? {
+            available: false,
+            reason: "Node path-based IPC uses named pipes on Windows",
+        }
+        : { available: true, reason: null },
+    probePty: probeProcessCaptureCapability,
+});
+/** Report pathname no-follow support without treating it as Windows authority. */
+export const systemNoFollowOpenCapability = (platform, noFollow) => {
+    if (platform === "win32")
+        return {
+            available: false,
+            reason: "Windows reparse-safe handle admission is not implemented",
+        };
+    return typeof noFollow === "number"
+        ? { available: true, reason: null }
+        : {
+            available: false,
+            reason: "O_NOFOLLOW is unavailable in this Node runtime",
+        };
+};
+const probeSymlinkCreation = async () => {
+    const root = await mkdtemp(join(tmpdir(), "rea-symlink-probe-"));
+    const target = join(root, "target");
+    const link = join(root, "link");
+    try {
+        await writeFile(target, "probe");
+        await symlink(target, link, "file");
+        return { available: true, reason: null };
+    }
+    catch (cause) {
+        return {
+            available: false,
+            reason: cause instanceof Error &&
+                "code" in cause &&
+                typeof cause.code === "string"
+                ? cause.code
+                : "symlink creation failed",
+        };
+    }
+    finally {
+        try {
+            await rm(root, { recursive: true, force: true });
+        }
+        catch {
+            // Cleanup failure must not replace the machine-readable probe outcome.
+            // The probe root lives beneath the OS temporary directory and is unique.
+        }
+    }
+};

package/dist/artifacts/AsarArtifactReader.js

@@ -70,6 +70,13 @@ export class AsarArtifactReader {
             return Promise.resolve(Readable.from(extractFile(this.path, entry.adapterKey, false)));
         }
         catch (cause) {
+            if (entry.unpacked && isMissingFile(cause))
+                return Promise.reject(new ArtifactReaderFailure("unavailable", `ASAR unpacked entry bytes are unavailable: ${entry.path}`, { cause }, {
+                    logicalPath: entry.path,
+                    declaredSha256: entry.declaredSha256,
+                    calculatedSha256: null,
+                    unpacked: true,
+                }));
             return Promise.reject(asarFailure(this.path, `read ${entry.path}`, cause));
         }
     }
@@ -87,3 +94,7 @@ const abortIfNeeded = (signal) => {
 const asarFailure = (path, operation, cause) => cause instanceof ArtifactReaderFailure
     ? cause
     : new ArtifactReaderFailure("format", `Malformed or unreadable ASAR during ${operation}: ${path}`, { cause });
+const isMissingFile = (cause) => typeof cause === "object" &&
+    cause !== null &&
+    "code" in cause &&
+    cause.code === "ENOENT";

package/dist/browser/BrowserProcessStartup.js

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+/** Safe diagnostics for a browser process that did not publish a CDP port. */
+export class BrowserStartupError extends Error {
+    _tag = "BrowserStartupError";
+    failure;
+    executable;
+    elapsedMs;
+    exitCode;
+    signalCode;
+    stderr;
+    constructor(diagnostics, options) {
+        super(browserStartupMessage(diagnostics.failure, diagnostics), options);
+        this.failure = diagnostics.failure;
+        this.executable = diagnostics.executable;
+        this.elapsedMs = diagnostics.elapsedMs;
+        this.exitCode = diagnostics.exitCode;
+        this.signalCode = diagnostics.signalCode;
+        this.stderr = diagnostics.stderr;
+    }
+}
+/** Wait for Chrome's valid DevToolsActivePort or a terminal process outcome. */
+export const waitForBrowserDevtoolsPort = async (options) => {
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    const pollIntervalMs = options.pollIntervalMs ?? 25;
+    const startedAt = performance.now();
+    const terminal = childTermination(options, startedAt);
+    const deadline = startedAt + timeoutMs;
+    while (true) {
+        const terminalState = currentTerminalState(options.child);
+        if (terminalState !== null)
+            throw startupError(options, startedAt, terminalState);
+        const port = await readDevtoolsPort(options.activePortPath);
+        if (port !== null)
+            return port;
+        const remainingMs = deadline - performance.now();
+        if (remainingMs <= 0)
+            throw startupError(options, startedAt, { failure: "timeout" });
+        const outcome = await Promise.race([
+            terminal,
+            delay(Math.min(pollIntervalMs, remainingMs)).then(() => null),
+        ]);
+        if (outcome !== null)
+            throw outcome;
+    }
+};
+const childTermination = (options, startedAt) => new Promise((resolve) => {
+    options.child.once("error", (cause) => {
+        resolve(startupError(options, startedAt, {
+            failure: "spawn-error",
+            cause,
+        }));
+    });
+    options.child.once("exit", () => {
+        resolve(startupError(options, startedAt, options.child.signalCode === null
+            ? { failure: "exited" }
+            : { failure: "signalled" }));
+    });
+});
+const currentTerminalState = (child) => {
+    if (child.signalCode !== null)
+        return { failure: "signalled" };
+    if (child.exitCode !== null)
+        return { failure: "exited" };
+    return null;
+};
+const startupError = (options, startedAt, state) => new BrowserStartupError({
+    failure: state.failure,
+    executable: options.executable,
+    elapsedMs: Math.max(0, Math.round(performance.now() - startedAt)),
+    exitCode: options.child.exitCode,
+    signalCode: options.child.signalCode,
+    stderr: boundedStderr(options.stderr()),
+}, state.failure === "spawn-error" ? { cause: state.cause } : undefined);
+const readDevtoolsPort = async (path) => {
+    try {
+        const firstLine = (await readFile(path, "utf8")).trim().split("\n")[0];
+        const port = Number(firstLine);
+        return Number.isSafeInteger(port) && port > 0 && port <= 65_535
+            ? port
+            : null;
+    }
+    catch {
+        return null;
+    }
+};
+const boundedStderr = (stderr) => stderr.length <= 65_536 ? stderr : stderr.slice(-65_536);
+const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const browserStartupMessage = (failure, diagnostics) => `Chrome CDP startup ${failure}; executable=${diagnostics.executable}; elapsed_ms=${String(diagnostics.elapsedMs)}; exit_code=${diagnostics.exitCode === null ? "null" : String(diagnostics.exitCode)}; signal=${diagnostics.signalCode ?? "null"}; stderr=${diagnostics.stderr.length === 0 ? "<empty>" : diagnostics.stderr}`;

package/dist/browser/CdpCaptureDocuments.js

@@ -1,4 +1,5 @@
-import { allowedSanitizedUrl, boundedText, isHttpUrl, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, boundedText, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
+import { exclusionReasonForUrl } from "./CdpCaptureEventHelpers.js";
 /** Normalize allowed frames while retaining a bounded prefix and total count. */
 export const captureFrames = (result, allowedOrigins, maximum, completeness) => {
     const root = recordValue(requiredRecord(result).frameTree);
@@ -121,7 +122,14 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
                     .map((value) => indexedString(strings, value).slice(0, 256))
                     .slice(0, 200),
             });
-            const metadata = domMetadata(strings, attributeIndexes, documentUrl, nodeIndex, nodeName, allowedOrigins);
+            const metadata = domMetadata({
+                strings,
+                attributes: attributeIndexes,
+                documentUrl,
+                nodeIndex,
+                nodeName,
+                allowedOrigins,
+            });
             for (const url of metadata.urls) {
                 if (urls.length >= input.limits.max_resources) {
                     completeness?.truncate("metadata");
@@ -218,7 +226,8 @@ const numberArray = (value) => Array.isArray(value)
         return number === undefined ? [] : [number];
     })
     : [];
-const domMetadata = (strings, attributes, documentUrl, nodeIndex, nodeName, allowedOrigins) => {
+const domMetadata = (options) => {
+    const { strings, attributes, documentUrl, nodeIndex, nodeName, allowedOrigins, } = options;
     const pairs = new Map();
     for (let index = 0; index + 1 < attributes.length; index += 2) {
         const name = indexedString(strings, attributes[index]).toLowerCase();
@@ -284,11 +293,6 @@ const boundedUtf8 = (value, maximumBytes) => {
     }
     return { text, bytes, truncated: true };
 };
-const exclusionReasonForUrl = (value) => value === undefined || value === ""
-    ? "unattributed_origin"
-    : isHttpUrl(value)
-        ? "disallowed_origin"
-        : "unsupported_url";
 const domUrlAttributes = [
     "href",
     "src",

package/dist/browser/CdpCaptureEventBodyShapes.js

@@ -0,0 +1,75 @@
+import { inferJsonShape } from "../domain/jsonShape.js";
+import { recordValue, stringValue, } from "./CdpCaptureValues.js";
+import { decodeBase64, isJsonContentType } from "./CdpCaptureEventHelpers.js";
+export const ingestResponseBodyShape = (state, requestId, value) => {
+    const result = recordValue(value);
+    const body = stringValue(result?.body);
+    if (body === undefined) {
+        invalidResponseBodyShape(state, requestId);
+        return;
+    }
+    const decoded = result?.base64Encoded === true
+        ? decodeBase64(body)?.toString("utf8")
+        : body;
+    if (decoded === undefined) {
+        invalidResponseBodyShape(state, requestId);
+        return;
+    }
+    const inferred = inferBodyShape(state, decoded);
+    updateResponseBodyShape(state, requestId, inferred.shape, inferred.truncated);
+};
+export const requestBodyShape = (state, request) => {
+    if (!state.input.include_json_body_shapes)
+        return { status: "not_approved", request: null, response: null };
+    const body = stringValue(request.postData);
+    if (!isJsonContentType(recordValue(request.headers)) || body === undefined)
+        return { status: "unavailable", request: null, response: null };
+    const inferred = inferBodyShape(state, body);
+    return {
+        status: inferred.truncated
+            ? "truncated"
+            : inferred.shape === null
+                ? "unavailable"
+                : "included",
+        request: inferred.shape,
+        response: null,
+    };
+};
+export const updateResponseBodyShape = (state, requestId, response, truncated) => {
+    const current = state.network.get(requestId);
+    if (current === undefined)
+        return;
+    const request = current.body_shapes.request;
+    const status = truncated || current.body_shapes.status === "truncated"
+        ? "truncated"
+        : response !== null
+            ? "included"
+            : request !== null
+                ? "partial"
+                : "unavailable";
+    state.network.set(requestId, {
+        ...current,
+        body_shapes: { status, request, response },
+    });
+};
+const inferBodyShape = (state, text) => {
+    const bytes = Buffer.byteLength(text);
+    const remaining = state.input.limits.max_total_json_body_bytes - state.jsonBodyBytes;
+    if (bytes > state.input.limits.max_json_body_bytes || bytes > remaining) {
+        state.completeness.truncate("json_body_shapes");
+        return { shape: null, truncated: true };
+    }
+    state.jsonBodyBytes += bytes;
+    const shape = inferJsonShape(text, {
+        maximumBytes: state.input.limits.max_json_body_bytes,
+        maximumNodes: state.input.limits.max_json_shape_nodes,
+        maximumDepth: state.input.limits.max_json_shape_depth,
+    });
+    if (shape?.truncated === true)
+        state.completeness.truncate("json_body_shapes");
+    return { shape, truncated: shape?.truncated === true };
+};
+const invalidResponseBodyShape = (state, requestId) => {
+    updateResponseBodyShape(state, requestId, null, false);
+    state.completeness.exclude("json_body_shapes", "invalid_protocol_value");
+};

package/dist/browser/CdpCaptureEventHandlers.js

@@ -0,0 +1,336 @@
+import { inferJsonShape } from "../domain/jsonShape.js";
+import { safeResponseMetadata } from "./CdpSafeMetadata.js";
+import { boundedSensitiveText } from "./SensitiveTextCapture.js";
+import { allowedSanitizedUrl, boundedText, isHttpUrl, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { requestBodyShape } from "./CdpCaptureEventBodyShapes.js";
+import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, } from "./CdpCaptureEventHelpers.js";
+export const handleExecutionContextCreated = (state, params) => {
+    const context = recordValue(params.context);
+    const identifier = numberValue(context?.id);
+    const frameId = stringValue(recordValue(context?.auxData)?.frameId);
+    if (identifier === undefined ||
+        !Number.isSafeInteger(identifier) ||
+        frameId === undefined ||
+        frameId.length > 256)
+        return;
+    const key = String(identifier);
+    if (state.executionContextFrames.size >= state.input.limits.max_scripts &&
+        !state.executionContextFrames.has(key)) {
+        state.completeness.truncate("scripts");
+        return;
+    }
+    state.executionContextFrames.set(key, frameId);
+};
+export const handleExecutionContextDestroyed = (state, params) => {
+    const key = executionContextKey(params.executionContextId);
+    if (key !== null)
+        state.executionContextFrames.delete(key);
+};
+export const handleScriptParsed = (state, params) => {
+    const scriptId = stringValue(params.scriptId);
+    const rawUrl = stringValue(params.url) ?? "";
+    const sanitized = allowedSanitizedUrl(rawUrl, state.allowedOrigins);
+    if (scriptId === undefined || scriptId.length > 256) {
+        state.completeness.exclude("scripts", "invalid_protocol_value");
+        return;
+    }
+    if (sanitized === undefined) {
+        state.completeness.exclude("scripts", exclusionReasonForUrl(rawUrl));
+        return;
+    }
+    if (state.scripts.size >= state.input.limits.max_scripts &&
+        !state.scripts.has(scriptId)) {
+        state.completeness.drop("scripts");
+        return;
+    }
+    const sourceMap = sourceMapForScript(params.sourceMapURL, rawUrl, state);
+    const script = {
+        scriptId,
+        rawUrl,
+        url: sanitized.url,
+        origin: sanitized.origin,
+        hash: (stringValue(params.hash) ?? "").slice(0, 512),
+        length: Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(numberValue(params.length) ?? 0))),
+        isModule: params.isModule === true,
+        language: boundedText(params.scriptLanguage, 100),
+        sourceMapUrl: sourceMap.sanitized,
+        sourceMapRawUrl: sourceMap.raw,
+        executionContextKey: executionContextKey(params.executionContextId),
+    };
+    state.scripts.set(scriptId, script);
+};
+const sourceMapForScript = (value, scriptUrl, state) => {
+    const declaredUrl = stringValue(value);
+    if (declaredUrl === undefined || declaredUrl === "")
+        return { sanitized: null, raw: null };
+    let rawUrl;
+    try {
+        rawUrl = new URL(declaredUrl, scriptUrl).href;
+    }
+    catch {
+        state.completeness.exclude("source_maps", "unsupported_url");
+        return { sanitized: null, raw: null };
+    }
+    const sanitized = allowedSanitizedUrl(rawUrl, state.allowedOrigins);
+    if (sanitized !== undefined)
+        return { sanitized: sanitized.url, raw: rawUrl };
+    state.completeness.exclude("source_maps", exclusionReasonForUrl(rawUrl));
+    return { sanitized: null, raw: null };
+};
+export const handleRequestWillBeSent = (state, params) => {
+    const requestId = stringValue(params.requestId);
+    const request = recordValue(params.request);
+    if (requestId === undefined || requestId.length > 256) {
+        state.completeness.exclude("network_requests", "invalid_protocol_value");
+        return;
+    }
+    if (request === undefined) {
+        state.completeness.exclude("network_requests", "invalid_protocol_value");
+        state.network.delete(requestId);
+        return;
+    }
+    const sanitized = allowedSanitizedUrl(request.url, state.allowedOrigins);
+    if (sanitized === undefined) {
+        state.completeness.exclude("network_requests", exclusionReasonForUrl(stringValue(request.url)));
+        state.network.delete(requestId);
+        return;
+    }
+    if (state.network.size >= state.input.limits.max_network_events &&
+        !state.network.has(requestId)) {
+        state.completeness.drop("network_requests");
+        return;
+    }
+    const initiator = recordValue(params.initiator);
+    const initiatorFrame = initiatorLocation(initiator);
+    const rawInitiatorUrl = stringValue(initiatorFrame?.url);
+    const initiatorUrl = allowedSanitizedUrl(rawInitiatorUrl, state.allowedOrigins);
+    if (rawInitiatorUrl !== undefined && initiatorUrl === undefined)
+        state.completeness.exclude("network_initiators", exclusionReasonForUrl(rawInitiatorUrl));
+    state.network.set(requestId, {
+        request_id: requestId,
+        url: sanitized.url,
+        origin: sanitized.origin ?? "",
+        method: (stringValue(request.method) ?? "GET").slice(0, 32),
+        resource_type: boundedText(params.type, 100),
+        status: null,
+        mime_type: null,
+        encoded_data_length: null,
+        initiator: {
+            type: (stringValue(initiator?.type) ?? "other").slice(0, 100),
+            url: initiatorUrl?.url ?? null,
+            line: integerOrNull(initiatorFrame?.lineNumber),
+            column: integerOrNull(initiatorFrame?.columnNumber),
+        },
+        body_shapes: requestBodyShape(state, request),
+    });
+};
+export const handleResponseReceived = (state, params) => {
+    const requestId = stringValue(params.requestId);
+    if (requestId === undefined || requestId.length > 256) {
+        state.completeness.exclude("network_requests", "invalid_protocol_value");
+        return;
+    }
+    const current = state.network.get(requestId);
+    const response = recordValue(params.response);
+    if (current === undefined)
+        return;
+    const sanitized = allowedSanitizedUrl(response?.url, state.allowedOrigins);
+    if (response === undefined || sanitized === undefined) {
+        state.completeness.exclude("network_requests", response === undefined
+            ? "invalid_protocol_value"
+            : exclusionReasonForUrl(stringValue(response.url)));
+        state.network.delete(requestId);
+        return;
+    }
+    state.network.set(requestId, {
+        ...current,
+        status: numberValue(response.status) ?? null,
+        mime_type: boundedText(response.mimeType, 256),
+    });
+    if (state.responseMetadata.length >= state.input.limits.max_network_events) {
+        state.completeness.truncate("metadata");
+        return;
+    }
+    const metadata = safeResponseMetadata(requestId, sanitized.url, response, state.allowedOrigins);
+    state.responseMetadata.push(metadata.response);
+    state.agentHints.push(...metadata.agentHints);
+};
+export const handleLoadingFinished = (state, params) => {
+    const requestId = stringValue(params.requestId);
+    if (requestId === undefined || requestId.length > 256)
+        return;
+    const current = state.network.get(requestId);
+    if (current === undefined)
+        return;
+    state.network.set(requestId, {
+        ...current,
+        encoded_data_length: Math.max(0, numberValue(params.encodedDataLength) ?? 0),
+    });
+};
+export const handleConsoleAPICalled = (state, params) => {
+    const frame = firstCallFrame(recordValue(params.stackTrace));
+    if (frame === undefined) {
+        state.completeness.exclude("console_events", "unattributed_origin");
+        return;
+    }
+    const source = allowedSanitizedUrl(frame.url, state.allowedOrigins);
+    if (source === undefined) {
+        state.completeness.exclude("console_events", exclusionReasonForUrl(stringValue(frame.url)));
+        return;
+    }
+    if (state.console.length >= state.input.limits.max_console_events) {
+        state.completeness.drop("console_events");
+        return;
+    }
+    const arguments_ = recordsValue(params.args);
+    state.console.push({
+        type: (stringValue(params.type) ?? "unknown").slice(0, 100),
+        timestamp: numberValue(params.timestamp) ?? 0,
+        argument_types: arguments_
+            .map((argument) => (stringValue(argument.type) ?? "unknown").slice(0, 100))
+            .slice(0, 100),
+        url: source.url,
+        line: integerOrNull(frame.lineNumber),
+        column: integerOrNull(frame.columnNumber),
+        text_capture: captureConsoleText(state, arguments_),
+    });
+};
+const captureConsoleText = (state, arguments_) => {
+    if (!state.input.include_console_text)
+        return {
+            status: "not_approved",
+            values: [],
+            retained_bytes: 0,
+            truncated_values: 0,
+        };
+    const values = [];
+    let retainedBytes = 0;
+    let truncatedValues = 0;
+    for (const [argumentIndex, argument] of arguments_.entries()) {
+        const primitive = consolePrimitive(argument);
+        if (primitive === undefined)
+            continue;
+        const remaining = state.input.limits.max_total_console_text_bytes - state.consoleTextBytes;
+        if (remaining <= 0) {
+            truncatedValues += 1;
+            continue;
+        }
+        const bounded = boundedSensitiveText(primitive.text, Math.min(state.input.limits.max_console_text_field_bytes, remaining));
+        values.push({
+            argument_index: argumentIndex,
+            type: primitive.type,
+            text: bounded.text,
+        });
+        retainedBytes += bounded.bytes;
+        state.consoleTextBytes += bounded.bytes;
+        if (bounded.truncated)
+            truncatedValues += 1;
+    }
+    if (truncatedValues > 0)
+        state.completeness.truncate("console_text");
+    return {
+        status: truncatedValues > 0 ? "truncated" : "included",
+        values,
+        retained_bytes: retainedBytes,
+        truncated_values: truncatedValues,
+    };
+};
+export const handleWebSocketFrame = (state, params, direction) => {
+    const requestId = stringValue(params.requestId);
+    if (requestId === undefined ||
+        requestId.length > 256 ||
+        (!state.network.has(requestId) && !state.allowedWebSockets.has(requestId)))
+        return;
+    if (state.websockets.length >= state.input.limits.max_websocket_events) {
+        state.completeness.drop("websocket_frames");
+        return;
+    }
+    const response = recordValue(params.response);
+    const payload = stringValue(response?.payloadData) ?? "";
+    const opcode = Math.max(0, Math.trunc(numberValue(response?.opcode) ?? 0));
+    const decoded = opcode === 1 ? undefined : decodeBase64(payload);
+    if (opcode !== 1 && decoded === undefined)
+        state.completeness.exclude("websocket_frames", "invalid_protocol_value");
+    state.websockets.push({
+        request_id: requestId,
+        direction,
+        opcode,
+        payload_bytes: opcode === 1 ? Buffer.byteLength(payload) : (decoded?.byteLength ?? 0),
+        payload_shape: captureWebSocketShape(state, payload, opcode),
+    });
+};
+const captureWebSocketShape = (state, payload, opcode) => {
+    if (!state.input.include_websocket_shapes)
+        return null;
+    if (opcode !== 1)
+        return { format: "binary", json_shape: null, truncated: false };
+    const bytes = Buffer.byteLength(payload);
+    const remaining = state.input.limits.max_total_websocket_shape_bytes -
+        state.websocketShapeBytes;
+    if (bytes > state.input.limits.max_websocket_shape_bytes ||
+        bytes > remaining) {
+        state.completeness.truncate("websocket_shapes");
+        return { format: "text", json_shape: null, truncated: true };
+    }
+    state.websocketShapeBytes += bytes;
+    const shape = inferJsonShape(payload, {
+        maximumBytes: state.input.limits.max_websocket_shape_bytes,
+        maximumNodes: state.input.limits.max_json_shape_nodes,
+        maximumDepth: state.input.limits.max_json_shape_depth,
+    });
+    if (shape?.truncated === true)
+        state.completeness.truncate("websocket_shapes");
+    return {
+        format: shape === null ? "text" : "json",
+        json_shape: shape,
+        truncated: shape?.truncated === true,
+    };
+};
+export const handleWebSocketCreated = (state, params) => {
+    const requestId = stringValue(params.requestId);
+    const rawUrl = stringValue(params.url);
+    if (requestId === undefined || requestId.length > 256) {
+        state.completeness.exclude("websocket_connections", "invalid_protocol_value");
+        return;
+    }
+    if (rawUrl === undefined) {
+        state.completeness.exclude("websocket_connections", "invalid_protocol_value");
+        return;
+    }
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        state.completeness.exclude("websocket_connections", "unsupported_url");
+        return;
+    }
+    if (parsed.protocol === "ws:")
+        parsed.protocol = "http:";
+    else if (parsed.protocol === "wss:")
+        parsed.protocol = "https:";
+    else {
+        state.completeness.exclude("websocket_connections", "unsupported_url");
+        return;
+    }
+    if (!state.allowedOrigins.has(parsed.origin)) {
+        state.completeness.exclude("websocket_connections", "disallowed_origin");
+        return;
+    }
+    if (!state.allowedWebSockets.has(requestId) &&
+        state.allowedWebSockets.size >= state.input.limits.max_websocket_events) {
+        state.completeness.drop("websocket_connections");
+        return;
+    }
+    state.allowedWebSockets.add(requestId);
+};
+export const handleFrameNavigated = (state, params) => {
+    const frame = recordValue(params.frame);
+    if (stringValue(frame?.id) !== state.mainFrameId)
+        return;
+    state.navigationDuringCapture = true;
+    const rawUrl = stringValue(frame?.url);
+    if (isHttpUrl(rawUrl) &&
+        allowedSanitizedUrl(rawUrl, state.allowedOrigins) === undefined)
+        state.originViolation = true;
+};