rea-agents 6.3.0 → 6.5.0

package/dist/browser/assets/PublishWebScripts.js

@@ -1,24 +1,44 @@
 import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { Readable } from "node:stream";
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+import { ArtifactResourceScope } from "../../artifacts/ArtifactResourceScope.js";
+import { DESTINATION_CASE_COLLISION_PREFIX } from "../../artifacts/ArtifactPaths.js";
 import { SafeOutputTree } from "../../artifacts/SafeOutputTree.js";
+import { SafeOutputTreeCreationFailure } from "../../artifacts/SafeOutputTreeCreationFailure.js";
+import { PLAYWRIGHT_RESPONSE_BODY_PROVENANCE_LIMITATION } from "../../domain/browserNetworkEvidence.js";
 import { webScriptExportManifestSchema, webScriptExportResultSchema, } from "../../domain/webScriptExport.js";
-import { planWebScriptExport } from "../../domain/webScriptExportPlan.js";
+import { planWebScriptExport, } from "../../domain/webScriptExportPlan.js";
 import { WebScriptExportError } from "../../domain/webScriptExportError.js";
 const LIMITATIONS = [
     "Only script bytes retained in this capture are exported. Sources are not refetched or executed, and a response or Debugger source does not prove execution.",
-    "Ordinary unambiguous URL paths preserve relative module layouts by origin. Query variants, collisions, inline sources, and unrepresentable paths are isolated; their browser module relationships remain unknown.",
+    "Ordinary unambiguous URL paths preserve relative module layouts by origin, including case-distinct spellings. Query variants, exact path collisions, file/directory prefixes, inline sources, and unrepresentable paths are isolated. A case-distinct pair is isolated only when the destination filesystem cannot store both spellings; the record names that pair. Browser module relationships of isolated paths remain unknown.",
     "Local JavaScript analysis does not implement browser import maps, root-relative URL resolution, remote URL loading, or browser runtime behavior. It may strip import queries and fragments; isolated variants are not canonical targets.",
     "Source-map declarations are retained as metadata. No source maps or missing dependencies are fetched or reconstructed.",
-    "Captured response bytes are browser-decoded bytes; Debugger sources are the exposed text encoded as UTF-8. Redacted bytes are exported exactly as retained, and may no longer parse as JavaScript.",
+    "Scenario response bytes preserve the output of Playwright's Response.body() API; any source-body provenance caveat from the capture is retained in this manifest. Debugger sources are the exposed text encoded as UTF-8. Redacted bytes are exported exactly as retained, and may no longer parse as JavaScript.",
 ];
 /** Exclusively publish verified bytes and a manifest, rolling back partial work. */
