rea-agents 5.0.0 → 6.0.0

package/dist/artifacts/apple/MachoLoadCommandReader.js

@@ -0,0 +1,294 @@
+/** Load commands larger than this are refused instead of buffered. */
+export const MAX_LOAD_COMMAND_BYTES = 16 * 1024 * 1024;
+/** Target opening accepts up to 128 FAT records; Java class files share the FAT magic. */
+const MAX_FAT_ARCHITECTURES = 128;
+/** CPU types of real Mach-O slices (x86, x86_64, arm, arm64, arm64_32, ppc, ppc64). */
+const KNOWN_CPU_TYPES = [
+    7, 0x01000007, 12, 0x0100000c, 0x0200000c, 18, 0x01000012,
+];
+const MH_MAGIC = 0xfeedface;
+const MH_MAGIC_64 = 0xfeedfacf;
+const MH_CIGAM = 0xcefaedfe;
+const MH_CIGAM_64 = 0xcffaedfe;
+const FAT_MAGIC = 0xcafebabe;
+const FAT_MAGIC_64 = 0xcafebabf;
+const FAT_CIGAM = 0xbebafeca;
+const FAT_CIGAM_64 = 0xbfbafeca;
+const LC_ID_DYLIB = 0xd;
+const LC_LOAD_DYLIB = 0xc;
+const LC_LOAD_WEAK_DYLIB = 0x80000018;
+const LC_REEXPORT_DYLIB = 0x8000001f;
+const LC_LAZY_LOAD_DYLIB = 0x20;
+const LC_LOAD_UPWARD_DYLIB = 0x80000023;
+const LC_RPATH = 0x8000001c;
+const LC_DYLD_ENVIRONMENT = 0x27;
+const LC_CODE_SIGNATURE = 0x1d;
+/** `mach-o/loader.h` `dylib_use_command`: `nameoff == 28` and this marker. */
+const DYLIB_USE_MARKER = 0x1a741800;
+const DYLIB_USE_WEAK_LINK = 0x1;
+const DYLIB_USE_REEXPORT = 0x2;
+const DYLIB_USE_UPWARD = 0x4;
+const DYLIB_USE_DELAYED_INIT = 0x8;
+const DEPENDENCY_COMMANDS = new Map([
+    [LC_LOAD_DYLIB, "LC_LOAD_DYLIB"],
+    [LC_LOAD_WEAK_DYLIB, "LC_LOAD_WEAK_DYLIB"],
+    [LC_REEXPORT_DYLIB, "LC_REEXPORT_DYLIB"],
+    [LC_LAZY_LOAD_DYLIB, "LC_LAZY_LOAD_DYLIB"],
+    [LC_LOAD_UPWARD_DYLIB, "LC_LOAD_UPWARD_DYLIB"],
+]);
+/** Malformed or unsupported structure found while decoding one image. */
+class MachoFormatIssue extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/** Report whether the first bytes carry a Mach-O or FAT magic number. */
+export const hasMachoMagic = (head) => {
+    if (head.byteLength < 4)
+        return false;
+    const magic = new DataView(head.buffer, head.byteOffset, head.byteLength).getUint32(0, false);
+    return [
+        MH_MAGIC,
+        MH_MAGIC_64,
+        MH_CIGAM,
+        MH_CIGAM_64,
+        FAT_MAGIC,
+        FAT_MAGIC_64,
+        FAT_CIGAM,
+        FAT_CIGAM_64,
+    ].includes(magic);
+};
+/** Decode every slice's dylib-loading load commands without reading code. */
+export const readMachoImage = async (readAt, size) => {
+    try {
+        const head = await readAt(0, Math.min(size, 8));
+        if (head.byteLength < 8)
+            // A recognized magic with no room for a header is a truncated image.
+            return hasMachoMagic(head)
+                ? { status: "malformed", reason: "Mach-O header is truncated" }
+                : { status: "not-mach-o" };
+        const view = viewOf(head);
+        const magic = view.getUint32(0, false);
+        if ([FAT_MAGIC, FAT_MAGIC_64, FAT_CIGAM, FAT_CIGAM_64].includes(magic)) {
+            // FAT headers are big-endian; the swapped magics store them little-endian.
+            const littleEndian = magic === FAT_CIGAM || magic === FAT_CIGAM_64;
+            const count = view.getUint32(4, littleEndian);
+            const wide = magic === FAT_MAGIC_64 || magic === FAT_CIGAM_64;
+            // A Java class file's nonzero major version reads as the count, so an
+            // empty architecture table can only be a malformed universal header.
+            if (count === 0)
+                return {
+                    status: "malformed",
+                    reason: "FAT header declares no architectures",
+                };
+            if (count > MAX_FAT_ARCHITECTURES || 8 + count * (wide ? 32 : 20) > size)
+                return { status: "not-mach-o" };
+            const table = viewOf(await readExact(readAt, 8, count * (wide ? 32 : 20), "FAT table"));
+            // A Java class file's version fields read as a FAT count; its "table" names no CPU.
+            const cpuTypes = Array.from({ length: count }, (_, index) => table.getUint32(index * (wide ? 32 : 20), littleEndian));
+            if (!cpuTypes.some((type) => KNOWN_CPU_TYPES.includes(type)))
+                return { status: "not-mach-o" };
+            return {
+                status: "parsed",
+                slices: await readFatSlices(readAt, size, {
+                    wide,
+                    littleEndian,
+                    count,
+                }),
+            };
+        }
+        if (magic === MH_CIGAM || magic === MH_CIGAM_64)
+            return { status: "parsed", slices: [await readSlice(readAt, 0, size)] };
+        if (magic === MH_MAGIC || magic === MH_MAGIC_64)
+            throw new MachoFormatIssue("unsupported", "big-endian Mach-O images are not supported");
+        return { status: "not-mach-o" };
+    }
+    catch (cause) {
+        if (cause instanceof MachoFormatIssue)
+            return { status: cause.status, reason: cause.message };
+        throw cause;
+    }
+};
+const readFatSlices = async (readAt, size, table) => {
+    const { wide, littleEndian, count } = table;
+    const entrySize = wide ? 32 : 20;
+    const view = viewOf(await readExact(readAt, 8, count * entrySize, "FAT table"));
+    const slices = [];
+    for (let index = 0; index < count; index++) {
+        const base = index * entrySize;
+        const offset = wide
+            ? safeNumber(view.getBigUint64(base + 8, littleEndian))
+            : view.getUint32(base + 8, littleEndian);
+        const length = wide
+            ? safeNumber(view.getBigUint64(base + 16, littleEndian))
+            : view.getUint32(base + 12, littleEndian);
+        if (offset + length > size)
+            throw new MachoFormatIssue("malformed", `FAT architecture ${index} extends beyond the file`);
+        slices.push(await readSlice(readAt, offset, length));
+    }
+    return slices;
+};
+const readSlice = async (readAt, base, length) => {
+    const header = viewOf(await readExact(readAt, base, 28, "Mach-O header"));
+    const magic = header.getUint32(0, true);
+    if (magic === MH_MAGIC_64 || magic === MH_MAGIC) {
+        const wide = magic === MH_MAGIC_64;
+        const headerSize = wide ? 32 : 28;
+        const commandCount = header.getUint32(16, true);
+        const commandBytes = header.getUint32(20, true);
+        if (commandBytes > MAX_LOAD_COMMAND_BYTES)
+            throw new MachoFormatIssue("unsupported", `load commands occupy ${commandBytes} bytes, above the ${MAX_LOAD_COMMAND_BYTES}-byte limit`);
+        if (headerSize + commandBytes > length)
+            throw new MachoFormatIssue("malformed", "load commands extend beyond the Mach-O slice");
+        const commands = await readExact(readAt, base + headerSize, commandBytes, "load commands");
+        return decodeCommands(commands, {
+            wide,
+            cpuType: header.getUint32(4, true),
+            cpuSubtype: header.getUint32(8, true),
+            fileType: header.getUint32(12, true),
+            commandCount,
+        });
+    }
+    throw new MachoFormatIssue(magic === swap(MH_MAGIC) || magic === swap(MH_MAGIC_64)
+        ? "unsupported"
+        : "malformed", magic === swap(MH_MAGIC) || magic === swap(MH_MAGIC_64)
+        ? "big-endian Mach-O slices are not supported"
+        : `slice at offset ${base} has no Mach-O header`);
+};
+const decodeCommands = (bytes, header) => {
+    // loader.h: load commands are 8-byte aligned in 64-bit images, 4 in 32-bit.
+    const alignment = header.wide ? 8 : 4;
+    const view = viewOf(bytes);
+    const slice = {
+        architecture: architectureName(header.cpuType, header.cpuSubtype),
+        file_type: fileTypeName(header.fileType),
+        install_name: null,
+        dependencies: [],
+        rpaths: [],
+        dyld_environment: [],
+        code_signature_present: false,
+    };
+    let offset = 0;
+    for (let index = 0; index < header.commandCount; index++) {
+        if (offset + 8 > bytes.byteLength)
+            throw new MachoFormatIssue("malformed", `load command ${index} starts beyond sizeofcmds`);
+        const command = view.getUint32(offset, true);
+        const size = view.getUint32(offset + 4, true);
+        if (size < 8 || size % alignment !== 0 || offset + size > bytes.byteLength)
+            throw new MachoFormatIssue("malformed", `load command ${index} at offset ${offset} has invalid cmdsize ${size}`);
+        const body = bytes.subarray(offset, offset + size);
+        decodeCommand(command, body, index, slice);
+        offset += size;
+    }
+    return slice;
+};
+const decodeCommand = (command, body, index, slice) => {
+    if (command === LC_ID_DYLIB) {
+        slice.install_name = commandString(body, 24, index);
+        return;
+    }
+    if (command === LC_RPATH) {
+        slice.rpaths.push(commandString(body, 12, index));
+        return;
+    }
+    if (command === LC_DYLD_ENVIRONMENT) {
+        slice.dyld_environment.push(commandString(body, 12, index));
+        return;
+    }
+    if (command === LC_CODE_SIGNATURE) {
+        // linkedit_data_command: cmd, cmdsize, dataoff, datasize.
+        if (body.byteLength < 16)
+            throw new MachoFormatIssue("malformed", `load command ${index} is too short for LC_CODE_SIGNATURE`);
+        slice.code_signature_present = true;
+        return;
+    }
+    const name = DEPENDENCY_COMMANDS.get(command);
+    if (name !== undefined)
+        slice.dependencies.push(decodeDependency(name, body, index));
+};
+const decodeDependency = (command, body, index) => {
+    if (body.byteLength < 24)
+        throw new MachoFormatIssue("malformed", `load command ${index} is too short for a dylib command`);
+    const view = viewOf(body);
+    const nameOffset = view.getUint32(8, true);
+    const usesFlags = nameOffset === 28 &&
+        body.byteLength >= 28 &&
+        view.getUint32(12, true) === DYLIB_USE_MARKER;
+    const flags = usesFlags ? view.getUint32(24, true) : 0;
+    return {
+        command,
+        encoding: usesFlags ? "dylib_use_command" : "dylib_command",
+        install_name: commandString(body, usesFlags ? 28 : 24, index),
+        weak: command === "LC_LOAD_WEAK_DYLIB" || (flags & DYLIB_USE_WEAK_LINK) !== 0,
+        upward: command === "LC_LOAD_UPWARD_DYLIB" || (flags & DYLIB_USE_UPWARD) !== 0,
+        reexport: command === "LC_REEXPORT_DYLIB" || (flags & DYLIB_USE_REEXPORT) !== 0,
+        delayed_init: (flags & DYLIB_USE_DELAYED_INIT) !== 0,
+        current_version: version(view.getUint32(16, true)),
+        compatibility_version: version(view.getUint32(20, true)),
+    };
+};
+/** NUL-terminated UTF-8 string at a `lc_str` offset inside one command. */
+const commandString = (body, minimumOffset, index) => {
+    if (body.byteLength < 12)
+        throw new MachoFormatIssue("malformed", `load command ${index} is too short to hold a string offset`);
+    const offset = viewOf(body).getUint32(8, true);
+    if (offset < minimumOffset || offset >= body.byteLength)
+        throw new MachoFormatIssue("malformed", `load command ${index} has string offset ${offset} outside the command`);
+    const end = body.indexOf(0, offset);
+    if (end < 0)
+        throw new MachoFormatIssue("malformed", `load command ${index} has an unterminated string`);
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(body.subarray(offset, end));
+    }
+    catch {
+        throw new MachoFormatIssue("malformed", `load command ${index} has a string that is not UTF-8`);
+    }
+};
+const readExact = async (readAt, offset, length, label) => {
+    const bytes = await readAt(offset, length);
+    if (bytes.byteLength < length)
+        throw new MachoFormatIssue("malformed", `${label} is truncated`);
+    return bytes;
+};
+const CPU_ARCH_ABI64 = 0x01000000;
+const CPU_ARCH_ABI64_32 = 0x02000000;
+const CPU_TYPE_X86 = 7;
+const CPU_TYPE_ARM = 12;
+const CPU_SUBTYPE_MASK = 0xff000000;
+const CPU_SUBTYPE_ARM64E = 2;
+const CPU_SUBTYPE_X86_64_H = 8;
+const architectureName = (cpuType, cpuSubtype) => {
+    const subtype = cpuSubtype & ~CPU_SUBTYPE_MASK;
+    if (cpuType === (CPU_TYPE_ARM | CPU_ARCH_ABI64))
+        return subtype === CPU_SUBTYPE_ARM64E ? "arm64e" : "arm64";
+    if (cpuType === (CPU_TYPE_ARM | CPU_ARCH_ABI64_32))
+        return "arm64_32";
+    if (cpuType === (CPU_TYPE_X86 | CPU_ARCH_ABI64))
+        return subtype === CPU_SUBTYPE_X86_64_H ? "x86_64h" : "x86_64";
+    if (cpuType === CPU_TYPE_X86)
+        return "i386";
+    if (cpuType === CPU_TYPE_ARM)
+        return "arm";
+    return `cpu-${cpuType.toString(16)}`;
+};
+const fileTypeName = (fileType) => fileType === 2
+    ? "execute"
+    : fileType === 6
+        ? "dylib"
+        : fileType === 8
+            ? "bundle"
+            : "other";
+const version = (value) => `${value >>> 16}.${(value >>> 8) & 0xff}.${value & 0xff}`;
+const swap = (value) => (((value & 0xff) << 24) |
+    ((value & 0xff00) << 8) |
+    ((value >>> 8) & 0xff00) |
+    (value >>> 24)) >>>
+    0;
+const safeNumber = (value) => {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new MachoFormatIssue("malformed", "FAT offset exceeds safe range");
+    return Number(value);
+};
+const viewOf = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);

