rea-agents 4.1.0 → 5.0.0

package/dist/browser/execution/CdpRuntimeSources.js

@@ -0,0 +1,223 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { sanitizeBrowserUrl } from "../../domain/browserObservation.js";
+import { jsonObjectSchema } from "../../domain/jsonValue.js";
+import { WEB_RUNTIME_LIMITS, } from "../../domain/webRuntime.js";
+import { runtimeContextSchema, runtimeScriptParsedSchema, } from "./CdpRuntimeProtocol.js";
+const scriptIdentitySchema = runtimeScriptParsedSchema.pick({ scriptId: true });
+const contextIdentitySchema = z.object({
+    context: runtimeContextSchema.shape.context.pick({ id: true }),
+});
+/** Source ownership is proven by execution context/frame metadata, independently of URL aliases. */
+export class CdpRuntimeSources {
+    session;
+    scripts = new Map();
+    #contexts = new Map();
+    #changed = new Set();
+    #changedContexts = new Set();
+    #sources = new Map();
+    #retainedBytes = 0;
+    #sourceBytes = 0;
+    #failure;
+    constructor(session) {
+        this.session = session;
+    }
+    /** Subscribe before enabling Debugger; existing uncollected scripts are replayed by the producer. */
+    ingest(event, retainNewMetadata = true) {
+        if (event.sessionId !== this.session.transport.sessionId ||
+            this.#failure !== undefined)
+            return;
+        try {
+            if (event.method === "Runtime.executionContextCreated") {
+                this.#retainedBytes += Buffer.byteLength(JSON.stringify(event.params));
+                if (this.#retainedBytes > WEB_RUNTIME_LIMITS.retainedEventBytes)
+                    throw new Error("Context/script metadata exceeds the complete 8 MiB event budget.");
+                const context = runtimeContextSchema.parse(event.params).context;
+                const previous = this.#contexts.get(context.id);
+                if (previous !== undefined &&
+                    JSON.stringify(previous) !== JSON.stringify(context)) {
+                    this.#changedContexts.add(context.id);
+                    for (const item of this.#sources.values())
+                        if (item.execution_context_id === context.id)
+                            this.revalidate(item);
+                }
+                if (retainNewMetadata)
+                    this.#contexts.set(context.id, context);
+            }
+            else if (event.method === "Debugger.scriptParsed") {
+                this.#retainedBytes += Buffer.byteLength(JSON.stringify(event.params));
+                if (this.#retainedBytes > WEB_RUNTIME_LIMITS.retainedEventBytes)
+                    throw new Error("Script metadata exceeds the complete 8 MiB event budget.");
+                const script = runtimeScriptParsedSchema.parse(event.params);
+                const previous = this.scripts.get(script.scriptId);
+                if (previous !== undefined &&
+                    JSON.stringify(previous) !== JSON.stringify(script)) {
+                    this.#changed.add(script.scriptId);
+                    const retained = this.#sources.get(script.scriptId);
+                    if (retained !== undefined)
+                        this.revalidate(retained);
+                }
+                if (retainNewMetadata)
+                    this.scripts.set(script.scriptId, script);
+            }
+        }
+        catch (cause) {
+            this.#failure = new AnalysisOutputError(this.session.operation, cause instanceof Error ? cause.message : String(cause));
+        }
+    }
+    /** Producer parse/resource failures are surfaced outside the transport event callback. */
+    check() {
+        if (this.#failure !== undefined)
+            throw this.#failure;
+    }
+    /** Frozen inventories still monitor known identities through asynchronous source reads. */
+    verifyKnownIdentity(event) {
+        if (event.method === "Debugger.scriptParsed") {
+            const id = scriptIdentitySchema.safeParse(event.params);
+            if (id.success && this.scripts.has(id.data.scriptId))
+                this.ingest(event, false);
+        }
+        else if (event.method === "Runtime.executionContextCreated") {
+            const id = contextIdentitySchema.safeParse(event.params);
+            if (id.success && this.#contexts.has(id.data.context.id))
+                this.ingest(event, false);
+        }
+    }
+    /** Only proven default worlds of the selected main frame establish website source ownership. */
+    belongsToDocument(scriptId) {
+        const script = this.scripts.get(scriptId);
+        if (script === undefined ||
+            this.#changed.has(scriptId) ||
+            this.#changedContexts.has(script.executionContextId))
+            return false;
+        const scriptContext = script.executionContextAuxData;
+        const context = this.#contexts.get(script.executionContextId)?.auxData;
+        const worlds = [scriptContext, context];
+        if (worlds.some((world) => world?.isDefault === false ||
+            (world?.type !== undefined && world.type !== "default")) ||
+            !worlds.some((world) => world?.isDefault === true || world?.type === "default"))
+            return false;
+        const reported = scriptContext?.frameId;
+        const contextFrame = context?.frameId;
+        return ((reported === undefined ||
+            contextFrame === undefined ||
+            reported === contextFrame) &&
+            (reported ?? contextFrame) === this.session.target.frame_id);
+    }
+    /** Retain complete script text and compute a digest distinct from the producer hash. */
+    async read(scriptIds) {
+        this.check();
+        for (const scriptId of new Set(scriptIds)) {
+            if (this.#sources.has(scriptId))
+                continue;
+            const script = this.scripts.get(scriptId);
+            const owned = this.belongsToDocument(scriptId);
+            const context = script === undefined
+                ? undefined
+                : this.#contexts.get(script.executionContextId);
+            const item = {
+                script_id: scriptId,
+                url: this.sourceUrl(scriptId, script?.url ?? ""),
+                execution_context_id: script?.executionContextId ?? null,
+                reported_execution_context: context === undefined ? null : jsonObjectSchema.parse(context),
+                reported_script_context_aux_data: script?.executionContextAuxData === undefined
+                    ? null
+                    : jsonObjectSchema.parse(script.executionContextAuxData),
+                frame_id: owned ? this.session.target.frame_id : null,
+                producer_hash: script?.hash ?? null,
+                source_map_url: script?.sourceMapURL ?? null,
+                has_source_url: script?.hasSourceURL ?? null,
+                language: script?.scriptLanguage ?? null,
+                resource_start: script !== undefined
+                    ? {
+                        line_number: script.startLine,
+                        column_number: script.startColumn,
+                    }
+                    : null,
+                source: {
+                    state: "excluded",
+                    reason: this.#changed.has(scriptId)
+                        ? "The script changed identity during observation; source attribution is unknown."
+                        : "Selected main-document default-world ownership was not established.",
+                },
+            };
+            if (owned && script?.scriptLanguage !== "WebAssembly")
+                item.source = await this.capture(scriptId);
+            else if (owned)
+                item.source = {
+                    state: "excluded",
+                    reason: "WebAssembly bytecode is outside this JavaScript source operation.",
+                };
+            this.revalidate(item);
+            this.#sources.set(scriptId, item);
+        }
+        this.check();
+        return [...this.#sources.values()];
+    }
+    /** Resolve an exact producer script ID; URL equality is never an identity fallback. */
+    location(scriptId, url, line, column, functionName = null) {
+        return {
+            script_id: scriptId,
+            url: url === null ? null : this.sourceUrl(scriptId, url),
+            line_number: line,
+            column_number: column,
+            function_name: functionName,
+            source_association: this.belongsToDocument(scriptId)
+                ? "script_id"
+                : "unknown",
+        };
+    }
+    /** Declared script names are inert evidence; known resource URLs omit transport userinfo. */
+    sourceUrl(scriptId, url) {
+        return !this.#changed.has(scriptId) &&
+            this.scripts.get(scriptId)?.hasSourceURL === false
+            ? sanitizeBrowserUrl(url).url
+            : url;
+    }
+    revalidate(item) {
+        if (item.frame_id === null || this.belongsToDocument(item.script_id))
+            return;
+        const previous = item.source.state === "unavailable"
+            ? ` Previous source read failure: ${item.source.reason}`
+            : "";
+        item.frame_id = null;
+        item.source = {
+            state: "excluded",
+            reason: `The script or context changed identity during source collection; attribution is unknown.${previous}`,
+        };
+    }
+    async capture(scriptId) {
+        let raw;
+        try {
+            raw = await this.session.command("Debugger.getScriptSource", {
+                scriptId,
+            });
+        }
+        catch (cause) {
+            if (this.session.options.signal?.aborted ||
+                !(cause instanceof AnalysisError))
+                throw cause;
+            return {
+                state: "unavailable",
+                reason: cause.userMessage ?? cause.message,
+            };
+        }
+        const source = z.object({ scriptSource: z.string() }).safeParse(raw);
+        if (!source.success)
+            throw new AnalysisOutputError(this.session.operation, "Debugger.getScriptSource returned malformed source text.");
+        const text = source.data.scriptSource;
+        const bytes = Buffer.byteLength(text);
+        this.#sourceBytes += bytes;
+        if (this.#sourceBytes > WEB_RUNTIME_LIMITS.sourceBytes)
+            throw new AnalysisOutputError(this.session.operation, "Complete runtime source evidence exceeds its 32 MiB budget; no partial evidence is returned.");
+        return {
+            state: "captured",
+            text,
+            sha256: createHash("sha256").update(text).digest("hex"),
+            utf8_bytes: bytes,
+            utf16_units: text.length,
+        };
+    }
+}

package/dist/browser/execution/CdpWebRuntimeProvider.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { err, ok } from "../../domain/result.js";
+import { webExecutionSchema, } from "../../domain/webExecution.js";
+import { webEventListenersSchema, } from "../../domain/webEventListeners.js";
+import { CDP_BROWSER_PROVIDER_IDENTITY } from "../providerIdentities.js";
+import { CdpRuntimeSession } from "./CdpRuntimeSession.js";
+import { CdpRuntimeSources } from "./CdpRuntimeSources.js";
+import { captureWebExecution } from "./CdpExecutionCapture.js";
+import { captureWebEventListeners, eventListenerObjectGroup, } from "./CdpEventListeners.js";
+/** Native CDP integration with distinct inspection/instrumentation authority and confirmed cleanup. */
+export class CdpWebRuntimeProvider {
+    /** Identify this adapter independently of the captured browser version. */
+    identity() {
+        return CDP_BROWSER_PROVIDER_IDENTITY;
+    }
+    /** Observe one instrumented window while preserving the externally owned page. */
+    observeExecution(input, options = {}) {
+        return this.run(input, "observe_web_execution", options, webExecutionSchema, (sources) => captureWebExecution(input, sources));
+    }
+    /** Inspect one selected node's registered callback locations. */
+    inspectEventListeners(input, options = {}) {
+        const group = eventListenerObjectGroup();
+        return this.run(input, "inspect_web_event_listeners", options, webEventListenersSchema, (sources) => captureWebEventListeners(input, sources, group), group);
+    }
+    async run(input, operation, options, schema, capture, group) {
+        let session;
+        let result;
+        try {
+            session = await CdpRuntimeSession.open(input, operation, options);
+            result = ok(schema.parse(await capture(new CdpRuntimeSources(session))));
+        }
+        catch (cause) {
+            result = err(cause instanceof AnalysisError
+                ? cause
+                : cause instanceof z.ZodError
+                    ? new AnalysisOutputError(operation, cause.message)
+                    : new ProviderAdapterError(this.identity().id, operation, {
+                        cause,
+                    }));
+        }
+        if (session !== undefined) {
+            const failure = await session.close(result.ok ? undefined : result.error, group);
+            if (failure !== undefined)
+                return err(failure);
+        }
+        return result;
+    }
+}

package/dist/browser/modules/NativeModuleResolver.js

@@ -0,0 +1,210 @@
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
+import { BrowserObservationError } from "../../domain/browserObservationError.js";
+import { jsonObjectSchema } from "../../domain/jsonValue.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { err, ok } from "../../domain/result.js";
+import { webModuleResolutionSchema } from "../../domain/webModuleTrace.js";
+import { ProviderStartupDeadline } from "../../process/ProviderDeadline.js";
+const OPERATION = "trace_web_module_imports";
+const TIMEOUT_MS = 20000;
+const reportSchema = z.strictObject({
+    importer_url: z.string(),
+    entries: z.array(z.strictObject({
+        specifier: z.string(),
+        resolution: webModuleResolutionSchema,
+    })),
+});
+const launch = async (options) => (await import("playwright-core")).chromium.launch(options);
+/** Use native import.meta.resolve in an owned context with locally fulfilled requests. */
+export class NativeModuleResolver {
+    environment;
+    launcher;
+    constructor(environment, launcher = launch) {
+        this.environment = environment;
+        this.launcher = launcher;
+    }
+    async resolve(input, options) {
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError(OPERATION));
+        const executable = this.environment.REA_BROWSER_EXECUTABLE;
+        if (executable === undefined || !isAbsolute(executable))
+            return err(new AnalysisCapabilityUnavailableError("native-module-resolver", OPERATION, "missing_browser_executable", {
+                userMessage: "Provide an absolute REA_BROWSER_EXECUTABLE for a caller-supplied Chromium browser supporting import.meta.resolve. REA installs no browser.",
+            }));
+        const deadline = new ProviderStartupDeadline(TIMEOUT_MS, options?.signal);
+        let browser;
+        let cleanup;
+        const close = () => {
+            if (cleanup === undefined && browser !== undefined)
+                cleanup = browser.close();
+            return cleanup ?? Promise.resolve();
+        };
+        const onAbort = () => {
+            if (browser !== undefined) {
+                const pending = close();
+                void pending.catch(() => undefined);
+            }
+        };
+        deadline.signal.addEventListener("abort", onAbort, { once: true });
+        let result;
+        try {
+            browser = await this.launcher({
+                executablePath: executable,
+                headless: true,
+                timeout: Math.max(1, deadline.remainingMs()),
+                handleSIGINT: false,
+                handleSIGTERM: false,
+                handleSIGHUP: false,
+                args: [
+                    "--disable-dev-shm-usage",
+                    "--disable-background-networking",
+                    "--renderer-process-limit=1",
+                    "--js-flags=--max-old-space-size=128",
+                    ...(this.environment.REA_BROWSER_NO_SANDBOX === "true"
+                        ? ["--no-sandbox"]
+                        : []),
+                ],
+            });
+            deadline.signal.throwIfAborted();
+            const context = await browser.newContext({
+                serviceWorkers: "block",
+                acceptDownloads: false,
+            });
+            const page = await context.newPage();
+            const diagnostics = [];
+            let diagnosticBytes = 0;
+            page.on("console", (message) => {
+                const text = message.text();
+                diagnosticBytes += Buffer.byteLength(text);
+                if (diagnosticBytes <= 1024 * 1024)
+                    diagnostics.push(`${message.type()}: ${text}`);
+            });
+            const requests = [];
+            const importerUrl = new URL(input.importerUrl).href;
+            const documentUrl = new URL("/.rea-module-resolver/document", importerUrl)
+                .href;
+            const transportUrl = new URL(importerUrl);
+            transportUrl.hash = "";
+            let stubSent = false;
+            await context.route("**/*", async (route) => {
+                const request = route.request();
+                if (request.resourceType() === "document" &&
+                    request.url() === documentUrl.split("#")[0]) {
+                    requests.push({
+                        url: request.url(),
+                        resource_type: "document",
+                        effect: "fulfilled",
+                    });
+                    await route.fulfill({
+                        status: 200,
+                        contentType: "text/html",
+                        body: `<!doctype html>${input.importMap === null ? "" : `<base href="${htmlAttribute(new URL(input.importMap.baseUrl).href)}"><script type="importmap">${scriptJson(input.importMap.value)}</script>`}`,
+                    });
+                }
+                else if (!stubSent &&
+                    request.resourceType() === "script" &&
+                    request.url() === transportUrl.href) {
+                    stubSent = true;
+                    requests.push({
+                        url: request.url(),
+                        resource_type: "script",
+                        effect: "fulfilled",
+                    });
+                    await route.fulfill({
+                        status: 200,
+                        contentType: "text/javascript",
+                        headers: { "Access-Control-Allow-Origin": "*" },
+                        body: `if (typeof import.meta.resolve !== "function") {globalThis.__reaModuleUnsupported = true;} else {globalThis.__reaModuleResult = {importer_url: import.meta.url, entries: ${scriptJson(input.specifiers)}.map(specifier => {try {return {specifier, resolution: {state: "resolved", url: import.meta.resolve(specifier)}}} catch (error) {return {specifier, resolution: {state: "rejected", message: String(error)}}}})};}`,
+                    });
+                }
+                else {
+                    requests.push({
+                        url: request.url(),
+                        resource_type: request.resourceType(),
+                        effect: "blocked",
+                    });
+                    await route.abort();
+                }
+            });
+            await page.goto(documentUrl, {
+                timeout: Math.max(1, deadline.remainingMs()),
+            });
+            await page.evaluate(`{const script = document.createElement("script"); script.type = "module"; script.src = ${scriptJson(importerUrl)}; script.onerror = () => {globalThis.__reaModuleFailure = "Trusted resolver stub could not be loaded in the selected context.";}; document.head.append(script);}`);
+            await page.waitForFunction(() => Reflect.has(globalThis, "__reaModuleResult") ||
+                Reflect.has(globalThis, "__reaModuleUnsupported") ||
+                Reflect.has(globalThis, "__reaModuleFailure"), undefined, { timeout: Math.max(1, deadline.remainingMs()) });
+            const unsupported = await page.evaluate(() => Reflect.get(globalThis, "__reaModuleUnsupported"));
+            if (unsupported === true)
+                throw new AnalysisCapabilityUnavailableError("native-module-resolver", OPERATION, "native_resolution_unsupported", {
+                    userMessage: `Configured Chromium ${browser.version()} does not supply import.meta.resolve; use a browser supporting native module resolution.`,
+                });
+            const raw = await page.evaluate(() => Reflect.get(globalThis, "__reaModuleResult"));
+            const failure = await page.evaluate(() => Reflect.get(globalThis, "__reaModuleFailure"));
+            if (typeof failure === "string")
+                throw new AnalysisOutputError(OPERATION, `${failure} Native diagnostics: ${diagnostics.join("\n")}`);
+            const parsed = reportSchema.safeParse(raw);
+            if (!parsed.success ||
+                parsed.data.importer_url !== importerUrl ||
+                parsed.data.entries.length !== input.specifiers.length ||
+                parsed.data.entries.some((entry, index) => entry.specifier !== input.specifiers[index]))
+                throw new AnalysisOutputError(OPERATION, "Native resolver report has invalid shape or does not match the selected importer/specifiers.");
+            if (diagnosticBytes > 1024 * 1024)
+                throw new BrowserObservationError(OPERATION, "payload_limit");
+            deadline.signal.throwIfAborted();
+            const engine = {
+                id: "chromium-native-module-resolver",
+                version: browser.version(),
+            };
+            result = ok({
+                engine,
+                resolutions: parsed.data.entries.map((entry) => entry.resolution),
+                diagnostics,
+                rawResult: jsonObjectSchema.parse({
+                    native_report: parsed.data,
+                    requests,
+                    diagnostics,
+                    engine,
+                    executable_path: executable,
+                }),
+            });
+        }
+        catch (cause) {
+            result = err(deadline.interruption === "cancelled"
+                ? new AnalysisCancelledError(OPERATION)
+                : deadline.interruption === "timeout"
+                    ? new AnalysisTimeoutError(OPERATION, TIMEOUT_MS)
+                    : cause instanceof AnalysisOutputError ||
+                        cause instanceof AnalysisCapabilityUnavailableError ||
+                        cause instanceof BrowserObservationError
+                        ? cause
+                        : new ProviderAdapterError("native-module-resolver", OPERATION, {
+                            cause,
+                            diagnostics: {
+                                executable,
+                                error_message: cause instanceof Error ? cause.message : String(cause),
+                            },
+                        }));
+        }
+        finally {
+            deadline.signal.removeEventListener("abort", onAbort);
+            deadline.dispose();
+            try {
+                await close();
+            }
+            catch (cause) {
+                result = err(new BrowserObservationError(OPERATION, "cleanup_failed", { cause }));
+            }
+        }
+        if (result.ok && options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        return result;
+    }
+}
+const scriptJson = (value) => JSON.stringify(value).replaceAll("<", "\\u003c");
+const htmlAttribute = (value) => value
+    .replaceAll("&", "&amp;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");

package/dist/browser/modules/WebModuleArtifacts.js

@@ -0,0 +1,40 @@
+import { jsonObjectSchema } from "../../domain/jsonValue.js";
+import { err, ok } from "../../domain/result.js";
+import { LocalWebScriptArtifacts } from "../assets/LocalWebScriptArtifacts.js";
+import { readWebArtifactJson, webArtifactReadError, } from "../assets/WebArtifactReads.js";
+/** Add an explicitly selected import map to a verified captured-script source. */
+export class LocalWebModuleArtifacts {
+    scripts;
+    constructor(scripts = new LocalWebScriptArtifacts("trace_web_module_imports")) {
+        this.scripts = scripts;
+    }
+    /** Read selected source and optional map without website requests. */
+    async load(input, options) {
+        const loaded = await this.scripts.load(input, options);
+        if (!loaded.ok)
+            return loaded;
+        if (input.import_map === undefined)
+            return ok({ ...loaded.value, importMap: null });
+        const selected = input.import_map;
+        try {
+            const data = await readWebArtifactJson(selected.path, 4 * 1024 * 1024, options?.signal);
+            const importMap = {
+                file: {
+                    path: selected.path,
+                    sha256: data.sha256,
+                    bytes: data.bytes.length,
+                },
+                baseUrl: selected.base_url,
+                value: jsonObjectSchema.parse(data.value),
+            };
+            return ok({ ...loaded.value, importMap });
+        }
+        catch (cause) {
+            return err(webArtifactReadError(cause, {
+                operation: "trace_web_module_imports",
+                field: ["import_map", "path"],
+                targetPath: selected.path,
+            }, options?.signal));
+        }
+    }
+}

package/dist/browser/network/PlaywrightNetworkContent.js

@@ -0,0 +1,71 @@
+import { createHash } from "node:crypto";
+import { AnalysisCancelledError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
+import { withPlaywrightExecutionBoundary } from "../PlaywrightExecutionBoundary.js";
+const credentialHeaders = new Set([
+    "authorization",
+    "proxy-authorization",
+    "cookie",
+    "set-cookie",
+]);
+const errorMessage = (cause, secrets) => secrets.redact(cause instanceof Error && cause.message !== ""
+    ? cause.message
+    : "Network read failed");
+/** Read actual producer headers without flattening duplicates or exposing credentials. */
+export const captureNetworkHeaders = async (source, secrets, options) => {
+    try {
+        const headers = await withPlaywrightExecutionBoundary(() => source.headersArray(), options.timeoutMs, options.signal);
+        return {
+            state: "captured",
+            items: headers.map(({ name, value }) => {
+                const safeName = secrets.redact(name);
+                const credential = credentialHeaders.has(name.toLowerCase());
+                const safeValue = credential
+                    ? null
+                    : secrets.redactBytes(Buffer.from(value)).toString("utf8");
+                return {
+                    name: safeName,
+                    value: safeValue,
+                    redacted: credential || safeName !== name || safeValue !== value,
+                };
+            }),
+        };
+    }
+    catch (cause) {
+        return { state: "unavailable", message: errorMessage(cause, secrets) };
+    }
+};
+/** Retain only bytes exposed by the browser; no fetch or wire-byte reconstruction occurs. */
+export const captureNetworkBody = async (read, phase, source, secrets, options) => {
+    try {
+        const observed = await withPlaywrightExecutionBoundary(read, options.timeoutMs, options.signal);
+        if (observed === null)
+            return { state: "not_exposed" };
+        const retained = secrets.redactBytes(observed);
+        const contentType = source.headers()["content-type"];
+        return {
+            state: "captured",
+            representation: phase === "request"
+                ? "browser-exposed-request-bytes"
+                : "browser-decoded-response-bytes",
+            encoding: "base64",
+            content: retained.toString("base64"),
+            bytes: retained.length,
+            sha256: createHash("sha256").update(retained).digest("hex"),
+            media_type: contentType === undefined
+                ? null
+                : secrets.redactBytes(Buffer.from(contentType)).toString("utf8"),
+            redacted: !retained.equals(observed),
+        };
+    }
+    catch (cause) {
+        return {
+            state: "unavailable",
+            reason: cause instanceof AnalysisCancelledError
+                ? "cancelled"
+                : cause instanceof AnalysisTimeoutError
+                    ? "body-read-timeout"
+                    : "body-read-failed",
+            message: errorMessage(cause, secrets),
+        };
+    }
+};