rea-agents 6.4.0 → 6.7.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,18 @@ 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: signal.reason,
+            })
+            : 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: signal.reason,
+        });
     const selection = context.callerSelected
         ? selectedFileError(cause, context)
         : undefined;

package/dist/browser/assets/WebSourceLocationArtifacts.js

@@ -1,21 +1,65 @@
+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";
+import { webArtifactCleanupFailures } from "../WebArtifactCleanup.js";
 import { LocalWebScriptArtifacts } from "./LocalWebScriptArtifacts.js";
 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, index) => result.status === "rejected"
+            ? [
+                {
+                    cause: result.reason,
+                    resource: index === 0 ? "web source-location artifacts" : "web scripts",
+                },
+            ]
+            : []);
+        const error = webArtifactCleanupFailures("web-source-location-artifacts", "trace_web_source_location", failures);
+        if (error !== undefined)
+            throw error;
     }
     /** 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/execution/CdpRuntimeSession.js

@@ -2,6 +2,8 @@ import { AnalysisError } from "../../domain/analysisErrorBase.js";
 import { AnalysisTimeoutError } from "../../domain/analysisErrorCore.js";
 import { BrowserObservationError } from "../../domain/browserObservationError.js";
 import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
+import { analysisErrorWithCleanupFailure } from "../../domain/analysisErrorCleanup.js";
+import { CdpTargetSessionOwner } from "../CdpTargetSessionOwner.js";
 import { sanitizeBrowserUrl } from "../../domain/browserObservation.js";
 import { WEB_RUNTIME_LIMITS, } from "../../domain/webRuntime.js";
 import { authorizeCdpTarget } from "../CdpAuthorizedTarget.js";
@@ -17,24 +19,26 @@ export class CdpRuntimeSession {
     allowedOrigins;
     operation;
     options;
+    owner;
     enabledDomains = [];
     preciseCoverageMayBeActive = false;
     #completion;
     #completionTimer;
-    constructor(transport, discovery, target, allowedOrigins, operation, options) {
+    constructor(transport, discovery, target, allowedOrigins, operation, options, owner) {
         this.transport = transport;
         this.discovery = discovery;
         this.target = target;
         this.allowedOrigins = allowedOrigins;
         this.operation = operation;
         this.options = options;
+        this.owner = owner;
     }
     /** Acquire a validated target; failed setup releases its owned socket. */
