rea-agents 6.3.0 → 6.4.0

package/dist/artifacts/ZipArtifactReader.js

@@ -1,20 +1,54 @@
-import { open } from "node:fs/promises";
 import { PassThrough } from "node:stream";
 import { once } from "node:events";
 import { Reader, ZipReader } from "@zip.js/zip.js";
-import { ArtifactReaderFailure, } from "./ArtifactReader.js";
+import { ArtifactReaderFailure, copyArtifactEntry, sameArtifactEntry, } from "./ArtifactReader.js";
+import { OwnedFileHandle } from "../filesystem/OwnedFileHandle.js";
+import { NonRegularFileReadError, RegularFileAdmissionFailure, openRegularFile, sameRegularFileState, } from "../filesystem/RegularFile.js";
 class NodeFileReader extends Reader {
     path;
     maximumReadBytes;
+    admitted;
     #handle;
-    constructor(path, maximumReadBytes) {
+    #owner;
+    #initPromise;
+    #ownsHandle;
+    constructor(path, maximumReadBytes, admitted) {
         super(path);
         this.path = path;
         this.maximumReadBytes = maximumReadBytes;
+        this.admitted = admitted;
+        this.#ownsHandle = admitted === undefined;
     }
-    async init() {
-        this.#handle = await open(this.path, "r");
-        this.size = (await this.#handle.stat()).size;
+    init() {
+        this.#initPromise ??= this.#initialize();
+        return this.#initPromise;
+    }
+    async #initialize() {
+        try {
+            const handle = this.admitted?.handle ??
+                (await openRegularFile(this.path, { symlinks: "reject" }));
+            this.#handle = handle;
+            if (this.#ownsHandle)
+                this.#owner = new OwnedFileHandle(handle);
+        }
+        catch (cause) {
+            if (cause instanceof RegularFileAdmissionFailure) {
+                this.#owner = cause.owner;
+                const primary = cause.cause instanceof NonRegularFileReadError
+                    ? new ArtifactReaderFailure("format", `ZIP source is not a regular file: ${this.path}`, { cause: cause.cause })
+                    : cause.cause;
+                throw ArtifactReaderFailure.withCleanup(primary, ArtifactReaderFailure.cleanupObservation(cause.cleanupCause, this.path));
+            }
+            if (cause instanceof NonRegularFileReadError)
+                throw new ArtifactReaderFailure("format", `ZIP source is not a regular file: ${this.path}`, { cause });
+            throw cause;
+        }
+        const metadata = await this.#handle.stat();
+        if (!metadata.isFile() ||
+            (this.admitted !== undefined &&
+                !sameRegularFileState(this.admitted.initial, metadata)))
+            throw new ArtifactReaderFailure("integrity", `ZIP source identity changed before reading: ${this.path}`);
+        this.size = metadata.size;
     }
     async readUint8Array(index, length) {
         const handle = this.#handle;
@@ -29,7 +63,13 @@ class NodeFileReader extends Reader {
         return bytes.subarray(0, read.bytesRead);
     }
     async closeHandle() {
-        await this.#handle?.close();
+        if (!this.#ownsHandle)
+            return;
+        await this.#initPromise?.catch(() => undefined);
+        if (this.#owner === undefined)
+            return;
+        await this.#owner.close();
+        this.#owner = undefined;
         this.#handle = undefined;
     }
 }
@@ -40,9 +80,9 @@ export class ZipArtifactReader {
     #reader;
     #entries = new Map();
     /** Optionally bound each metadata read before allocating its backing buffer. */
-    constructor(path, format, maximumMetadataReadBytes) {
+    constructor(path, format, maximumMetadataReadBytes, admitted) {
         this.format = format;
-        this.#source = new NodeFileReader(path, maximumMetadataReadBytes);
+        this.#source = new NodeFileReader(path, maximumMetadataReadBytes, admitted);
         this.#reader = new ZipReader(this.#source, {
             checkSignature: true,
             checkOverlappingEntry: true,
@@ -54,31 +94,25 @@ export class ZipArtifactReader {
     async *entries(signal) {
         for await (const entry of this.#reader.getEntriesGenerator()) {
             abortIfNeeded(signal);
-            this.#entries.set(entry.filename, entry);
-            const symlink = isSymlink(entry);
-            yield {
-                path: entry.filename,
-                kind: entry.directory ? "directory" : symlink ? "symlink" : "file",
-                declaredSize: entry.directory ? null : entry.uncompressedSize,
-                compressedSize: entry.directory ? null : entry.compressedSize,
-                executable: entry.executable,
-                encrypted: entry.encrypted,
-                byteOffset: null,
-                declaredSha256: null,
-                unpacked: false,
-                limitations: symlink ? ["Archive symlink target was not read."] : [],
-                adapterKey: entry.filename,
-            };
+            const metadata = projectZipEntry(entry);
+            this.#entries.set(entry.filename, {
+                source: entry,
+                metadata: copyArtifactEntry(metadata),
+            });
+            yield metadata;
         }
     }
     open(entry, signal) {
         abortIfNeeded(signal);
         const stored = this.#entries.get(entry.adapterKey);
-        if (stored === undefined || stored.directory || isSymlink(stored))
+        if (stored === undefined || !sameArtifactEntry(entry, stored.metadata))
+            return Promise.reject(new ArtifactReaderFailure("integrity", "ZIP entry metadata does not match this reader's inventory"));
+        const source = stored.source;
+        if (source.directory || isSymlink(source))
             return Promise.reject(new ArtifactReaderFailure("format", "ZIP entry is not a regular file"));
-        if (stored.encrypted)
+        if (source.encrypted)
             return Promise.reject(new ArtifactReaderFailure("unavailable", "Encrypted ZIP entry is unsupported"));
-        return Promise.resolve(extractStream(stored, signal));
+        return Promise.resolve(extractStream(source, signal));
     }
     async close() {
         // best-effort cleanup: zip-reader close must not mask prior extraction state.
@@ -89,6 +123,22 @@ export class ZipArtifactReader {
         return [];
     }
 }
+const projectZipEntry = (entry) => {
+    const symlink = isSymlink(entry);
+    return {
+        path: entry.filename,
+        kind: entry.directory ? "directory" : symlink ? "symlink" : "file",
+        declaredSize: entry.directory ? null : entry.uncompressedSize,
+        compressedSize: entry.directory ? null : entry.compressedSize,
+        executable: entry.executable,
+        encrypted: entry.encrypted,
+        byteOffset: null,
+        declaredSha256: null,
+        unpacked: false,
+        limitations: symlink ? ["Archive symlink target was not read."] : [],
+        adapterKey: entry.filename,
+    };
+};
 const extractStream = (entry, signal) => {
     const output = new PassThrough();
     const controller = new AbortController();

package/dist/artifacts/apple/InterfaceBuilderAnalysis.js

@@ -4,10 +4,11 @@ import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
 import { projectPlistValue } from "../../domain/apple/plistValue.js";
 import { omittedPrototypeKeysLimitation, parseXmlPropertyList, } from "../../domain/propertyListKeys.js";
 import { decodeNibArchive } from "./NibArchive.js";
-import { estimatePropertyListDecodeBytes, InterfaceBuilderDecodeBudget, InterfaceBuilderDecodeBudgetExceeded, } from "./InterfaceBuilderDecodeBudget.js";
+import { preflightPropertyListDecode, InterfaceBuilderDecodeBudget, InterfaceBuilderDecodeBudgetExceeded, } from "./InterfaceBuilderDecodeBudget.js";
 import { buildInterfaceBuilderAnalysis, interfaceBuilderLimitsSchema, } from "../../domain/apple/interfaceBuilderGraph.js";
 import { mergeNibHierarchies, projectNibViewHierarchy, } from "./NibViewHierarchy.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 import { decodeXmlPlistText } from "../../domain/propertyListXmlText.js";
 const MAX_AGGREGATE_INPUT_BYTES = 32 * 1024 * 1024;
 const MAX_AGGREGATE_DECODE_BYTES = 256 * 1024 * 1024;
@@ -24,7 +25,6 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
     const prototypeKeyOmissions = new Map();
     let omitted = 0;
     let attempted = 0;
-    let candidates = 0;
     let aggregateInputBytes = 0;
     const decodeBudget = new InterfaceBuilderDecodeBudget(MAX_AGGREGATE_DECODE_BYTES);
     const recordOmittedArchive = (path, reason) => {
@@ -34,15 +34,12 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
             unreportedOmittedArchives += 1;
     };
     try {
-        for await (const entry of reader.entries(input.signal)) {
-            if (entry.kind !== "file" || !isInterfaceBuilderArchive(entry.path))
-                continue;
-            candidates += 1;
-            if (candidates > limits.max_documents) {
-                omitted += 1;
-                recordOmittedArchive(entry.path, "max_documents");
-                continue;
-            }
+        const selection = await selectInterfaceBuilderCandidates(reader, input.signal, limits.max_documents);
+        omitted = selection.omitted;
+        for (const entry of selection.omittedSamples)
+            recordOmittedArchive(entry.path, "max_documents");
+        unreportedOmittedArchives += selection.unreportedOmitted;
+        for (const entry of selection.selected) {
             try {
                 const remainingInputBytes = MAX_AGGREGATE_INPUT_BYTES - aggregateInputBytes;
                 if (entry.declaredSize !== null &&
@@ -57,6 +54,7 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
                 const isNibArchive = bytes.subarray(0, 10).toString("ascii") === "NIBArchive";
                 let nib = null;
                 let xmlText;
+                let binaryPrototypeKeyObserved = false;
                 if (isNibArchive) {
                     const documentBudget = new InterfaceBuilderDecodeBudget(decodeBudget.remainingBytes);
                     nib = projectNibArchive(decodeNibArchive(bytes, documentBudget), documentBudget, limits.max_objects);
@@ -65,15 +63,17 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
                 else {
                     if (bytes.subarray(0, 8).toString("ascii") !== "bplist00")
                         xmlText = decodeXmlPlistText(bytes);
-                    const decodedReservation = estimatePropertyListDecodeBytes(bytes, decodeBudget.remainingBytes, xmlText);
-                    decodeBudget.reserve(decodedReservation, "plist representation exceeds the aggregate Interface Builder decode budget");
+                    const decodedReservation = preflightPropertyListDecode(bytes, decodeBudget.remainingBytes, xmlText);
+                    decodeBudget.reserve(decodedReservation.estimatedBytes, "plist representation exceeds the aggregate Interface Builder decode budget");
+                    binaryPrototypeKeyObserved =
+                        decodedReservation.binaryPrototypeKeyObserved;
                 }
                 const { value: raw, omittedPrototypeKeys } = nib === null
-                    ? decodePlist(bytes, xmlText)
+                    ? decodePlist(bytes, xmlText, binaryPrototypeKeyObserved)
                     : { value: nib.raw, omittedPrototypeKeys: 0 };
                 if (nib !== null && nib.omitted > 0)
                     incompleteHierarchies.set(entry.path, nib.omitted);
-                if (omittedPrototypeKeys > 0)
+                if (omittedPrototypeKeys !== 0)
                     prototypeKeyOmissions.set(entry.path, omittedPrototypeKeys);
                 const documentHash = createHash("sha256").update(bytes).digest("hex");
                 documents.push({
@@ -116,6 +116,42 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
         omitted,
     });
 };
+/** Select lexically earliest document paths independent of host traversal order. */
+const selectInterfaceBuilderCandidates = async (reader, signal, maximumDocuments) => {
+    const capacity = maximumDocuments + MAX_REPORTED_OMITTED_ARCHIVES;
+    const candidates = [];
+    let total = 0;
+    for await (const entry of reader.entries(signal)) {
+        if (entry.kind !== "file" || !isInterfaceBuilderArchive(entry.path))
+            continue;
+        total += 1;
+        retainCandidate(candidates, entry, capacity);
+    }
+    const omittedSamples = candidates.slice(maximumDocuments, capacity);
+    return {
+        selected: candidates.slice(0, maximumDocuments),
+        omittedSamples,
+        omitted: Math.max(0, total - maximumDocuments),
+        unreportedOmitted: Math.max(0, total - maximumDocuments - omittedSamples.length),
+    };
+};
+/** Keep the earliest bounded path set; directory iteration order is host-defined. */
+const retainCandidate = (candidates, entry, maximum) => {
+    let low = 0;
+    let high = candidates.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        const existing = candidates[middle];
+        if (existing !== undefined &&
+            compareUnicodeCodePoints(existing.path, entry.path) < 0)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    candidates.splice(low, 0, entry);
+    if (candidates.length > maximum)
+        candidates.pop();
+};
 const finalizeHierarchyCoverage = (result, counts) => {
     const { incompleteHierarchies, prototypeKeyOmissions, invalid, omittedArchives, unreportedOmittedArchives, } = counts;
     const archiveDecodePartial = invalid.length > 0 ||
@@ -452,9 +488,13 @@ const readEntry = async (reader, entry, signal, maxInputBytes = MAX_AGGREGATE_IN
     return Buffer.concat(chunks, length);
 };
 /** Project decoded plist data and dates while retaining omitted-key coverage. */
-const decodePlist = (bytes, xmlText) => {
-    const { value, omittedPrototypeKeys } = bytes.subarray(0, 8).toString("ascii") === "bplist00"
-        ? { value: parseBinary(bytes), omittedPrototypeKeys: 0 }
+const decodePlist = (bytes, xmlText, binaryPrototypeKeyObserved) => {
+    const binary = bytes.subarray(0, 8).toString("ascii") === "bplist00";
+    const { value, omittedPrototypeKeys } = binary
+        ? {
+            value: parseBinary(bytes),
+            omittedPrototypeKeys: binaryPrototypeKeyObserved ? null : 0,
+        }
         : parseXmlPropertyList(xmlText ?? decodeXmlPlistText(bytes));
     return { value: projectPlistValue(value).value, omittedPrototypeKeys };
 };

package/dist/artifacts/apple/InterfaceBuilderDecodeBudget.js

@@ -58,13 +58,16 @@ export class InterfaceBuilderDecodeBudget {
     }
 }
 /** Preflight the representation created by the pinned plist decoder. */
-export const estimatePropertyListDecodeBytes = (bytes, maxBytes, xmlText) => {
-    const estimate = bytes.subarray(0, 8).toString("ascii") === "bplist00"
+export const preflightPropertyListDecode = (bytes, maxBytes, xmlText) => {
+    const expansion = bytes.subarray(0, 8).toString("ascii") === "bplist00"
         ? estimateBinaryPlistExpansion(bytes, maxBytes)
-        : estimateXmlPlistExpansion(bytes, maxBytes, xmlText);
-    if (estimate > maxBytes)
+        : {
+            estimatedBytes: estimateXmlPlistExpansion(bytes, maxBytes, xmlText),
+            binaryPrototypeKeyObserved: false,
+        };
+    if (expansion.estimatedBytes > maxBytes)
         throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "plist representation exceeds the aggregate Interface Builder decode budget");
-    return estimate;
+    return expansion;
 };
 const estimateXmlPlistExpansion = (bytes, maxBytes, xmlText) => {
     const xml = xmlText ?? decodeXmlPlistText(bytes);
@@ -94,8 +97,14 @@ const estimateXmlPlistExpansion = (bytes, maxBytes, xmlText) => {
     }
     return decodedSourceBytes * 2 + elementCount * 128;
 };
-/** Count every expanded binary-plist reference before calling plist.parseBinary. */
-const estimateBinaryPlistExpansion = (bytes, maxBytes) => {
+const interfaceBuilderBudgetFailure = (_kind, message) => new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", message);
+const PROTOTYPE_KEY = "__proto__";
+/**
+ * Count every expanded binary-plist reference before calling plist.parseBinary,
+ * which recurses on each reference and copies shared containers. Malformed
+ * structure throws TypeError; budget, depth, and cycle failures use `fail`.
+ */
+export const estimateBinaryPlistExpansion = (bytes, maxBytes, { budget = "the aggregate Interface Builder decode budget", fail = interfaceBuilderBudgetFailure, bounds = "strict", } = {}) => {
     if (bytes.length < 40)
         throw new TypeError("binary plist trailer is truncated");
     const trailer = bytes.length - 32;
@@ -115,19 +124,20 @@ const estimateBinaryPlistExpansion = (bytes, maxBytes) => {
     const objectCount = readInteger(trailer + 8, 8);
     const topObject = readInteger(trailer + 16, 8);
     const offsetTable = readInteger(trailer + 24, 8);
+    const tableEnd = bounds === "strict" ? trailer : bytes.length;
+    const objectsEnd = bounds === "strict" ? offsetTable : bytes.length;
     if (objectCount < 1 ||
         topObject < 0 ||
         topObject >= objectCount ||
         offsetTable < 8 ||
-        offsetTable + objectCount * offsetSize > trailer)
+        offsetTable + objectCount * offsetSize > tableEnd)
         throw new TypeError("binary plist trailer or object table is invalid");
     let estimate = bytes.length * 2 + objectCount * 16;
+    let binaryPrototypeKeyObserved = false;
     if (estimate > maxBytes)
-        throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist object table exceeds the aggregate Interface Builder decode budget");
+        throw fail("expansion", `binary plist object table exceeds ${budget}`);
     const active = new Set();
-    const pending = [
-        { object: topObject, depth: 0, exit: false },
-    ];
+    const pending = [{ object: topObject, depth: 0, exit: false, dictionaryKey: false }];
     let pendingObjectCount = 1;
     while (pending.length > 0) {
         const entry = pending.pop();
@@ -139,14 +149,14 @@ const estimateBinaryPlistExpansion = (bytes, maxBytes) => {
         }
         pendingObjectCount -= 1;
         if (entry.depth > 128)
-            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist nesting exceeds the aggregate Interface Builder decode budget");
+            throw fail("depth", `binary plist nesting exceeds ${budget}`);
         if (active.has(entry.object))
-            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist reference cycle exceeds the aggregate Interface Builder decode budget");
+            throw fail("cycle", `binary plist reference cycle exceeds ${budget}`);
         estimate += 96;
         if (estimate > maxBytes)
-            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist reference expansion exceeds the aggregate Interface Builder decode budget");
+            throw fail("expansion", `binary plist reference expansion exceeds ${budget}`);
         const offset = readInteger(offsetTable + entry.object * offsetSize, offsetSize);
-        if (offset < 8 || offset >= offsetTable)
+        if (offset < 8 || offset >= objectsEnd)
             throw new TypeError("binary plist object offset is invalid");
         const marker = bytes[offset] ?? 0;
         const type = marker >> 4;
@@ -160,36 +170,64 @@ const estimateBinaryPlistExpansion = (bytes, maxBytes) => {
             const integerSize = 1 << (extMarker & 0x0f);
             size = readInteger(cursor, integerSize);
             cursor += integerSize;
-            if (size < 0 || cursor > offsetTable)
+            if (size < 0 || cursor > objectsEnd)
                 throw new TypeError("binary plist extended object size is invalid");
         }
         if (type === 4 || type === 5 || type === 6) {
             const byteLength = type === 6 ? size * 2 : size;
-            if (cursor + byteLength > offsetTable)
+            if (cursor + byteLength > objectsEnd)
                 throw new TypeError("binary plist scalar object is truncated");
+            if (!binaryPrototypeKeyObserved &&
+                entry.dictionaryKey &&
+                (type === 5 || type === 6) &&
+                size === PROTOTYPE_KEY.length) {
+                let matches = true;
+                for (let index = 0; index < PROTOTYPE_KEY.length; index += 1) {
+                    const codeUnit = type === 5
+                        ? (bytes[cursor + index] ?? 0)
+                        : ((bytes[cursor + index * 2] ?? 0) << 8) |
+                            (bytes[cursor + index * 2 + 1] ?? 0);
+                    if (codeUnit !== PROTOTYPE_KEY.charCodeAt(index)) {
+                        matches = false;
+                        break;
+                    }
+                }
+                if (matches)
+                    binaryPrototypeKeyObserved = true;
+            }
             estimate += type === 4 ? size + 4 * Math.ceil(size / 3) : byteLength * 2;
             if (estimate > maxBytes)
-                throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist scalar expansion exceeds the aggregate Interface Builder decode budget");
+                throw fail("expansion", `binary plist scalar expansion exceeds ${budget}`);
             continue;
         }
         if (type !== 10 && type !== 13)
             continue;
         const childCount = type === 13 ? size * 2 : size;
         const refsEnd = cursor + childCount * referenceSize;
-        if (!Number.isSafeInteger(refsEnd) || refsEnd > offsetTable)
+        if (!Number.isSafeInteger(refsEnd) || refsEnd > objectsEnd)
             throw new TypeError("binary plist reference table is truncated");
         const availableNodes = Math.floor((maxBytes - estimate) / 96);
         if (childCount > availableNodes - pendingObjectCount)
-            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist reference expansion exceeds the aggregate Interface Builder decode budget");
+            throw fail("expansion", `binary plist reference expansion exceeds ${budget}`);
         active.add(entry.object);
-        pending.push({ object: entry.object, depth: entry.depth, exit: true });
+        pending.push({
+            object: entry.object,
+            depth: entry.depth,
+            exit: true,
+            dictionaryKey: false,
+        });
         for (let index = childCount - 1; index >= 0; index -= 1) {
             const reference = readInteger(cursor + index * referenceSize, referenceSize);
             if (reference < 0 || reference >= objectCount)
                 throw new TypeError("binary plist reference is invalid");
-            pending.push({ object: reference, depth: entry.depth + 1, exit: false });
+            pending.push({
+                object: reference,
+                depth: entry.depth + 1,
+                exit: false,
+                dictionaryKey: type === 13 && index < size,
+            });
         }
         pendingObjectCount += childCount;
     }
-    return estimate;
+    return { estimatedBytes: estimate, binaryPrototypeKeyObserved };
 };

package/dist/artifacts/apple/KeyedArchiveReader.js

@@ -11,7 +11,10 @@ import { KeyedArchiveKindError, keyedArchiveInputSchema, keyedArchiveResultSchem
 import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
 import { ArtifactReaderFailure } from "../ArtifactReader.js";
 import { decodeXmlPlistText } from "../../domain/propertyListXmlText.js";
+import { estimateBinaryPlistExpansion } from "./InterfaceBuilderDecodeBudget.js";
 const MAX_BYTES = 64 * 1024 * 1024;
+/** Decoded representation budget, the same 8:1 ratio Interface Builder uses. */
+const MAX_DECODE_BYTES = 8 * MAX_BYTES;
 /** Parse inert plist bytes, preserving data and dates with explicit typed values. */
 export const decodeKeyedArchiveBytes = (bytes, selection) => {
     if (bytes.length > MAX_BYTES)
@@ -20,8 +23,25 @@ export const decodeKeyedArchiveBytes = (bytes, selection) => {
         throw new KeyedArchiveKindError("Selected file is a compiled NIBArchive, not a Foundation plist archive; decode it with decode_interface_builder", "nib-archive");
     const binary = bytes.subarray(0, 8).toString("ascii") === "bplist00";
     const xmlText = binary ? undefined : decodeXmlPlistText(bytes);
-    const parsed = binary
-        ? { value: parseBinary(bytes), omittedPrototypeKeys: 0 }
+    // plist.parseBinary recurses on every object reference and copies shared
+    // containers, so a few hundred bytes can exhaust memory or the stack.
+    // RangeError reports a resource limit; a reference cycle is malformed.
+    const binaryExpansion = binary
+        ? estimateBinaryPlistExpansion(bytes, MAX_DECODE_BYTES, {
+            budget: "the keyed archive decode budget",
+            fail: (kind, message) => kind === "cycle"
+                ? new TypeError("binary plist object references form a cycle, which a property list cannot represent")
+                : new RangeError(message),
+            bounds: "decoder",
+        })
+        : undefined;
+    const parsed = binaryExpansion !== undefined
+        ? {
+            value: parseBinary(bytes),
+            omittedPrototypeKeys: binaryExpansion.binaryPrototypeKeyObserved
+                ? null
+                : 0,
+        }
         : parseXmlPropertyList(xmlText ?? "");
     const { value: plistValue, unknownRealCount } = projectPlistValue(parsed.value);
     const graph = projectKeyedArchive(plistValue, selection);
@@ -82,21 +102,20 @@ export const inspectBundleKeyedArchive = async (input) => {
     try {
         // Match inventory spelling while retaining the raw path for I/O and evidence.
         const wanted = selected.path.normalize("NFC");
-        const matches = [];
-        for await (const entry of reader.entries(input.signal)) {
-            if (entry.path.normalize("NFC") !== wanted)
+        let entry;
+        for await (const candidate of reader.entries(input.signal, (directory) => wanted.startsWith(`${directory.normalize("NFC")}/`))) {
+            if (candidate.path.normalize("NFC") !== wanted)
                 continue;
-            matches.push(entry);
+            if (candidate.kind !== "file")
+                throw archivePathError("invalid_value", `Archive path selects a ${candidate.kind}, not a regular file: ${selected.path}`);
+            if ((candidate.declaredSize ?? 0) > MAX_BYTES)
+                throw new ArtifactReaderFailure("limit", "Keyed archive exceeds 64 MiB");
+            if (entry !== undefined)
+                throw archivePathError("invalid_value", `Archive path matches multiple Unicode-equivalent bundle entries; selection is ambiguous: ${selected.path}`);
+            entry = candidate;
         }
-        if (matches.length > 1)
-            throw archivePathError("invalid_value", `Archive path matches ${String(matches.length)} Unicode-equivalent bundle entries; selection is ambiguous: ${selected.path}`);
-        const entry = matches[0];
         if (entry === undefined)
             throw archivePathError("invalid_value", `No regular file exists at ${selected.path} in the active app bundle.`);
-        if (entry.kind !== "file")
-            throw archivePathError("invalid_value", `Archive path selects a ${entry.kind}, not a regular file: ${selected.path}`);
-        if ((entry.declaredSize ?? 0) > MAX_BYTES)
-            throw new ArtifactReaderFailure("limit", "Keyed archive exceeds 64 MiB");
         const stream = await reader.open(entry, input.signal);
         const chunks = [];
         let size = 0;