rea-agents 6.5.0 → 6.7.0

package/dist/artifacts/apple/DylibResolutionReader.js

@@ -1,6 +1,4 @@
-import { createHash } from "node:crypto";
-import { constants } from "node:fs";
-import { lstat, open, readlink, realpath } from "node:fs/promises";
+import { lstat, readlink, realpath } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
 import { resolveTreePath } from "../../domain/apple/dyldPaths.js";
@@ -9,20 +7,23 @@ import { projectInputIssues } from "../../domain/inputIssueProjection.js";
 import { ArtifactReaderFailure } from "../ArtifactReader.js";
 import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
 import { consumeWithOrderedReads } from "../OrderedReads.js";
-import { hasMachoMagic, readMachoImage } from "./MachoLoadCommandReader.js";
+import { DylibFileAccess, classifyDylibReadFailure, } from "./DylibFileAccess.js";
+import { ArtifactResourceScope } from "../ArtifactResourceScope.js";
+import { assertArtifactReadActive } from "../ArtifactFileOperation.js";
 const OPERATION = "trace_dylib_resolution";
-const HASH_CHUNK_BYTES = 1024 * 1024;
 /** Concurrent four-byte magic reads while enumerating bundle roots. */
 const MAGIC_READ_CONCURRENCY = 8;
 /** Lazily probed, symlink-preserving view of one analyzed directory. */
 class FilesystemTreeView {
     root;
+    files;
     signal;
     #entries = new Map();
     #images = new Map();
     #identities = new Map();
-    constructor(root, signal) {
+    constructor(root, files, signal) {
         this.root = root;
+        this.files = files;
         this.signal = signal;
     }
     entry(path) {
@@ -37,7 +38,9 @@ class FilesystemTreeView {
         const cached = this.#images.get(path);
         if (cached !== undefined)
             return cached;
-        const pending = readImage(join(this.root, path), this.signal).then(({ facts, identity }) => {
+        const pending = this.files
+            .image(join(this.root, path))
+            .then(({ facts, identity }) => {
             this.#identities.set(path, identity);
             return facts;
         });
@@ -49,7 +52,7 @@ class FilesystemTreeView {
         return this.#identities.get(path);
     }
     async #readEntry(path) {
-        cancelled(this.signal);
+        assertArtifactReadActive(this.signal);
         const absolute = join(this.root, path);
         try {
             const metadata = await lstat(absolute);
@@ -71,77 +74,70 @@ export const traceDylibResolution = async (options) => {
     const parsed = dylibResolutionInputSchema.safeParse(options.parameters);
     if (!parsed.success)
         throw new AnalysisInputError(OPERATION, { cause: parsed.error }, projectInputIssues(parsed.error.issues, options.parameters));
-    // Canonicalization is inside the translated region: a revoked permission
-    // keeps its reason and path.
-    let root = options.rootPath;
-    try {
-        root = await realpath(options.rootPath);
-        const target = relative(root, await realpath(options.targetPath))
-            .split(sep)
-            .join("/");
-        const view = new FilesystemTreeView(root, options.signal);
-        const { roots: requested, unclassified } = parsed.data.roots !== undefined
-            ? { roots: parsed.data.roots, unclassified: [] }
-            : options.enumerateRoots
-                ? await executableRoots(root, view, options.signal)
-                : { roots: [target], unclassified: [] };
-        const roots = await requireMachoRoots(view, requested, parsed.data.roots !== undefined);
-        const trace = await traceDylibLoading(view, {
-            roots,
-            unclassified,
-            ...(parsed.data.architecture === undefined
-                ? {}
-                : { architecture: parsed.data.architecture }),
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-        });
-        // Each digest must describe the same file whose headers were parsed.
-        const digests = new Map();
-        for (const { path } of trace.images)
-            digests.set(path, await fileSha256(join(root, path), {
-                path,
-                expected: view.identity(path),
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-            }));
-        const targetDigest = digests.get(target) ??
-            (await fileSha256(join(root, target), {
-                path: target,
-                expected: undefined,
+    const resources = options.resourceScope ?? new ArtifactResourceScope();
+    return await resources.run(async () => {
+        // Canonicalization is inside the translated region: a revoked permission
+        // keeps its reason and path.
+        let root = options.rootPath;
+        try {
+            assertArtifactReadActive(options.signal);
+            root = await realpath(options.rootPath);
+            assertArtifactReadActive(options.signal);
+            const files = new DylibFileAccess(resources, root, options.signal);
+            const target = relative(root, await realpath(options.targetPath))
+                .split(sep)
+                .join("/");
+            assertArtifactReadActive(options.signal);
+            const view = new FilesystemTreeView(root, files, options.signal);
+            const { roots: requested, unclassified } = parsed.data.roots !== undefined
+                ? { roots: parsed.data.roots, unclassified: [] }
+                : options.enumerateRoots
+                    ? await executableRoots(root, view, files, options.signal)
+                    : { roots: [target], unclassified: [] };
+            const roots = await requireMachoRoots(view, requested, parsed.data.roots !== undefined);
+            const trace = await traceDylibLoading(view, {
+                roots,
+                unclassified,
+                ...(parsed.data.architecture === undefined
+                    ? {}
+                    : { architecture: parsed.data.architecture }),
                 ...(options.signal === undefined ? {} : { signal: options.signal }),
-            }));
-        if (targetDigest !== options.targetSha256)
-            throw new ArtifactReaderFailure("integrity", `Active target digest changed: expected ${options.targetSha256}, observed ${targetDigest}`);
-        return dylibResolutionResultSchema.parse({
-            ...trace,
-            root_path: options.rootPath,
-            target_sha256: options.targetSha256,
-            images: trace.images.map((image) => ({
-                ...image,
-                sha256: digests.get(image.path),
-            })),
-        });
-    }
-    catch (cause) {
-        if (options.signal?.aborted === true)
-            throw new ArtifactReaderFailure("cancelled", "Dylib resolution was cancelled", { cause });
-        const denied = permissionDenied(cause);
-        if (denied !== undefined)
-            throw new ArtifactReaderFailure("unavailable", `Permission denied (${denied.code}) reading ${deniedPath(root, denied.path)}`, { cause });
-        throw cause;
-    }
+            });
+            // Each digest must describe the same file whose headers were parsed.
+            const digests = new Map();
+            for (const { path } of trace.images)
+                digests.set(path, await files.sha256(join(root, path), view.identity(path)));
+            const targetDigest = digests.get(target) ??
+                (await files.sha256(join(root, target), undefined));
+            if (targetDigest !== options.targetSha256)
+                throw new ArtifactReaderFailure("integrity", `Active target digest changed: expected ${options.targetSha256}, observed ${targetDigest}`);
+            assertArtifactReadActive(options.signal);
+            return dylibResolutionResultSchema.parse({
+                ...trace,
+                root_path: options.rootPath,
+                target_sha256: options.targetSha256,
+                images: trace.images.map((image) => ({
+                    ...image,
+                    sha256: digests.get(image.path),
+                })),
+            });
+        }
+        catch (cause) {
+            throw classifyDylibReadFailure(root, cause);
+        }
+    });
 };
 /**
  * Every Mach-O in the bundle with an executable slice is its own process root.
  * Mach-O files that do not parse are returned separately: whether they are
  * executables is unknown, so they make coverage partial instead of vanishing.
  */
-const executableRoots = async (root, view, signal) => {
+const executableRoots = async (root, view, files, signal) => {
     const roots = [];
     const unclassified = [];
     // Bundles hold tens of thousands of files and few Mach-O images, so the
     // magic reads overlap the walk while results are classified in walk order.
-    await consumeWithOrderedReads(new DirectoryArtifactReader(root).entries(signal), MAGIC_READ_CONCURRENCY, (entry) => entry.kind === "file"
-        ? startsWithMachoMagic(entry.adapterKey)
-        : undefined, async (entry, macho) => {
+    await consumeWithOrderedReads(new DirectoryArtifactReader(root).entries(signal), MAGIC_READ_CONCURRENCY, (entry) => entry.kind === "file" ? files.startsWithMachoMagic(entry) : undefined, async (entry, macho) => {
         if (!macho)
             return;
         const facts = await view.image(entry.path);
@@ -183,93 +179,6 @@ const requireMachoRoots = async (view, roots, callerSelected) => {
     }
     return resolved;
 };
-const startsWithMachoMagic = async (path) => {
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const buffer = new Uint8Array(4);
-        const { bytesRead } = await handle.read(buffer, 0, 4, 0);
-        return hasMachoMagic(buffer.subarray(0, bytesRead));
-    }
-    finally {
-        await handle.close();
-    }
-};
-const identityOf = (metadata) => [
-    metadata.dev,
-    metadata.ino,
-    metadata.size,
-    metadata.mtimeNs,
-    metadata.ctimeNs,
-].join(":");
-const readImage = async (path, signal) => {
-    cancelled(signal);
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const metadata = await handle.stat({ bigint: true });
-        const size = Number(metadata.size);
-        const facts = await readMachoImage(async (offset, length) => {
-            cancelled(signal);
-            const buffer = new Uint8Array(Math.max(0, Math.min(length, size - offset)));
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
-            return buffer.subarray(0, bytesRead);
-        }, size);
-        return { facts, identity: identityOf(metadata) };
-    }
-    finally {
-        await handle.close();
-    }
-};
-/** Hash a file, failing if it is not the file (or the version) that was parsed. */
-const fileSha256 = async (absolute, options) => {
-    const { signal } = options;
-    const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
-    const unchanged = async () => {
-        if (options.expected !== undefined &&
-            identityOf(await handle.stat({ bigint: true })) !== options.expected)
-            throw new ArtifactReaderFailure("integrity", `${options.path} changed while its dyld load commands were traced`);
-    };
-    try {
-        await unchanged();
-        const hash = createHash("sha256");
-        const buffer = new Uint8Array(HASH_CHUNK_BYTES);
-        for (;;) {
-            cancelled(signal);
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
-            if (bytesRead === 0)
-                break;
-            hash.update(buffer.subarray(0, bytesRead));
-        }
-        await unchanged();
-        return hash.digest("hex");
-    }
-    finally {
-        await handle.close();
-    }
-};
-const cancelled = (signal) => {
-    if (signal?.aborted === true)
-        throw new ArtifactReaderFailure("cancelled", "Dylib resolution was cancelled");
-};
-/** A denied path relative to the analyzed root, or absolute when outside it. */
-const deniedPath = (root, path) => {
-    if (path === undefined)
-        return "a file in the analyzed root";
-    const inside = relative(root, path);
-    return inside === "" || inside.startsWith("..") ? path : inside;
-};
-/** Host permission denials, kept distinct from malformed or missing files. */
-const permissionDenied = (cause) => {
-    if (!(cause instanceof Error) || !("code" in cause))
-        return undefined;
-    if (cause.code !== "EACCES" && cause.code !== "EPERM")
-        return undefined;
-    return {
-        code: cause.code,
-        path: "path" in cause && typeof cause.path === "string"
-            ? cause.path
-            : undefined,
-    };
-};
 const missing = (cause) => cause instanceof Error &&
     "code" in cause &&
     (cause.code === "ENOENT" || cause.code === "ENOTDIR");

package/dist/artifacts/apple/InterfaceBuilderAnalysis.js

@@ -3,7 +3,7 @@ import { parseBinary } from "plist";
 import { appleResourceKeyFields } from "../../domain/apple/appleAssetCatalog.js";
 import { interfaceBuilderConnectionFieldNames, isUIKitRuntimeConnectionClass, } from "../../domain/apple/interfaceBuilderKeyedArchive.js";
 import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
-import { projectPlistValue } from "../../domain/apple/plistValue.js";
+import { projectPlistValue, unknownDateLimitation, } from "../../domain/apple/plistValue.js";
 import { omittedPrototypeKeysLimitation, parseXmlPropertyList, } from "../../domain/propertyListKeys.js";
 import { decodeNibArchive } from "./NibArchive.js";
 import { preflightPropertyListDecode, InterfaceBuilderDecodeBudget, InterfaceBuilderDecodeBudgetExceeded, } from "./InterfaceBuilderDecodeBudget.js";
@@ -12,6 +12,7 @@ import { mergeNibHierarchies, projectNibViewHierarchy, } from "./NibViewHierarch
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 import { decodeXmlPlistText } from "../../domain/propertyListXmlText.js";
+import { decodeBinaryPlistNumbers, scanBinaryPlistNumberLiterals, } from "./PlistNumberLiterals.js";
 import { hasBinaryPlistSignature, hasNibArchiveSignature, } from "../../domain/apple/appleArchiveFormat.js";
 const MAX_AGGREGATE_INPUT_BYTES = 32 * 1024 * 1024;
 const MAX_AGGREGATE_DECODE_BYTES = 256 * 1024 * 1024;
@@ -27,6 +28,7 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
     const incompleteHierarchies = new Map();
     const unresolvedConnections = new Map();
     const prototypeKeyOmissions = new Map();
+    const unknownDates = new Map();
     let omitted = 0;
     let attempted = 0;
     let aggregateInputBytes = 0;
@@ -44,6 +46,8 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
             recordOmittedArchive(entry.path, "max_documents");
         unreportedOmittedArchives += selection.unreportedOmitted;
         for (const entry of selection.selected) {
+            // Plist representation reserved for this document before decoding.
+            let plistReservation = 0;
             try {
                 const remainingInputBytes = MAX_AGGREGATE_INPUT_BYTES - aggregateInputBytes;
                 if (entry.declaredSize !== null &&
@@ -67,20 +71,28 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
                 else {
                     if (!hasBinaryPlistSignature(bytes))
                         xmlText = decodeXmlPlistText(bytes);
-                    const decodedReservation = preflightPropertyListDecode(bytes, decodeBudget.remainingBytes, xmlText);
+                    const decodedReservation = preflightPropertyListDecode(bytes, decodeBudget.remainingBytes, xmlText, { numberProjection: true });
                     decodeBudget.reserve(decodedReservation.estimatedBytes, "plist representation exceeds the aggregate Interface Builder decode budget");
+                    plistReservation = decodedReservation.estimatedBytes;
                     binaryPrototypeKeyObserved =
                         decodedReservation.binaryPrototypeKeyObserved;
                 }
-                const { value: raw, omittedPrototypeKeys } = nib === null
+                const { value: raw, omittedPrototypeKeys, unknownDateCount, numberLiterals, } = nib === null
                     ? decodePlist(bytes, xmlText, binaryPrototypeKeyObserved)
-                    : { value: nib.raw, omittedPrototypeKeys: 0 };
+                    : {
+                        value: nib.raw,
+                        omittedPrototypeKeys: 0,
+                        unknownDateCount: 0,
+                        numberLiterals: undefined,
+                    };
                 if (nib !== null && nib.omitted > 0)
                     incompleteHierarchies.set(entry.path, nib.omitted);
                 if (nib !== null && nib.unresolvedConnections > 0)
                     unresolvedConnections.set(entry.path, nib.unresolvedConnections);
                 if (omittedPrototypeKeys !== 0)
                     prototypeKeyOmissions.set(entry.path, omittedPrototypeKeys);
+                if (unknownDateCount !== 0)
+                    unknownDates.set(entry.path, unknownDateCount);
                 const documentHash = createHash("sha256").update(bytes).digest("hex");
                 documents.push({
                     relativePath: entry.path,
@@ -89,6 +101,7 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
                         ? "storyboard_scene"
                         : "nib",
                     raw,
+                    ...(numberLiterals === undefined ? {} : { numberLiterals }),
                     ...(nib === null || nib.omitted === 0
                         ? {}
                         : { omittedSerializedHierarchyReferences: nib.omitted }),
@@ -98,6 +111,9 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
                 if (input.signal?.aborted === true)
                     throw cause;
                 if (cause instanceof InterfaceBuilderDecodeBudgetExceeded) {
+                    // A document rejected while decoding, e.g. beyond the shared depth
+                    // limit, retains no representation; later documents keep its share.
+                    decodeBudget.release(plistReservation);
                     omitted += 1;
                     recordOmittedArchive(entry.path, cause.reason);
                     continue;
@@ -119,6 +135,7 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
         incompleteHierarchies,
         unresolvedConnections,
         prototypeKeyOmissions,
+        unknownDates,
         invalid,
         omittedArchives,
         unreportedOmittedArchives,
@@ -163,7 +180,7 @@ const retainCandidate = (candidates, entry, maximum) => {
         candidates.pop();
 };
 const finalizeHierarchyCoverage = (result, counts) => {
-    const { incompleteHierarchies, unresolvedConnections, prototypeKeyOmissions, invalid, omittedArchives, unreportedOmittedArchives, } = counts;
+    const { incompleteHierarchies, unresolvedConnections, prototypeKeyOmissions, unknownDates, invalid, omittedArchives, unreportedOmittedArchives, } = counts;
     const archiveDecodePartial = invalid.length > 0 ||
         prototypeKeyOmissions.size > 0 ||
         omittedArchives.length > 0;
@@ -236,6 +253,7 @@ const finalizeHierarchyCoverage = (result, counts) => {
                     `Some Interface Builder archives could not be decoded: ${invalid.slice(0, 16).join("; ")}`,
                 ]),
             ...[...prototypeKeyOmissions].map(([path, count]) => `${path}: ${omittedPrototypeKeysLimitation(count)}`),
+            ...[...unknownDates].map(([path, count]) => `${path}: ${unknownDateLimitation(count)}`),
             ...omittedArchives.map(({ path, reason }) => `${path}: omitted because ${reason.replaceAll("_", " ")}.`),
             ...(unreportedOmittedArchives === 0
                 ? []
@@ -523,14 +541,39 @@ const readEntry = async (reader, entry, signal, maxInputBytes = MAX_AGGREGATE_IN
     }
     return Buffer.concat(chunks, length);
 };
+/**
+ * The shared parser bounds plist value nesting before its recursive decode and
+ * reports the limit as a RangeError; that is an omitted archive, not a
+ * malformed one.
+ */
+const parseXmlWithinDecodeBudget = (text) => {
+    try {
+        return parseXmlPropertyList(text);
+    }
+    catch (cause) {
+        if (cause instanceof RangeError)
+            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", cause.message);
+        throw cause;
+    }
+};
 /** Project decoded plist data and dates while retaining omitted-key coverage. */
 const decodePlist = (bytes, xmlText, binaryPrototypeKeyObserved) => {
     const binary = hasBinaryPlistSignature(bytes);
-    const { value, omittedPrototypeKeys } = binary
+    const binaryNumberMetadata = binary
+        ? scanBinaryPlistNumberLiterals(bytes)
+        : undefined;
+    const { value, omittedPrototypeKeys, numberLiterals } = binary
         ? {
-            value: parseBinary(bytes),
+            value: parseBinary(decodeBinaryPlistNumbers(bytes, binaryNumberMetadata)),
             omittedPrototypeKeys: binaryPrototypeKeyObserved ? null : 0,
+            numberLiterals: binaryNumberMetadata.literals,
         }
-        : parseXmlPropertyList(xmlText ?? decodeXmlPlistText(bytes));
-    return { value: projectPlistValue(value).value, omittedPrototypeKeys };
+        : parseXmlWithinDecodeBudget(xmlText ?? decodeXmlPlistText(bytes));
+    const projected = projectPlistValue(value);
+    return {
+        value: projected.value,
+        omittedPrototypeKeys,
+        unknownDateCount: projected.unknownDateCount,
+        numberLiterals,
+    };
 };

package/dist/artifacts/apple/InterfaceBuilderDecodeBudget.js

@@ -33,6 +33,10 @@ export class InterfaceBuilderDecodeBudget {
             throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", message);
         this.#remainingBytes -= bytes;
     }
+    /** Return a reservation whose representation was rejected and not retained. */
+    release(bytes) {
+        this.#remainingBytes = Math.min(this.#initialBytes, this.#remainingBytes + bytes);
+    }
     /** Reserve an upper bound for one JSON-serialized string occurrence. */
     reserveJsonStringOccurrence(value) {
         // JSON escaping uses at most six ASCII bytes per UTF-16 code unit, plus
@@ -59,22 +63,26 @@ export class InterfaceBuilderDecodeBudget {
     }
 }
 /** Preflight the representation created by the pinned plist decoder. */
-export const preflightPropertyListDecode = (bytes, maxBytes, xmlText) => {
+export const preflightPropertyListDecode = (bytes, maxBytes, xmlText, options = {}) => {
+    const { numberProjection = false } = options;
     const expansion = hasBinaryPlistSignature(bytes)
-        ? estimateBinaryPlistExpansion(bytes, maxBytes)
+        ? estimateBinaryPlistExpansion(bytes, maxBytes, { numberProjection })
         : {
-            estimatedBytes: estimateXmlPlistExpansion(bytes, maxBytes, xmlText),
+            estimatedBytes: estimateXmlPlistExpansion(bytes, maxBytes, xmlText, numberProjection),
             binaryPrototypeKeyObserved: false,
         };
     if (expansion.estimatedBytes > maxBytes)
         throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "plist representation exceeds the aggregate Interface Builder decode budget");
     return expansion;
 };
-const estimateXmlPlistExpansion = (bytes, maxBytes, xmlText) => {
+const estimateXmlPlistExpansion = (bytes, maxBytes, xmlText, numberProjection = false) => {
     const xml = xmlText ?? decodeXmlPlistText(bytes);
     const decodedSourceBytes = xml.length * 2;
     let elementCount = 0;
-    let xmlDepth = 0;
+    // Reserve room for numeric source metadata and the projected attribute copy.
+    const elementBytes = numberProjection ? 256 : 128;
+    // Value nesting is bounded by the shared plist parser, which counts plist
+    // value depth; raw element depth would also count the envelope and keys.
     for (const token of xmlPreflightTokens(xml)) {
         if (token.doctype) {
             // Only a declaration outside opaque text can introduce an internal
@@ -84,17 +92,10 @@ const estimateXmlPlistExpansion = (bytes, maxBytes, xmlText) => {
             continue;
         }
         elementCount += 1;
-        if (token.closing)
-            xmlDepth -= 1;
-        else if (!token.selfClosing) {
-            xmlDepth += 1;
-            if (xmlDepth > 128)
-                throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "XML plist nesting exceeds the aggregate Interface Builder decode budget");
-        }
-        if (decodedSourceBytes * 2 + elementCount * 128 > maxBytes)
+        if (decodedSourceBytes * 2 + elementCount * elementBytes > maxBytes)
             return maxBytes + 1;
     }
-    return decodedSourceBytes * 2 + elementCount * 128;
+    return decodedSourceBytes * 2 + elementCount * elementBytes;
 };
 /** Consume each XML span once; malformed tokens cannot restart suffix scans. */
 function* xmlPreflightTokens(xml) {
@@ -139,12 +140,7 @@ function* xmlPreflightTokens(xml) {
             return;
         cursor = end + 1;
         if (doctype || element)
-            yield {
-                doctype,
-                internalSubset,
-                closing: xml[start + 1] === "/",
-                selfClosing: xml[end - 1] === "/",
-            };
+            yield { doctype, internalSubset };
     }
 }
 const interfaceBuilderBudgetFailure = (_kind, message) => new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", message);
@@ -154,7 +150,7 @@ const PROTOTYPE_KEY = "__proto__";
  * 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", } = {}) => {
+export const estimateBinaryPlistExpansion = (bytes, maxBytes, { budget = "the aggregate Interface Builder decode budget", fail = interfaceBuilderBudgetFailure, bounds = "strict", numberProjection = false, } = {}) => {
     if (bytes.length < 40)
         throw new TypeError("binary plist trailer is truncated");
     const trailer = bytes.length - 32;
@@ -182,7 +178,12 @@ export const estimateBinaryPlistExpansion = (bytes, maxBytes, { budget = "the ag
         offsetTable < 8 ||
         offsetTable + objectCount * offsetSize > tableEnd)
         throw new TypeError("binary plist trailer or object table is invalid");
-    let estimate = bytes.length * 2 + objectCount * 16;
+    // Metadata covers the full object table; projected values may repeat through references.
+    const objectBytes = numberProjection ? 144 : 16;
+    const expandedNodeBytes = numberProjection ? 224 : 96;
+    // Number projection may require a same-sized parser-compatible input copy
+    // for wide integers. Reserve for it before the caller allocates that copy.
+    let estimate = bytes.length * (numberProjection ? 3 : 2) + objectCount * objectBytes;
     let binaryPrototypeKeyObserved = false;
     if (estimate > maxBytes)
         throw fail("expansion", `binary plist object table exceeds ${budget}`);
@@ -202,7 +203,7 @@ export const estimateBinaryPlistExpansion = (bytes, maxBytes, { budget = "the ag
             throw fail("depth", `binary plist nesting exceeds ${budget}`);
         if (active.has(entry.object))
             throw fail("cycle", `binary plist reference cycle exceeds ${budget}`);
-        estimate += 96;
+        estimate += expandedNodeBytes;
         if (estimate > maxBytes)
             throw fail("expansion", `binary plist reference expansion exceeds ${budget}`);
         const offset = readInteger(offsetTable + entry.object * offsetSize, offsetSize);
@@ -258,7 +259,7 @@ export const estimateBinaryPlistExpansion = (bytes, maxBytes, { budget = "the ag
         const refsEnd = cursor + childCount * referenceSize;
         if (!Number.isSafeInteger(refsEnd) || refsEnd > objectsEnd)
             throw new TypeError("binary plist reference table is truncated");
-        const availableNodes = Math.floor((maxBytes - estimate) / 96);
+        const availableNodes = Math.floor((maxBytes - estimate) / expandedNodeBytes);
         if (childCount > availableNodes - pendingObjectCount)
             throw fail("expansion", `binary plist reference expansion exceeds ${budget}`);
         active.add(entry.object);

package/dist/artifacts/apple/KeyedArchiveReader.js

@@ -3,9 +3,9 @@ import { join } from "node:path";
 import { parseBinary } from "plist";
 import { z } from "zod";
 import { AnalysisInputError, AnalysisUnsupportedTargetError, } from "../../domain/analysisErrorCore.js";
-import { projectPlistValue } from "../../domain/apple/plistValue.js";
+import { negativeZeroRealLimitation, nonFiniteRealLimitation, unknownDateLimitation, unknownRealLimitation, } from "../../domain/apple/plistValue.js";
 import { createPlistNumberProjection } from "../../domain/apple/plistNumbers.js";
-import { binaryPlistNumberLiterals, xmlPlistNumberLiterals, } from "./PlistNumberLiterals.js";
+import { decodeBinaryPlistNumbers, scanBinaryPlistNumberLiterals, } from "./PlistNumberLiterals.js";
 import { omittedPrototypeKeysLimitation, parseXmlPropertyList, } from "../../domain/propertyListKeys.js";
 import { KeyedArchiveKindError, keyedArchiveInputSchema, keyedArchiveResultSchema, projectKeyedArchive, } from "../../domain/apple/keyedArchive.js";
 import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
@@ -34,21 +34,23 @@ export const decodeKeyedArchiveBytes = (bytes, selection) => {
                 ? new TypeError("binary plist object references form a cycle, which a property list cannot represent")
                 : new RangeError(message),
             bounds: "decoder",
+            numberProjection: true,
         })
         : undefined;
+    const binaryNumberMetadata = binary
+        ? scanBinaryPlistNumberLiterals(bytes)
+        : undefined;
     const parsed = binaryExpansion !== undefined
         ? {
-            value: parseBinary(bytes),
+            value: parseBinary(decodeBinaryPlistNumbers(bytes, binaryNumberMetadata)),
+            numberLiterals: binaryNumberMetadata.literals,
             omittedPrototypeKeys: binaryExpansion.binaryPrototypeKeyObserved
                 ? null
                 : 0,
         }
         : parseXmlPropertyList(xmlText ?? "");
-    const { value: plistValue, unknownRealCount } = projectPlistValue(parsed.value);
-    const graph = projectKeyedArchive(plistValue, selection);
-    const numbers = createPlistNumberProjection(binary
-        ? binaryPlistNumberLiterals(bytes)
-        : xmlPlistNumberLiterals(xmlText ?? ""));
+    const { nonFiniteRealCount, unknownRealCount, negativeZeroRealCount, unknownDateCount, ...graph } = projectKeyedArchive(parsed.value, selection);
+    const numbers = createPlistNumberProjection(parsed.numberLiterals);
     // Classify the serialized graph before projecting values to typed decimals.
     // Numeric IDs, node kinds, references and pagination retain their original meaning.
     const roots = Object.fromEntries(Object.entries(graph.roots).map(([name, value]) => [
@@ -70,11 +72,18 @@ export const decodeKeyedArchiveBytes = (bytes, selection) => {
             ...(parsed.omittedPrototypeKeys === 0
                 ? []
                 : [omittedPrototypeKeysLimitation(parsed.omittedPrototypeKeys)]),
+            ...(nonFiniteRealCount === 0
+                ? []
+                : [nonFiniteRealLimitation(nonFiniteRealCount)]),
             ...(unknownRealCount === 0
                 ? []
-                : [
-                    `${String(unknownRealCount)} non-finite real value(s) are reported as { "$plist_type": "real", "value": null } because JSON evidence cannot preserve NaN vs infinity.`,
-                ]),
+                : [unknownRealLimitation(unknownRealCount)]),
+            ...(negativeZeroRealCount === 0
+                ? []
+                : [negativeZeroRealLimitation(negativeZeroRealCount)]),
+            ...(unknownDateCount === 0
+                ? []
+                : [unknownDateLimitation(unknownDateCount)]),
         ],
     };
 };

package/dist/artifacts/apple/MachoLoadCommandReader.js

@@ -107,7 +107,16 @@ export const readMachoImage = async (readAt, size) => {
                 : { status: "not-mach-o" };
         const view = viewOf(head);
         const magic = view.getUint32(0, false);
-        let header = readFatContainerHeader(head, size);
+        let header;
+        if (magic === FAT_MAGIC && size <= MAX_LOAD_COMMAND_BYTES) {
+            const complete = await readAt(0, size);
+            header =
+                complete.byteLength === size
+                    ? readFatContainerHeader(complete, size)
+                    : readFatContainerHeader(head, size);
+        }
+        else
+            header = readFatContainerHeader(head, size);
         if (header.state !== "not-fat") {
             if (header.state === "needs-data") {
                 header = readFatContainerHeader(await readAt(0, header.requiredBytes), size);
@@ -129,8 +138,14 @@ export const readMachoImage = async (readAt, size) => {
             }
             if (identity.state === "not-mach-o")
                 return { status: "not-mach-o" };
-            if (identity.state === "malformed")
+            if (identity.state === "malformed") {
+                // A large CAFEBABE input whose bounded prefix resembles an invalid
+                // known-CPU FAT table remains unknown until its JVM identity can be
+                // checked; do not turn the resource limit into a malformed claim.
+                if (magic === FAT_MAGIC && size > MAX_LOAD_COMMAND_BYTES)
+                    throw new MachoFormatIssue("unsupported", "FAT/JVM identity is unresolved because the class identity scan exceeds the 16 MiB limit");
                 throw new MachoFormatIssue(identity.category, identity.reason);
+            }
             if (identity.state === "needs-slice-header")
                 return { status: "not-mach-o" };
             return {