rea-agents 6.4.0 → 6.5.0

package/dist/browser/assets/WebArtifactReads.js

@@ -4,6 +4,8 @@ import { readStableArtifact } from "../../artifacts/readStableArtifact.js";
 import { AnalysisAccessDeniedError, AnalysisCancelledError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
 import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
+import { analysisErrorWithCleanupFailure } from "../../domain/analysisErrorCleanup.js";
 import { safeParseJson } from "../../domain/safeJson.js";
 /** A malformed producer document, distinct from host I/O failures. */
 export class WebArtifactFormatFailure extends Error {
@@ -18,8 +20,8 @@ export const decodeWebArtifact = (bytes) => {
     }
 };
 /** Read one stable JSON artifact with a documented byte budget. */
-export const readWebArtifactJson = async (path, maximumBytes, signal) => {
-    const data = await readStableArtifact(path, maximumBytes, signal);
+export const readWebArtifactJson = async (path, maximumBytes, signal, resourceScope) => {
+    const data = await readStableArtifact(path, maximumBytes, signal, undefined, resourceScope);
     const value = safeParseJson(decodeWebArtifact(data.bytes));
     if (!value.ok)
         throw new WebArtifactFormatFailure(value.error);
@@ -27,8 +29,14 @@ export const readWebArtifactJson = async (path, maximumBytes, signal) => {
 };
 /** Preserve artifact format, integrity, OS I/O, and cancellation reasons. */
 export const webArtifactReadError = (cause, context, signal) => {
+    if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined) {
+        const primary = signal?.aborted === true
+            ? new AnalysisCancelledError(context.operation, { cause })
+            : new ArtifactOperationError(context.operation, cause.reason, cause.details, cause.message, { cause });
+        return analysisErrorWithCleanupFailure(primary, new ProviderCleanupError("captured-web-artifacts", cause.cleanup.resources, { reason: cause.cleanup.reason }, { cause, operation: context.operation }), context.operation);
+    }
     if (signal?.aborted === true)
-        return new AnalysisCancelledError(context.operation);
+        return new AnalysisCancelledError(context.operation, { cause });
     const selection = context.callerSelected
         ? selectedFileError(cause, context)
         : undefined;

package/dist/browser/assets/WebSourceLocationArtifacts.js

@@ -1,3 +1,4 @@
+import { ArtifactResourceScope } from "../../artifacts/ArtifactResourceScope.js";
 import { readStableArtifact } from "../../artifacts/readStableArtifact.js";
 import { WEB_SOURCE_MAP_LIMITS, } from "../../domain/webSourceLocation.js";
 import { err, ok } from "../../domain/result.js";
@@ -6,16 +7,50 @@ import { decodeWebArtifact, webArtifactReadError } from "./WebArtifactReads.js";
 /** Read one verified capture source and the caller-selected map, without fetching. */
 export class LocalWebSourceLocationArtifacts {
     scripts;
-    constructor(scripts = new LocalWebScriptArtifacts("trace_web_source_location")) {
-        this.scripts = scripts;
+    #resources;
+    constructor(scripts, resources = scripts instanceof LocalWebScriptArtifacts
+        ? scripts.resources
+        : new ArtifactResourceScope()) {
+        this.#resources = resources;
+        this.scripts =
+            scripts ??
+                new LocalWebScriptArtifacts("trace_web_source_location", resources);
+    }
+    async close() {
+        const closeScript = this.scripts instanceof LocalWebScriptArtifacts &&
+            this.scripts.resources === this.#resources
+            ? undefined
+            : this.scripts.close?.bind(this.scripts);
+        const results = await Promise.allSettled([
+            Promise.resolve().then(() => this.#resources.close()),
+            ...(closeScript === undefined
+                ? []
+                : [Promise.resolve().then(closeScript)]),
+        ]);
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length > 0)
+            throw new AggregateError(failures, "Web source-location artifact cleanup failed");
     }
     /** Preserve actual map identity separately from the selected deployment URL. */
     async load(input, options) {
+        try {
+            return await this.#resources.run(() => this.#load(input, options));
+        }
+        catch (cause) {
+            return err(webArtifactReadError(cause, {
+                operation: "trace_web_source_location",
+                field: ["source_map", "path"],
+                targetPath: input.source_map.path,
+                callerSelected: true,
+            }, options?.signal));
+        }
+    }
+    async #load(input, options) {
         const loaded = await this.scripts.load(input, options);
         if (!loaded.ok)
             return loaded;
         try {
-            const data = await readStableArtifact(input.source_map.path, WEB_SOURCE_MAP_LIMITS.mapBytes, options?.signal);
+            const data = await readStableArtifact(input.source_map.path, WEB_SOURCE_MAP_LIMITS.mapBytes, options?.signal, undefined, this.#resources);
             return ok({
                 ...loaded.value,
                 sourceMap: {

package/dist/browser/history/CaptureFailures.js

@@ -1,12 +1,14 @@
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
-import { AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, AnalysisResourceConstraintError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
+import { AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, AnalysisResourceConstraintError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
 import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
 import { WEB_NETWORK_CAPTURE_LIMITS, } from "../../domain/webNetworkCapture.js";
 import { OwnedCommandFailure } from "../../process/OwnedCommand.js";
-import { HAR_CAPTURE_HEAP_LIMITS } from "./CaptureRelease.js";
+import { NODE_CAPTURE_HEAP_ENFORCED, NODE_CAPTURE_HEAP_LIMITS, NODE_CAPTURE_PROCESS_MEMORY_LIMIT_BYTES, } from "./CaptureRelease.js";
 const OPERATION = "inspect_web_network_capture";
+/** Reason for a decoder whose owned process tree reached its Job Object commit limit. */
+export const CAPTURE_PROCESS_MEMORY_LIMIT_REASON = "The capture decoder reached its Windows Job Object memory limit";
 /** Preserve the origin and typed cause of a historical capture failure. */
 export const historicalCaptureFailure = (input, cause, phase, options) => {
     if (cause instanceof AnalysisError)
@@ -31,13 +33,19 @@ export const historicalCaptureFailure = (input, cause, phase, options) => {
             return new AnalysisTimeoutError(OPERATION, WEB_NETWORK_CAPTURE_LIMITS.timeoutMs);
         if (cause.reason === "output-limit")
             return new AnalysisOutputError(OPERATION, cause.message);
+        // The job's own notification is runtime-independent; Bun's exit status
+        // and diagnostics for an allocation failure are not.
         if (phase === "decoder" &&
-            input.format === "har" &&
+            cause.reason === "process" &&
+            cause.snapshot?.memoryLimitReached === true)
+            return captureMemoryFailure(input, CAPTURE_PROCESS_MEMORY_LIMIT_REASON, cause);
+        if (phase === "decoder" &&
+            input.format !== "mitmproxy" &&
             cause.reason === "process" &&
             (cause.snapshot?.signal === "SIGABRT" ||
                 (cause.snapshot?.signal === null && cause.snapshot.exitCode === 134)) &&
             /FATAL ERROR:[^\r\n]*heap out of memory/u.test(cause.snapshot.stderr.text))
-            return captureMemoryFailure(input, "The HAR decoder exhausted its fixed V8 heap", cause);
+            return captureMemoryFailure(input, `The ${input.format} decoder exhausted its fixed V8 heap`, cause);
     }
     if (options?.signal?.aborted)
         return new AnalysisCancelledError(OPERATION);
@@ -114,10 +122,16 @@ export const captureMemoryFailure = (input, reason, cause) => new AnalysisResour
     format: input.format,
     maximum_input_bytes: WEB_NETWORK_CAPTURE_LIMITS.inputBytes,
     maximum_reply_bytes: WEB_NETWORK_CAPTURE_LIMITS.outputBytes,
-    ...(input.format === "har"
+    ...(input.format !== "mitmproxy" && NODE_CAPTURE_HEAP_ENFORCED
+        ? {
+            old_generation_heap_mib: NODE_CAPTURE_HEAP_LIMITS.oldGenerationMiB,
+            semi_space_heap_mib: NODE_CAPTURE_HEAP_LIMITS.semiSpaceMiB,
+        }
+        : {}),
+    ...(input.format !== "mitmproxy" &&
+        NODE_CAPTURE_PROCESS_MEMORY_LIMIT_BYTES !== null
         ? {
-            old_generation_heap_mib: HAR_CAPTURE_HEAP_LIMITS.oldGenerationMiB,
-            semi_space_heap_mib: HAR_CAPTURE_HEAP_LIMITS.semiSpaceMiB,
+            process_memory_limit_bytes: NODE_CAPTURE_PROCESS_MEMORY_LIMIT_BYTES,
         }
         : {}),
     ...(cause instanceof OwnedCommandFailure
@@ -128,7 +142,7 @@ export const captureMemoryFailure = (input, reason, cause) => new AnalysisResour
         : {}),
 }, {
     cause,
-    remediationAction: `Use a smaller capture exported by its producer, or another decoder with sufficient capacity for the original capture. Preserve the original for provenance; a subset does not establish complete-capture coverage.${input.format === "har" ? ` REA's HAR old-generation heap is fixed at ${HAR_CAPTURE_HEAP_LIMITS.oldGenerationMiB} MiB; inherited NODE_OPTIONS cannot raise it.` : ""}`,
+    remediationAction: `Use a smaller capture exported by its producer, or another decoder with sufficient capacity for the original capture. Preserve the original for provenance; a subset does not establish complete-capture coverage.${input.format !== "mitmproxy" && NODE_CAPTURE_HEAP_ENFORCED ? ` REA's Node capture old-generation heap is fixed at ${NODE_CAPTURE_HEAP_LIMITS.oldGenerationMiB} MiB; inherited NODE_OPTIONS cannot raise it.` : ""}${input.format !== "mitmproxy" && NODE_CAPTURE_PROCESS_MEMORY_LIMIT_BYTES !== null ? ` REA's Node capture decoder process commit limit is fixed at ${String(NODE_CAPTURE_PROCESS_MEMORY_LIMIT_BYTES)} bytes.` : ""}`,
     ...(cause instanceof OwnedCommandFailure && cause.snapshot !== null
         ? {
             capturedOutput: {

package/dist/browser/history/CaptureFormatError.js

@@ -2,8 +2,8 @@
 export class CaptureFormatError extends Error {
     reason;
     pointer;
-    constructor(reason, message, pointer = "") {
-        super(message);
+    constructor(reason, message, pointer = "", cause) {
+        super(message, cause === undefined ? undefined : { cause });
         this.reason = reason;
         this.pointer = pointer;
     }

package/dist/browser/history/{HarJson.js → CaptureJson.js}

@@ -2,8 +2,9 @@ import { visit } from "jsonc-parser";
 import { LosslessNumber } from "lossless-json";
 import { WEB_NETWORK_CAPTURE_LIMITS } from "../../domain/webNetworkCapture.js";
 import { CaptureFormatError } from "./CaptureFormatError.js";
+import { TextDecoder } from "node:util";
 /** Materialize upstream JSON events without duplicate folding, prototype setters or numeric rounding. */
-export const parseHarJson = (text) => {
+export const parseCaptureJson = (text, format) => {
     const frames = [];
     let result;
     const valuePointer = () => {
@@ -18,7 +19,7 @@ export const parseHarJson = (text) => {
     };
     const checkDepth = () => {
         if (frames.length > WEB_NETWORK_CAPTURE_LIMITS.depth)
-            throw new CaptureFormatError("input-limit", "HAR exceeds the 64-level complete-evidence nesting budget.", valuePointer());
+            throw new CaptureFormatError("input-limit", `${format} exceeds the 64-level complete-evidence nesting budget.`, valuePointer());
     };
     const append = (value) => {
         const parent = frames.at(-1);
@@ -50,7 +51,7 @@ export const parseHarJson = (text) => {
             if (frame?.kind !== "object")
                 throw new TypeError("JSON visitor emitted a property outside an object.");
             if (frame.members.has(key))
-                throw new CaptureFormatError("format", "HAR JSON contains duplicate object members.");
+                throw new CaptureFormatError("format", `${format} JSON contains duplicate object members.`);
             frame.pendingKey = key;
         },
         onObjectEnd: () => {
@@ -81,7 +82,7 @@ export const parseHarJson = (text) => {
                 throw new TypeError("JSON visitor emitted an unsupported literal.");
         },
         onError: () => {
-            throw new CaptureFormatError("format", "HAR is malformed JSON.");
+            throw new CaptureFormatError("format", `${format} is malformed JSON.`);
         },
     }, {
         disallowComments: true,
@@ -90,3 +91,12 @@ export const parseHarJson = (text) => {
     });
     return result;
 };
+/** UTF-8 JSON decoding skips one permitted BOM and rejects malformed bytes. */
+export const decodeCaptureText = (bytes, format) => {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new CaptureFormatError("format", `${format} is not valid UTF-8 JSON.`);
+    }
+};

package/dist/browser/history/CaptureRedaction.js

@@ -1,3 +1,5 @@
+import { isSafeNumber } from "lossless-json";
+import { parseRecordedTransportUrl } from "../../domain/recordedTransportUrl.js";
 const CREDENTIAL_HEADERS = new Set([
     "authorization",
     "proxy-authorization",
@@ -22,9 +24,11 @@ export class CaptureRedaction {
     text(value, pointer, transportUrl = false) {
         let result = value;
         if (transportUrl) {
-            const match = /^([\x00-\x20]*(?:[a-z][a-z0-9+.-]*:)?\/\/)([^/?#]*@)/i.exec(result);
-            if (match !== null) {
-                result = `${match[1]}${result.slice(match[0].length)}`;
+            const { credentials } = parseRecordedTransportUrl(value);
+            if (credentials === "ambiguous")
+                return this.credential(pointer);
+            if (credentials !== null) {
+                result = `${value.slice(0, credentials.start)}${value.slice(credentials.end)}`;
                 this.redactions.push({ pointer, reason: "transport-credential" });
             }
         }
@@ -39,6 +43,15 @@ export class CaptureRedaction {
         this.redactions.push({ pointer, reason: "transport-credential" });
         return null;
     }
+    /** Check both retained spellings before projecting a producer JSON number. */
+    number(value, pointer, redact = true) {
+        const reported = isSafeNumber(value.value) ? Number(value.value) : null;
+        if (redact &&
+            (this.text(value.value, pointer) === null ||
+                (reported !== null && this.text(String(reported), pointer) === null)))
+            return null;
+        return { reported, literal: value.value };
+    }
     /** Known HAR credential surfaces; unknown extensions are ordinary caller-selected evidence. */
     harCredential(pointer, parent) {
         return ((/^\/(request|response)\/headers\/\d+\/value$/.test(pointer) &&

package/dist/browser/history/CaptureRelease.js

@@ -1,17 +1,35 @@
+import { javaScriptRuntime } from "../../domain/runtimeVersion.js";
+import { javaScriptWorkerMemoryLimitBytes } from "../../process/JavaScriptWorkerMemoryLimit.js";
 /** Exact upstream package profile for unchanged offline HAR validation and numeric parsing. */
 export const HAR_CAPTURE_PROVIDER_IDENTITY = {
     id: "har-schema/lossless-json",
     name: "REA HAR capture adapter",
     version: "har-schema@2.0.0;jsonc-parser@3.3.1;lossless-json@4.3.1",
 };
-/** Fixed V8 heap settings used by the owned HAR decoder process. */
-export const HAR_CAPTURE_HEAP_LIMITS = {
+/** Fixed V8 heap settings used by the owned Node capture decoder process. */
+export const NODE_CAPTURE_HEAP_LIMITS = {
     oldGenerationMiB: 192,
     semiSpaceMiB: 8,
 };
+/** The Node capture decoder runs on this executable; Bun accepts but ignores V8 heap flags. */
+export const NODE_CAPTURE_HEAP_ENFORCED = javaScriptRuntime(process.versions).id === "node";
+/** Windows Job Object commit limit replacing the ignored heap flags under Bun; otherwise null. */
+export const NODE_CAPTURE_PROCESS_MEMORY_LIMIT_BYTES = javaScriptWorkerMemoryLimitBytes(NODE_CAPTURE_HEAP_LIMITS.oldGenerationMiB);
 /** Native executable profile verified with unchanged mitmproxy raw-state decoding. */
 export const MITMPROXY_CAPTURE_PROVIDER_IDENTITY = {
     id: "mitmproxy-native-tnetstring",
     name: "REA offline native mitmproxy adapter",
     version: "12.2.3",
 };
+/** Native SAZ member decoding with the existing ZIP and XML package profiles. */
+export const SAZ_CAPTURE_PROVIDER_IDENTITY = {
+    id: "fiddler-saz",
+    name: "REA Fiddler SAZ capture adapter",
+    version: "1;zip.js@2.15.0;xmldom@0.9.12",
+};
+/** Fixed offline interpretation profile, not an authenticated producer claim. */
+export const QLOG_CAPTURE_PROVIDER_IDENTITY = {
+    id: "aioquic-qlog-json",
+    name: "REA aioquic qlog capture adapter",
+    version: "aioquic-profile@1.5.0;qlog@0.3;jsonc-parser@3.3.1;lossless-json@4.3.1",
+};

package/dist/browser/history/HarCapture.js

@@ -1,30 +1,16 @@
 import { createHash } from "node:crypto";
-import { TextDecoder } from "node:util";
-import { isSafeNumber, LosslessNumber } from "lossless-json";
-import { parseHarJson } from "./HarJson.js";
+import { LosslessNumber } from "lossless-json";
+import { parseCaptureJson } from "./CaptureJson.js";
 import { WEB_NETWORK_CAPTURE_LIMITS, } from "../../domain/webNetworkCapture.js";
 import { CaptureFormatError } from "./CaptureFormatError.js";
 import { CaptureRedaction, captureObject, capturePointer, } from "./CaptureRedaction.js";
 import { createHarValidator } from "./HarSchema.js";
 import { HAR_CAPTURE_PROVIDER_IDENTITY } from "./CaptureRelease.js";
-/**
- * Decode retained HAR bytes as UTF-8. HAR 1.2 lets writers emit a byte-order
- * mark and requires readers to ignore it, so one leading BOM is skipped.
- */
-export const decodeHarText = (bytes) => {
-    try {
-        // ignoreBOM: false (the default) is what skips the mark; true keeps it.
-        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-    }
-    catch {
-        throw new CaptureFormatError("format", "HAR is not valid UTF-8 JSON.");
-    }
-};
-/** Decode a retained HAR with exact numeric lexemes and unchanged upstream schema validation. */
+/** Decode a retained HAR, validating a disposable projection of source facts. */
 export const decodeHarCapture = (text, sensitiveValues) => {
-    const raw = parseHarJson(text);
+    const raw = parseCaptureJson(text, "HAR");
     const validation = projectHar(raw, [], false);
-    createHarValidator()(validation.reported);
+    const adaptedPlaywrightEntries = new Set(createHarValidator()(validation.reported));
     if (!captureObject(raw) ||
         !captureObject(raw.log) ||
         !Array.isArray(raw.log.entries))
@@ -53,6 +39,11 @@ export const decodeHarCapture = (text, sensitiveValues) => {
             ...projection,
             limitations: [
                 "HAR text is producer-decoded Unicode. Original body bytes remain unknown unless content explicitly uses valid base64; declared sizes are preserved independently of retained bytes. mitmproxy 12.2.3 SaveHar may report null optional postData.text; that null is retained and omitted only from the upstream validation copy.",
+                ...(adaptedPlaywrightEntries.has(ordinal)
+                    ? [
+                        "This capture declares Playwright 1.58.2 and reports bracketed IPv6 serverIPAddress. Original spellings are retained; brackets were removed only from valid IPv6 values in the validation copy. Producer declarations are not authenticated.",
+                    ]
+                    : []),
                 ...(recordsExcluded
                     ? [
                         "This record's payload and sidecars are excluded because its structural ancestor property was explicitly marked sensitive.",
@@ -85,14 +76,15 @@ const projectHar = (value, sensitiveValues, redact) => {
             redactor.harCredential(pointer, parent))
             return redactor.credential(pointer);
         if (item instanceof LosslessNumber) {
-            if (redact && redactor.text(item.value, pointer) === null)
+            const number = redactor.number(item, pointer, redact);
+            if (number === null)
                 return null;
             numeric_literals.push({
                 pointer,
                 producer_type: "json-number",
-                literal: item.value,
+                literal: number.literal,
             });
-            return isSafeNumber(item.value) ? Number(item.value) : null;
+            return number.reported;
         }
         if (typeof item === "string") {
             if (redact &&
@@ -104,7 +96,8 @@ const projectHar = (value, sensitiveValues, redact) => {
                 const hidden = redactor.sensitiveBytes(bytes) ||
                     sensitiveValues.some((literal) => item.includes(literal) ||
                         contentBase64.includes(literal) ||
-                        sha256.includes(literal));
+                        sha256.includes(literal) ||
+                        String(bytes.length).includes(literal));
                 binary_fields.push(hidden
                     ? {
                         pointer,

package/dist/browser/history/HarSchema.js

@@ -1,7 +1,9 @@
 import { createRequire } from "node:module";
+import { isIP } from "node:net";
 import { Ajv } from "ajv";
 import { z } from "zod";
 import { CaptureFormatError } from "./CaptureFormatError.js";
+import { captureObject } from "./CaptureRedaction.js";
 /** Validate using the unchanged, pinned upstream HAR 1.2 draft-06 schemas. */
 export const createHarValidator = () => {
     const require = createRequire(import.meta.url);
@@ -20,53 +22,51 @@ export const createHarValidator = () => {
     if (validate === undefined)
         throw new Error("Pinned HAR root schema is unavailable");
     return (value) => {
-        allowMitmproxyAbsentPostData(value);
+        const adaptedPlaywrightEntries = allowObservedProducerRepresentations(value);
         if (!validate(value)) {
             const error = validate.errors?.[0];
-            throw new CaptureFormatError("format", `HAR schema validation failed: ${error?.keyword ?? "unknown constraint"}.`, error?.instancePath ?? "");
+            // AJV messages name the violated constraint, such as the missing
+            // property, without restating any captured value.
+            throw new CaptureFormatError("format", error === undefined
+                ? "HAR schema validation failed: unknown constraint."
+                : `HAR schema validation failed: ${error.keyword} (${error.message ?? "no detail"}).`, error?.instancePath ?? "");
         }
+        return adaptedPlaywrightEntries;
     };
 };
-/** Observed SaveHar 12.2.3 compatibility: validate omitted optional text while retaining reported null. */
-const allowMitmproxyAbsentPostData = (value) => {
-    const parsed = z
-        .object({
-        log: z.object({
-            creator: z.object({
-                name: z.literal("mitmproxy"),
-                version: z.literal("12.2.3"),
-            }),
-            entries: z.array(z.unknown()),
-        }),
-    })
-        .safeParse(value);
-    if (!parsed.success ||
-        typeof value !== "object" ||
-        value === null ||
-        !("log" in value))
-        return;
+/** Adapt only observed producer representations in the disposable validation copy. */
+const allowObservedProducerRepresentations = (value) => {
+    if (!captureObject(value) || !captureObject(value.log))
+        return [];
     const log = value.log;
-    if (typeof log !== "object" ||
-        log === null ||
-        !("entries" in log) ||
-        !Array.isArray(log.entries))
-        return;
-    for (const entry of log.entries) {
+    if (!captureObject(log.creator) || !Array.isArray(log.entries))
+        return [];
+    const mitmproxy = log.creator.name === "mitmproxy" && log.creator.version === "12.2.3";
+    const playwright = log.creator.name === "Playwright" && log.creator.version === "1.58.2";
+    if (!mitmproxy && !playwright)
+        return [];
+    const adaptedPlaywrightEntries = [];
+    for (const [ordinal, entry] of log.entries.entries()) {
         const candidate = entry;
-        if (typeof candidate !== "object" ||
-            candidate === null ||
-            !("request" in candidate))
+        if (!captureObject(candidate))
+            continue;
+        const address = candidate.serverIPAddress;
+        if (playwright &&
+            typeof address === "string" &&
+            address.startsWith("[") &&
+            address.endsWith("]") &&
+            isIP(address.slice(1, -1)) === 6) {
+            candidate.serverIPAddress = address.slice(1, -1);
+            adaptedPlaywrightEntries.push(ordinal);
+        }
+        if (!mitmproxy)
             continue;
         const request = candidate.request;
-        if (typeof request !== "object" ||
-            request === null ||
-            !("postData" in request))
+        if (!captureObject(request))
             continue;
         const body = request.postData;
-        if (typeof body === "object" &&
-            body !== null &&
-            "text" in body &&
-            body.text === null)
+        if (captureObject(body) && body.text === null)
             delete body.text;
     }
+    return adaptedPlaywrightEntries;
 };