-    static async open(input, operation, options) {
+    static async open(input, operation, options, owner) {
         return runtimeDeadline(operation, options.signal, async (signal) => {
             const discovery = await discoverCdpEndpoint(input.cdp_endpoint, operation, signal);
             const { target, allowedOrigins } = authorizeCdpTarget(discovery, input, operation);
-            const transport = await openCdpTargetSession(discovery, target, operation, signal, { maxPayloadBytes: WEB_RUNTIME_LIMITS.protocolBytes });
+            const transport = await openCdpTargetSession(discovery, target, operation, signal, { maxPayloadBytes: WEB_RUNTIME_LIMITS.protocolBytes }, owner);
             try {
                 const tree = runtimeFrameTreeSchema.parse(await authorizedMainFrame({
                     ...transport,
@@ -52,10 +56,18 @@ export class CdpRuntimeSession {
                     origin: url.origin,
                     frame_id: frame.id,
                     loader_id: frame.loaderId ?? null,
-                }, allowedOrigins, operation, options);
+                }, allowedOrigins, operation, options, owner);
             }
             catch (cause) {
-                await transport.connection.close();
+                try {
+                    await owner.finish(transport.connection);
+                }
+                catch (cleanupCause) {
+                    if (cause instanceof AnalysisError &&
+                        cleanupCause instanceof AnalysisError)
+                        throw analysisErrorWithCleanupFailure(cause, cleanupCause, operation);
+                    throw new AggregateError([cause, cleanupCause], `CDP runtime setup ${operation} failed and cleanup remains incomplete.`, { cause });
+                }
                 throw cause;
             }
         });
@@ -106,6 +118,7 @@ export class CdpRuntimeSession {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), WEB_RUNTIME_LIMITS.cleanupTimeoutMs);
         const failures = [];
+        let transportFailure;
         const send = async (method, params = {}) => {
             try {
                 await this.transport.connection.send(method, params, this.transport.sessionId, controller.signal);
@@ -132,7 +145,18 @@ export class CdpRuntimeSession {
         }
         finally {
             clearTimeout(timer);
-            await this.transport.connection.close();
+            try {
+                await this.owner.finish(this.transport.connection);
+            }
+            catch (cause) {
+                transportFailure =
+                    cause instanceof AnalysisError
+                        ? cause
+                        : new ProviderCleanupError("rea-cdp-browser", [this.target.target_id], {
+                            reason: cause instanceof Error ? cause.message : String(cause),
+                        }, { operation: this.operation, cause });
+                failures.push(`CDP WebSocket close: ${transportFailure.userMessage ?? transportFailure.message}`);
+            }
         }
         return failures.length === 0
             ? undefined
@@ -140,7 +164,12 @@ export class CdpRuntimeSession {
                 target_id: this.target.target_id,
                 cleanup_failures: failures,
                 previous_error: previousError?.userMessage ?? previousError?.message ?? null,
-            }, { operation: this.operation });
+            }, {
+                operation: this.operation,
+                ...(transportFailure === undefined
+                    ? {}
+                    : { cause: transportFailure }),
+            });
     }
 }
 /** Apply a disposable command deadline without turning timeout into caller cancellation. */

package/dist/browser/execution/CdpWebRuntimeProvider.js

@@ -1,17 +1,23 @@
 import { z } from "zod";