package/dist/{application → artifacts/extraction}/ArtifactExtraction.js

@@ -1,14 +1,14 @@
 import { lstat, realpath } from "node:fs/promises";
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
-import { AsarArtifactReader } from "../artifacts/AsarArtifactReader.js";
-import { ArtifactPathRegistry, normalizeArtifactPath, } from "../artifacts/ArtifactPaths.js";
-import { ArtifactReaderFailure, } from "../artifacts/ArtifactReader.js";
-import { DirectoryArtifactReader } from "../artifacts/DirectoryArtifactReader.js";
-import { SafeOutputTree } from "../artifacts/SafeOutputTree.js";
-import { ZipArtifactReader } from "../artifacts/ZipArtifactReader.js";
-import { MachOSliceArtifactReader } from "../artifacts/MachOSliceArtifactReader.js";
-import { artifactExtractionResultSchema, } from "../domain/artifactGraph.js";
-import { scanArtifactInventory } from "./ArtifactInventory.js";
+import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { AsarArtifactReader } from "../AsarArtifactReader.js";
+import { ArtifactPathRegistry, normalizeArtifactPath, } from "../ArtifactPaths.js";
+import { ArtifactReaderFailure, } from "../ArtifactReader.js";
+import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
+import { SafeOutputTree } from "../SafeOutputTree.js";
+import { ZipArtifactReader } from "../ZipArtifactReader.js";
+import { MachOSliceArtifactReader } from "../MachOSliceArtifactReader.js";
+import { artifactExtractionResultSchema, } from "../../domain/artifactGraph.js";
+import { scanArtifactInventory } from "../inventory/ArtifactInventory.js";
 /** Extract every regular inventory occurrence into an exclusively owned absent root. */
 export const extractArtifact = async (input, signal) => {
     const sourcePath = await realpath(input.inputPath);

package/dist/{application → artifacts/inventory}/ArtifactGraphConstruction.js

@@ -1,6 +1,6 @@
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
-import { zipPackageFormatForPath } from "../domain/zipPackageFormat.js";
-import { mzWindowsHeaderOffset, parseDosMzHeader } from "../domain/dosMz.js";
+import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { zipPackageFormatForPath } from "../../domain/zipPackageFormat.js";
+import { mzWindowsHeaderOffset, parseDosMzHeader } from "../../domain/dosMz.js";
 /** Index the first occurrence for each canonical logical path. */
 export const indexOccurrencesByPath = (occurrences) => {
     const byPath = new Map();

package/dist/{application → artifacts/inventory}/ArtifactInventory.js

@@ -1,8 +1,8 @@
 import { realpath } from "node:fs/promises";
-import { artifactInventoryResultSchema, } from "../domain/artifactGraph.js";
-import { abortIfNeeded } from "../artifacts/ArtifactHash.js";
-import { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
-export { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
+import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
+import { abortIfNeeded } from "../ArtifactHash.js";
+import { scanCanonicalArtifactInventory } from "./scanCanonical.js";
+export { scanCanonicalArtifactInventory } from "./scanCanonical.js";
 /** Inventory one local artifact and return every graph collection inline. */
 export const inventoryArtifact = async (inputPath, options = {}) => {
     const snapshot = await scanArtifactInventory(inputPath, options);

package/dist/{application/ArtifactInventory → artifacts/inventory}/classify.js

@@ -1,6 +1,6 @@
 import { open } from "node:fs/promises";
-import { classifyArtifactContent } from "../ArtifactGraphConstruction.js";
-import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "../../artifacts/ArtifactHash.js";
+import { classifyArtifactContent } from "./ArtifactGraphConstruction.js";
+import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "../ArtifactHash.js";
 import { hasZipSignature, zipPackageFormatForPath, } from "../../domain/zipPackageFormat.js";
 const classifyContainerExtension = (path) => {
     const lower = path.toLowerCase();

package/dist/{application/ArtifactInventory → artifacts/inventory}/reader.js

@@ -1,8 +1,8 @@
-import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
-import { DirectoryArtifactReader } from "../../artifacts/DirectoryArtifactReader.js";
-import { MachOSliceArtifactReader } from "../../artifacts/MachOSliceArtifactReader.js";
-import { NativeDmgArtifactReader } from "../../artifacts/NativeDmgArtifactReader.js";
-import { ZipArtifactReader } from "../../artifacts/ZipArtifactReader.js";
+import { AsarArtifactReader } from "../AsarArtifactReader.js";
+import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
+import { MachOSliceArtifactReader } from "../MachOSliceArtifactReader.js";
+import { NativeDmgArtifactReader } from "../NativeDmgArtifactReader.js";
+import { ZipArtifactReader } from "../ZipArtifactReader.js";
 export const createReader = async (path, format, signal) => {
     switch (format) {
         case "directory":

package/dist/{application/ArtifactInventory → artifacts/inventory}/scanCanonical.js

@@ -1,11 +1,11 @@
 import { createReadStream } from "node:fs";
 import { lstat } from "node:fs/promises";
-import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
+import { ArtifactReaderFailure, } from "../ArtifactReader.js";
 import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
-import { createArtifactEdges, createRootNode, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "../ArtifactGraphConstruction.js";
+import { createArtifactEdges, createRootNode, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "./ArtifactGraphConstruction.js";
 import { canonicalDigest } from "../../domain/comparisonSemantics.js";
 import { classifyRoot } from "./classify.js";
-import { hashReadable } from "../../artifacts/ArtifactHash.js";
+import { hashReadable } from "../ArtifactHash.js";
 import { createReader, inventoryLimitations } from "./reader.js";
 import { scanReader, } from "./scanReader.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";

package/dist/{application/ArtifactInventory → artifacts/inventory}/scanReader.js

@@ -1,10 +1,10 @@
 import { isAbsolute } from "node:path";
-import { ArtifactPathRegistry, normalizeArtifactPath, } from "../../artifacts/ArtifactPaths.js";
-import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
-import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
-import { classifyArtifactContent, createArtifactNode, createOccurrence, nearestParent, } from "../ArtifactGraphConstruction.js";
+import { ArtifactPathRegistry, normalizeArtifactPath, } from "../ArtifactPaths.js";
+import { ArtifactReaderFailure, } from "../ArtifactReader.js";
+import { AsarArtifactReader } from "../AsarArtifactReader.js";
+import { classifyArtifactContent, createArtifactNode, createOccurrence, nearestParent, } from "./ArtifactGraphConstruction.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
-import { hashReadable } from "../../artifacts/ArtifactHash.js";
+import { hashReadable } from "../ArtifactHash.js";
 const UNAVAILABLE_UNPACKED_LIMITATION = "ASAR unpacked companion bytes were unavailable; no content hash or child artifact was produced.";
 const emptyScan = () => ({ nodes: new Map(), occurrences: [], pendingContradictions: [] });
 export const scanReader = async (reader, signal, integrity = STRICT_INTEGRITY_POLICY) => {

package/dist/artifacts/readStableArtifact.js

@@ -2,15 +2,31 @@ import { createHash } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, open } from "node:fs/promises";
 import { ArtifactReaderFailure } from "./ArtifactReader.js";
+const FILE_SYSTEM = {
+    lstat: (path) => lstat(path, { bigint: true }),
+    open,
+};
+const afterValidation = async (path, stage, read) => {
+    try {
+        return await read();
+    }
+    catch (cause) {
+        if (cause instanceof Error &&
+            "code" in cause &&
+            ["ENOENT", "ENOTDIR", "ELOOP"].includes(String(cause.code)))
+            throw new ArtifactReaderFailure("integrity", `Artifact changed ${stage}: ${path}`, { cause });
+        throw cause;
+    }
+};
 /** Read one bounded regular file and reject replacement or in-place changes. */
-export const readStableArtifact = async (path, maximumBytes, signal) => {
+export const readStableArtifact = async (path, maximumBytes, signal, fileSystem = FILE_SYSTEM) => {
     signal?.throwIfAborted();
-    const before = await lstat(path, { bigint: true });
+    const before = await fileSystem.lstat(path);
     if (!before.isFile() || before.isSymbolicLink())
         throw new ArtifactReaderFailure("path", `Expected a regular file without a symlink: ${path}`);
     if (before.size > BigInt(maximumBytes))
         throw new ArtifactReaderFailure("limit", `Selected artifact exceeds ${String(maximumBytes)} bytes: ${path}`);
-    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const file = await afterValidation(path, "before open", () => fileSystem.open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK));
     try {
         const initial = await file.stat({ bigint: true });
         if (!initial.isFile() ||
@@ -34,7 +50,7 @@ export const readStableArtifact = async (path, maximumBytes, signal) => {
             chunks.push(bytes);
         }
         const after = await file.stat({ bigint: true });
-        const current = await lstat(path, { bigint: true });
+        const current = await afterValidation(path, "during read", () => fileSystem.lstat(path));
         if ([after, current].some((stat) => !stat.isFile() ||
             stat.dev !== initial.dev ||
             stat.ino !== initial.ino ||

package/dist/browser/CdpCaptureEventHandlers.js

@@ -1,8 +1,8 @@
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { safeResponseMetadata } from "./CdpSafeMetadata.js";
 import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
-import { requestBodyShape } from "./CdpCaptureEventBodyShapes.js";
-import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, isMainFrameNavigation, } from "./CdpCaptureEventHelpers.js";
+import { requestBodyShape, updateResponseBodyShape, } from "./CdpCaptureEventBodyShapes.js";
+import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, isJsonMediaType, isMainFrameNavigation, } from "./CdpCaptureEventHelpers.js";
 export const handleExecutionContextCreated = (state, params) => {
     const context = recordValue(params.context);
     const identifier = numberValue(context?.id);
@@ -74,16 +74,69 @@ export const handleRequestWillBeSent = (state, params) => {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
     if (request === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
         return;
     }
     const sanitized = allowedSanitizedUrl(request.url, state.allowedOrigins);
     if (sanitized === undefined) {
         state.completeness.exclude("network_requests", exclusionReasonForUrl(cdpStringValue(request.url)));
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
+        return;
+    }
+    const previous = state.network.get(requestId);
+    const redirectResponse = recordValue(params.redirectResponse);
+    if (Object.hasOwn(params, "redirectResponse") &&
+        redirectResponse === undefined &&
+        preserveMalformedRedirectEvidence(state, requestId, previous))
         return;
+    const redirects = [...(previous?.redirects ?? [])];
+    if (redirectResponse !== undefined) {
+        const rawResponseUrl = cdpStringValue(redirectResponse.url);
+        const responseUrl = rawResponseUrl === undefined || rawResponseUrl === ""
+            ? undefined
+            : allowedSanitizedUrl(rawResponseUrl, state.allowedOrigins);
+        const responseUrlReason = redirectResponseUrlReason(rawResponseUrl);
+        if (previous === undefined) {
+            if (responseUrl === undefined)
+                state.completeness.exclude("network_requests", responseUrlReason);
+            else
+                // CDP may deliver the continuation after its predecessor was excluded
+                // by origin policy or before capture began. Keep the final request but
+                // report missing prior coverage without calling it malformed protocol.
+                state.completeness.attachLimited("network_requests");
+        }
+        else if (responseUrl === undefined) {
+            // redirectResponse belongs to the same request ID and can contain an
+            // excluded origin. Drop the entire chain before retaining any details.
+            state.completeness.exclude("network_requests", responseUrlReason);
+            state.network.delete(requestId);
+            state.networkRequestTimestamps.delete(requestId);
+            return;
+        }
+        else {
+            redirects.push({
+                url: previous.url,
+                response_url: responseUrl.url,
+                method: previous.method,
+                resource_type: previous.resource_type,
+                status: numberValue(redirectResponse.status) ?? null,
+                mime_type: cdpStringValue(redirectResponse.mimeType) ?? null,
+                encoded_data_length: (() => {
+                    const length = numberValue(redirectResponse.encodedDataLength);
+                    return length === undefined ? null : Math.max(0, length);
+                })(),
+                request_timestamp: state.networkRequestTimestamps.get(requestId) ?? null,
+                // CDP reports redirectResponse on the next requestWillBeSent event.
+                // This is the event boundary, not a separately observed response time.
+                redirect_event_timestamp: numberValue(params.timestamp) ?? null,
+            });
+        }
     }
     const initiator = recordValue(params.initiator);
     const initiatorFrame = initiatorLocation(initiator);
@@ -100,6 +153,7 @@ export const handleRequestWillBeSent = (state, params) => {
         status: null,
         mime_type: null,
         encoded_data_length: null,
+        redirects,
         initiator: {
             type: cdpStringValue(initiator?.type) ?? "other",
             url: initiatorUrl?.url ?? null,
@@ -108,6 +162,35 @@ export const handleRequestWillBeSent = (state, params) => {
         },
         body_shapes: requestBodyShape(state, request),
     });
+    const timestamp = numberValue(params.timestamp);
+    if (timestamp === undefined)
+        state.networkRequestTimestamps.delete(requestId);
+    else
+        state.networkRequestTimestamps.set(requestId, timestamp);
+};
+const preserveMalformedRedirectEvidence = (state, requestId, previous) => {
+    state.completeness.exclude("network_requests", "invalid_protocol_value");
+    if (previous === undefined)
+        return false;
+    state.malformedRedirectRequestIds.add(requestId);
+    if (state.input.include_json_body_shapes &&
+        isJsonMediaType(previous.mime_type) &&
+        previous.body_shapes.response === null) {
+        updateResponseBodyShape(state, requestId, null);
+        state.completeness.exclude("json_body_shapes", "invalid_protocol_value");
+    }
+    return true;
+};
+const redirectResponseUrlReason = (value) => {
+    if (value === undefined || value === "")
+        return "invalid_protocol_value";
+    try {
+        new URL(value);
+    }
+    catch {
+        return "invalid_protocol_value";
+    }
+    return exclusionReasonForUrl(value);
 };
 export const handleResponseReceived = (state, params) => {
     const requestId = cdpStringValue(params.requestId);
@@ -115,6 +198,8 @@ export const handleResponseReceived = (state, params) => {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
     const current = state.network.get(requestId);
     const response = recordValue(params.response);
     if (current === undefined)
@@ -125,6 +210,7 @@ export const handleResponseReceived = (state, params) => {
             ? "invalid_protocol_value"
             : exclusionReasonForUrl(cdpStringValue(response.url)));
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
         return;
     }
     state.network.set(requestId, {
@@ -140,6 +226,8 @@ export const handleLoadingFinished = (state, params) => {
     const requestId = cdpStringValue(params.requestId);
     if (requestId === undefined)
         return;
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
     const current = state.network.get(requestId);
     if (current === undefined)
         return;

package/dist/browser/CdpCaptureEvents.js

@@ -9,6 +9,8 @@ export class CdpCaptureEvents {
     scripts = new Map();
     executionContextFrames = new Map();
     network = new Map();
+    networkRequestTimestamps = new Map();
+    malformedRedirectRequestIds = new Set();
     allowedWebSockets = new Set();
     console = [];
     websockets = [];
@@ -39,6 +41,8 @@ export class CdpCaptureEvents {
         this.scripts.clear();
         this.executionContextFrames.clear();
         this.network.clear();
+        this.networkRequestTimestamps.clear();
+        this.malformedRedirectRequestIds.clear();
         this.allowedWebSockets.clear();
         this.console.length = 0;
         this.websockets.length = 0;
@@ -119,14 +123,19 @@ export class CdpCaptureEvents {
         if (!this.input.include_json_body_shapes)
             return [];
         return [...this.network.values()]
+            .filter((request) => !this.malformedRedirectRequestIds.has(request.request_id))
             .filter((request) => isJsonMediaType(request.mime_type))
             .map((request) => request.request_id);
     }
     responseBodyUnavailable(requestId) {
+        if (this.malformedRedirectRequestIds.has(requestId))
+            return;
         bodyShapes.updateResponseBodyShape(this, requestId, null);
         this.completeness.unavailable("json_body_shapes");
     }
     ingestResponseBody(requestId, value) {
+        if (this.malformedRedirectRequestIds.has(requestId))
+            return;
         bodyShapes.ingestResponseBodyShape(this, requestId, value);
     }
 }