-export const publishWebScripts = async (input, capture, captureSha256, signal) => {
+export const publishWebScripts = async (input, capture, captureSha256, options) => options.resources.run(async () => {
     const planned = planWebScriptExport(capture.scripts);
-    const tree = await SafeOutputTree.create(input.output_directory);
+    const scenarioResponseBodyCaptured = capture.kind === "browser-scenario" &&
+        capture.scripts.some((script) => script.source.kind === "scenario-response" &&
+            script.content.state === "captured" &&
+            (script.content.representation === "playwright-response-body-bytes" ||
+                script.content.representation === "browser-decoded-response-bytes"));
+    const responseBodyProvenanceLimitations = scenarioResponseBodyCaptured &&
+        !capture.limitations.includes(PLAYWRIGHT_RESPONSE_BODY_PROVENANCE_LIMITATION)
+        ? [PLAYWRIGHT_RESPONSE_BODY_PROVENANCE_LIMITATION]
+        : [];
+    let tree;
+    let result;
     try {
-        signal?.throwIfAborted();
-        const records = planned.map(({ record }) => record);
+        tree = await SafeOutputTree.create(input.output_directory);
+        options.signal?.throwIfAborted();
+        const records = [];
+        for (const [index, item] of planned.entries()) {
+            options.signal?.throwIfAborted();
+            records.push(await publishPlannedScript(tree, item, index, options.signal));
+        }
         const manifest = webScriptExportManifestSchema.parse({
             capture_path: input.capture_path,
             capture_sha256: captureSha256,
@@ -32,6 +52,7 @@ export const publishWebScripts = async (input, capture, captureSha256, signal) =
             scripts: records,
             limitations: [
                 ...capture.limitations,
+                ...responseBodyProvenanceLimitations,
                 ...LIMITATIONS,
                 ...(records.some(({ content }) => content.state === "exported")
                     ? []
@@ -42,7 +63,7 @@ export const publishWebScripts = async (input, capture, captureSha256, signal) =
         });
         const bytes = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`);
         const digest = createHash("sha256").update(bytes).digest("hex");
-        const result = webScriptExportResultSchema.parse({
+        result = webScriptExportResultSchema.parse({
             ...manifest,
             manifest: {
                 path: join(tree.outputRoot, "manifest.json"),
@@ -50,25 +71,70 @@ export const publishWebScripts = async (input, capture, captureSha256, signal) =
                 bytes: bytes.length,
             },
         });
-        for (const { script, record } of planned) {
-            signal?.throwIfAborted();
-            if (script.content.state === "captured" &&
-                record.content.state === "exported")
-                await tree.write(`files/${record.content.relative_path}`, Readable.from([script.content.bytes]), script.content.sha256, signal);
-        }
-        await tree.write("manifest.json", Readable.from([bytes]), digest, signal);
-        signal?.throwIfAborted();
-        await tree.commit();
+        await tree.write("manifest.json", Readable.from([bytes]), { sha256: digest, bytes: bytes.byteLength }, options.signal);
+        options.signal?.throwIfAborted();
+        await tree.commit(options.signal);
         return result;
     }
     catch (cause) {
-        try {
-            await tree.rollback();
-        }
-        catch (cleanupCause) {
-            throw new WebScriptExportError("io", tree.outputRoot, `Publication failed (${message(cause)}); rollback failed (${message(cleanupCause)}). Remove the residual output directory before retrying.`, [tree.outputRoot]);
+        if (cause instanceof SafeOutputTreeCreationFailure)
+            tree = cause.tree;
+        if (tree !== undefined) {
+            const cleanup = await options.resources.release({
+                kind: "output-tree",
+                resource: tree.outputRoot,
+                tree,
+            });
+            if (cleanup.kind === "failed") {
+                const cleanupCause = cleanup.cause;
+                const diagnostic = tree.published
+                    ? `Publication completed, but descriptor cleanup failed (${message(cleanupCause)}). The published output remains available.`
+                    : `Publication failed (${message(cause)}); rollback failed (${message(cleanupCause)}). Remove the residual output directory before retrying.`;
+                const error = new WebScriptExportError(cause instanceof ArtifactReaderFailure ? cause.reason : "io", tree.outputRoot, diagnostic, { residualPaths: [tree.outputRoot] });
+                if (tree.published && result !== undefined)
+                    error.retainPartialObservation({
+                        kind: "web-script-export",
+                        result,
+                    });
+                throw error;
+            }
+            if (tree.published && result !== undefined)
+                return result;
         }
         throw cause;
     }
+});
+const publishPlannedScript = async (tree, item, index, signal) => {
+    const { script, record } = item;
+    const content = script.content;
+    if (content.state !== "captured" || record.content.state !== "exported")
+        return record;
+    const write = (relativePath) => tree.write(`files/${relativePath}`, Readable.from([content.bytes]), { sha256: content.sha256, bytes: content.bytes.byteLength }, signal);
+    try {
+        await write(record.content.relative_path);
+        return record;
+    }
+    catch (cause) {
+        const collision = destinationCollisionReason(cause);
+        if (collision === undefined || record.content.layout !== "url-path")
+            throw cause;
+        const relativePath = isolatedScriptPath(script, index);
+        await write(relativePath);
+        return {
+            ...record,
+            content: {
+                ...record.content,
+                relative_path: relativePath,
+                layout: "isolated",
+                layout_reason: collision,
+            },
+        };
+    }
 };
+const isolatedScriptPath = (script, index) => `isolated/source-${index + 1}-${createHash("sha256").update(JSON.stringify(script.source)).digest("hex")}.js`;
+const destinationCollisionReason = (cause) => cause instanceof ArtifactReaderFailure &&
+    cause.reason === "path" &&
+    cause.message.startsWith(DESTINATION_CASE_COLLISION_PREFIX)
+    ? cause.message
+    : undefined;
 const message = (cause) => cause instanceof Error ? cause.message : "Unknown publication failure";

package/dist/browser/assets/ScenarioScriptCapture.js

@@ -52,7 +52,8 @@ const projectBody = (body, ambiguous) => {
         return unavailable(body.reason, body.message);
     if (body.state !== "captured")
         return unavailable(body.state, "No selected, completed script response bytes were retained for this request.");
-    if (body.representation !== "browser-decoded-response-bytes")
+    if (body.representation !== "playwright-response-body-bytes" &&
+        body.representation !== "browser-decoded-response-bytes")
         return unavailable("unsupported-body-representation", `Captured representation ${body.representation} is not script response bytes.`);
     return {
         state: "captured",

package/dist/browser/assets/WebArtifactReads.js

@@ -1,9 +1,11 @@
 import { z } from "zod";
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
 import { readStableArtifact } from "../../artifacts/readStableArtifact.js";
-import { AnalysisCancelledError, AnalysisInputError, } from "../../domain/analysisErrorCore.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,19 @@ 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;
+    if (selection !== undefined)
+        return selection;
     if (cause instanceof ArtifactReaderFailure)
         return new ArtifactOperationError(context.operation, cause.reason, cause.details, cause.message);
     if (cause instanceof Error &&
@@ -54,3 +67,20 @@ export const webArtifactReadError = (cause, context, signal) => {
         },
     });
 };
+/**
+ * Report a missing, non-regular or unreadable caller-selected file as the
+ * caller's selection or a host permission denial, not an artifact fault.
+ */
+const selectedFileError = (cause, context) => {
+    const selected = (message) => new AnalysisInputError(context.operation, { cause }, [
+        { path: context.field, reason: "invalid_value", message },
+    ]);
+    if (cause instanceof ArtifactReaderFailure)
+        return cause.reason === "path" ? selected(cause.message) : undefined;
+    const code = cause instanceof Error && "code" in cause ? String(cause.code) : "";
+    if (code === "EACCES" || code === "EPERM")
+        return new AnalysisAccessDeniedError(context.operation, context.targetPath, code, { cause });
+    if (code === "ENOENT" || code === "ENOTDIR")
+        return selected(`Selected file could not be read (${code}): ${context.targetPath}`);
+    return 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: {
@@ -34,6 +69,7 @@ export class LocalWebSourceLocationArtifacts {
                 operation: "trace_web_source_location",
                 field: ["source_map", "path"],
                 targetPath: input.source_map.path,
+                callerSelected: true,
             }, options?.signal));
         }
     }

package/dist/browser/execution/CdpExecutionCapture.js

@@ -69,9 +69,9 @@ export const captureWebExecution = async (input, sources) => {
         sources.check();
         const verifiedRequests = requests.result();
         const verifiedMainScripts = mainScripts.filter((id) => sources.belongsToDocument(id));
-        const sample = raw === undefined
-            ? undefined
-            : normalizePreciseCoverage(raw, sources, retained);
+        const sample = parsed?.success === true
+            ? normalizePreciseCoverage(parsed.data, sources, retained)
+            : undefined;
         await session.options.progress?.report({
             phase: "browser_execution",
             completed: 2,

package/dist/browser/execution/CdpPreciseCoverage.js

@@ -1,18 +1,15 @@
 import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
-import { preciseCoverageSchema } from "./CdpRuntimeProtocol.js";
 /** Validate source-range bounds against exact retained UTF-16 text without flattening nested counts. */
-export const normalizePreciseCoverage = (raw, sources, retained) => {
-    const parsed = preciseCoverageSchema.safeParse(raw);
-    if (!parsed.success)
-        throw new AnalysisOutputError(sources.session.operation, `Malformed precise coverage: ${parsed.error.message}`);
+export const normalizePreciseCoverage = (parsed, sources, retained) => {
+    const retainedSources = new Map(retained.map(({ script_id, source }) => [script_id, source]));
     const scripts = [];
     let excluded = 0;
-    for (const script of parsed.data.result) {
+    for (const script of parsed.result) {
         if (!sources.belongsToDocument(script.scriptId)) {
             excluded += 1;
             continue;
         }
-        const source = retained.find((item) => item.script_id === script.scriptId)?.source;
+        const source = retainedSources.get(script.scriptId);
         scripts.push({
             script_id: script.scriptId,
             reported_url: sources.sourceUrl(script.scriptId, script.url),
@@ -35,7 +32,7 @@ export const normalizePreciseCoverage = (raw, sources, retained) => {
         });
     }
     return {
-        timestamp: parsed.data.timestamp,
+        timestamp: parsed.timestamp,
         coverage: {
             state: "captured",
             reason: null,

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,16 +1,16 @@
 import { createHash } from "node:crypto";
-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 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))
@@ -39,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.",
@@ -71,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 &&
@@ -90,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,