-import { AnalysisError } from "../../domain/analysisErrorBase.js";
-import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+import { AnalysisError, } from "../../domain/analysisErrorBase.js";
+import { AnalysisCancelledError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { analysisErrorWithCleanupFailure } from "../../domain/analysisErrorCleanup.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 { CdpTargetSessionOwner } from "../CdpTargetSessionOwner.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 {
+    #owner = new CdpTargetSessionOwner();
+    close() {
+        return this.#owner.close();
+    }
     /** Identify this adapter independently of the captured browser version. */
     identity() {
         return CDP_BROWSER_PROVIDER_IDENTITY;
@@ -29,7 +35,7 @@ export class CdpWebRuntimeProvider {
         let session;
         let result;
         try {
-            session = await CdpRuntimeSession.open(input, operation, options);
+            session = await CdpRuntimeSession.open(input, operation, options, this.#owner);
             result = ok(schema.parse(await capture(new CdpRuntimeSources(session))));
         }
         catch (cause) {
@@ -44,8 +50,20 @@ export class CdpWebRuntimeProvider {
         if (session !== undefined) {
             const failure = await session.close(result.ok ? undefined : result.error, group);
             if (failure !== undefined)
-                return err(failure);
+                return err(result.ok
+                    ? options.signal?.aborted === true
+                        ? analysisErrorWithCleanupFailure(new AnalysisCancelledError(operation, {
+                            cause: options.signal.reason,
+                            partialObservation: result.value,
+                        }), failure, operation)
+                        : failure.retainPartialObservation(result.value)
+                    : analysisErrorWithCleanupFailure(result.error, failure, operation));
         }
+        if (result.ok && options.signal?.aborted === true)
+            return err(new AnalysisCancelledError(operation, {
+                cause: options.signal.reason,
+                partialObservation: result.value,
+            }));
         return result;
     }
 }

package/dist/browser/history/CaptureFailures.js

@@ -1,12 +1,15 @@
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+import { artifactFileCancellationCause } from "../../artifacts/ArtifactFileOperation.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,16 +34,24 @@ 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);
+        return new AnalysisCancelledError(OPERATION, {
+            cause: options.signal.reason,
+        });
     if (phase === "capture-read" &&
         cause instanceof ArtifactReaderFailure &&
         cause.reason === "integrity")
@@ -48,7 +59,9 @@ export const historicalCaptureFailure = (input, cause, phase, options) => {
     if (phase === "capture-read" &&
         cause instanceof ArtifactReaderFailure &&
         cause.reason === "cancelled")
-        return new AnalysisCancelledError(OPERATION);
+        return new AnalysisCancelledError(OPERATION, {
+            cause: artifactFileCancellationCause(cause),
+        });
     if (phase === "capture-read" &&
         cause instanceof ArtifactReaderFailure &&
         (cause.reason === "limit" ||
@@ -114,10 +127,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 +147,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.",
@@ -73,10 +64,25 @@ export const decodeHarCapture = (text, sensitiveValues) => {
         records,
     };
 };
+/** Evidence projection when `redact` is true; the upstream schema validation copy otherwise. */
 const projectHar = (value, sensitiveValues, redact) => {
     const redactor = new CaptureRedaction(sensitiveValues);
     const numeric_literals = [];
     const binary_fields = [];
+    const projectNumber = (item, pointer) => {
+        // Evidence publishes an unsafe number as null; the schema must still judge it as a number.
+        if (!redact)
+            return validationNumber(item.value);
+        const number = redactor.number(item, pointer, redact);
+        if (number === null)
+            return null;
+        numeric_literals.push({
+            pointer,
+            producer_type: "json-number",
+            literal: number.literal,
+        });
+        return number.reported;
+    };
     const visit = (item, pointer, depth, parent) => {
         if (depth > WEB_NETWORK_CAPTURE_LIMITS.depth)
             throw new CaptureFormatError("input-limit", "HAR exceeds the 64-level complete-evidence nesting budget.", pointer);
@@ -84,16 +90,8 @@ const projectHar = (value, sensitiveValues, redact) => {
             parent !== undefined &&
             redactor.harCredential(pointer, parent))
             return redactor.credential(pointer);
-        if (item instanceof LosslessNumber) {
-            if (redact && redactor.text(item.value, pointer) === null)
-                return null;
-            numeric_literals.push({
-                pointer,
-                producer_type: "json-number",
-                literal: item.value,
-            });
-            return isSafeNumber(item.value) ? Number(item.value) : null;
-        }
+        if (item instanceof LosslessNumber)
+            return projectNumber(item, pointer);
         if (typeof item === "string") {
             if (redact &&
                 pointer === "/response/content/text" &&
@@ -104,7 +102,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,
@@ -169,6 +168,31 @@ const projectHar = (value, sensitiveValues, redact) => {
         redactions: redactor.redactions,
     };
 };
+/**
+ * A JSON number lexeme as the validation copy carries it: its nearest double, unless rounding or
+ * overflow erased a fractional part, so the schema's `integer` checks the lexeme, not the double.
+ */
+const validationNumber = (literal) => {
+    const nearest = Number(literal);
+    if (integerLexeme(literal))
+        return nearest;
+    if (Number.isFinite(nearest) && !Number.isInteger(nearest))
+        return nearest;
+    return literal.startsWith("-") ? -0.5 : 0.5;
+};
+/** Whether a JSON number lexeme denotes an integer, decided from its digits and exponent. */
+const integerLexeme = (literal) => {
+    const match = /^-?(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(literal);
+    if (match === null)
+        return false;
+    const [, whole = "", fraction = "", exponent = "0"] = match;
+    const digits = `${whole}${fraction}`;
+    const significant = digits.replace(/0+$/, "");
+    if (/^0*$/.test(significant))
+        return true;
+    const trailingZeros = digits.length - significant.length;
+    return Number(exponent) - fraction.length + trailingZeros >= 0;
+};
 const decodeHarBase64 = (value, pointer) => {
     const compact = value.replace(/[\t\n\r ]/g, "");
     const bytes = Buffer.from(compact, "base64");