rea-agents 6.4.0 → 6.7.0

package/dist/domain/apple/keyedArchive.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { AnalysisInputError } from "../analysisErrorCore.js";
 import { jsonValueSchema } from "../jsonValue.js";
+import { localPathStringSchema } from "../localPath.js";
+import { projectPlistValue } from "./plistValue.js";
 /**
  * The selected file is intact but is another kind of file, so another tool
  * applies. A malformed NSKeyedArchiver archive is not this error.
@@ -17,7 +19,7 @@ export class KeyedArchiveKindError extends TypeError {
 }
 /** Select one archive within the active bundle and optionally one named root. */
 export const keyedArchiveInputSchema = z.strictObject({
-    path: z.string().min(1).default("."),
+    path: localPathStringSchema.default("."),
     root: z.string().optional(),
     offset: z.number().int().min(0).default(0),
     limit: z.number().int().min(1).max(20_000).default(20_000),
@@ -59,7 +61,10 @@ export const keyedArchiveResultSchema = z.strictObject({
     truncated: z.boolean(),
     limitations: z.array(z.string()),
 });
-const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+const record = (value, wrappedScalars) => value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    !wrappedScalars.has(value)
     ? value
     : undefined;
 /**
@@ -67,8 +72,8 @@ const record = (value) => value !== null && typeof value === "object" && !Array.
  * a numeric value. Any other value means an ordinary dictionary, such as a
  * `$top` that holds a root encoded under the key `UID`.
  */
-const uid = (value) => {
-    const object = record(value);
+const uid = (value, wrappedScalars) => {
+    const object = record(value, wrappedScalars);
     if (object === undefined || Object.keys(object).length !== 1)
         return undefined;
     const marker = Object.hasOwn(object, "UID") ? object.UID : object["CF$UID"];
@@ -83,9 +88,13 @@ const archiverMismatch = (archive) => {
         ? `its $archiver is ${JSON.stringify(archive.$archiver)}`
         : "its $archiver is not a string";
 };
-/** Interpret serialized Foundation references without instantiating archive classes. */
+/** Interpret decoded Foundation values without instantiating archive classes. */
 export const projectKeyedArchive = (value, selection) => {
-    const archive = record(jsonValueSchema.parse(value));
+    // Classify generated scalar wrappers by their producer identity, never by
+    // a caller-controlled $plist_type field in an ordinary dictionary.
+    const wrappedScalars = new WeakSet();
+    const projected = projectPlistValue(value, (scalar) => wrappedScalars.add(scalar));
+    const archive = record(projected.value, wrappedScalars);
     if (archive?.$archiver !== "NSKeyedArchiver")
         throw new KeyedArchiveKindError(`Selected property list is not an NSKeyedArchiver archive: ${archiverMismatch(archive)}`, "property-list");
     if (!Array.isArray(archive.$objects))
@@ -93,7 +102,7 @@ export const projectKeyedArchive = (value, selection) => {
     const table = archive.$objects;
     if (table.length > 200_000)
         throw new RangeError("Archive exceeds 200000 object-table entries");
-    const top = record(archive.$top);
+    const top = record(archive.$top, wrappedScalars);
     if (top === undefined || Object.keys(top).length === 0)
         throw new TypeError("Keyed archive has no $top roots");
     if (selection.root !== undefined && !Object.hasOwn(top, selection.root))
@@ -109,10 +118,9 @@ export const projectKeyedArchive = (value, selection) => {
         ? top
         : { [selection.root]: top[selection.root] ?? null };
     const references = [];
+    // `initial` is popped from the end, so callers list it in reverse order.
     const scan = (source, initial) => {
-        const pending = [
-            { value: initial, path: [] },
-        ];
+        const pending = initial;
         let visited = 0;
         while (pending.length > 0) {
             const item = pending.pop();
@@ -120,7 +128,7 @@ export const projectKeyedArchive = (value, selection) => {
                 break;
             if (++visited > 200_000 || item.path.length > 128)
                 throw new RangeError("Archive exceeds 200000 values per object or 128 nesting levels");
-            const target = uid(item.value);
+            const target = uid(item.value, wrappedScalars);
             if (target !== undefined) {
                 const index = Number.isSafeInteger(target) && target >= 0 ? target : null;
                 references.push({
@@ -145,7 +153,7 @@ export const projectKeyedArchive = (value, selection) => {
                 }
             }
             else {
-                const fields = record(item.value);
+                const fields = record(item.value, wrappedScalars);
                 if (fields !== undefined)
                     for (const key of Object.keys(fields).sort().reverse()) {
                         const child = fields[key];
@@ -157,15 +165,25 @@ export const projectKeyedArchive = (value, selection) => {
                 throw new RangeError("Archive exceeds 200000 reference edges");
         }
     };
-    scan(null, roots);
+    // Root names belong to the `$top` map, not to the encoded value. Scanning
+    // that wrapper makes a sole scalar root named `UID` look like a UID marker.
+    // Seed one scan with each value under its key to preserve paths and share
+    // the existing aggregate visit budget across every root.
+    scan(null, Object.keys(roots)
+        .sort()
+        .reverse()
+        .flatMap((key) => {
+        const value = roots[key];
+        return value === undefined ? [] : [{ value, path: [key] }];
+    }));
     const objects = table.map((value, id) => {
-        scan(id, value);
-        const fields = record(value);
-        const classUid = uid(fields?.$class);
+        scan(id, [{ value, path: [] }]);
+        const fields = record(value, wrappedScalars);
+        const classUid = uid(fields?.$class, wrappedScalars);
         const classId = classUid !== undefined && Number.isSafeInteger(classUid) && classUid >= 0
             ? classUid
             : null;
-        const descriptor = classId === null ? undefined : record(table[classId]);
+        const descriptor = classId === null ? undefined : record(table[classId], wrappedScalars);
         const className = typeof descriptor?.$classname === "string" ? descriptor.$classname : null;
         const isNil = id === 0 && value === "$null";
         return {
@@ -197,6 +215,10 @@ export const projectKeyedArchive = (value, selection) => {
     const page = objects.slice(selection.offset, end);
     const ids = new Set(page.map(({ id }) => id));
     return {
+        nonFiniteRealCount: projected.nonFiniteRealCount,
+        unknownRealCount: projected.unknownRealCount,
+        negativeZeroRealCount: projected.negativeZeroRealCount,
+        unknownDateCount: projected.unknownDateCount,
         roots,
         objects: page,
         references: references.filter(({ source }) => source === null || ids.has(source)),

package/dist/domain/apple/machoContainer.js

@@ -1,3 +1,95 @@
+import { isJvmClassFile } from "./jvmClassFile.js";
+const FAT_MAGIC = 0xcafebabe;
+const FAT_MAGIC_64 = 0xcafebabf;
+const FAT_CIGAM = 0xbebafeca;
+const FAT_CIGAM_64 = 0xbfbafeca;
+const MAX_FAT_ARCHITECTURES = 128;
+const KNOWN_MACHO_CPU_TYPES = [
+    7, 0x01000007, 12, 0x0100000c, 0x0200000c, 18, 0x01000012,
+];
+const MACHO_HEADER_MAGICS = [
+    0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe,
+];
+/** Parse a bounded FAT header and table without treating the magic alone as proof. */
+export const readFatContainerHeader = (bytes, fileSize) => {
+    if (bytes.byteLength < 4)
+        return { state: "not-fat" };
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const magic = view.getUint32(0, false);
+    if (![FAT_MAGIC, FAT_MAGIC_64, FAT_CIGAM, FAT_CIGAM_64].includes(magic))
+        return { state: "not-fat" };
+    if (!Number.isSafeInteger(fileSize) || fileSize < bytes.byteLength)
+        return {
+            state: "malformed",
+            reason: "FAT file size is invalid or contradicts retained bytes",
+        };
+    if (bytes.byteLength === fileSize && isJvmClassFile(bytes))
+        return { state: "not-fat" };
+    if (bytes.byteLength < 8) {
+        return fileSize < 8
+            ? { state: "malformed", reason: "FAT header is truncated" }
+            : { state: "needs-data", requiredBytes: 8 };
+    }
+    const littleEndian = magic === FAT_CIGAM || magic === FAT_CIGAM_64;
+    const wide = magic === FAT_MAGIC_64 || magic === FAT_CIGAM_64;
+    const count = view.getUint32(4, littleEndian);
+    if (count === 0)
+        return {
+            state: "malformed",
+            reason: "FAT header declares no architectures",
+        };
+    if (count > MAX_FAT_ARCHITECTURES)
+        return { state: "not-fat" };
+    const tableEnd = 8 + count * (wide ? 32 : 20);
+    if (tableEnd > fileSize)
+        return { state: "not-fat" };
+    if (tableEnd > bytes.byteLength)
+        return { state: "needs-data", requiredBytes: tableEnd };
+    const declarations = readFatSliceDeclarations(bytes.subarray(8, tableEnd), {
+        count,
+        wide,
+        littleEndian,
+    });
+    return declarations.status === "parsed"
+        ? {
+            state: "parsed",
+            magic,
+            count,
+            wide,
+            littleEndian,
+            tableEnd,
+            slices: declarations.slices,
+            rangeIssues: declarations.slices.map((slice) => inspectFatSliceRange(slice, fileSize, tableEnd)),
+        }
+        : { state: "malformed", reason: declarations.reason };
+};
+/** Confirm FAT identity from architecture records and observed slice headers. */
+export const classifyFatContainerIdentity = (header, sliceHeaderAt) => {
+    const hasKnownCpu = header.slices.some(({ cpuType }) => KNOWN_MACHO_CPU_TYPES.includes(cpuType));
+    const invalidRange = header.rangeIssues.find((issue) => issue !== null);
+    if (hasKnownCpu)
+        return invalidRange === undefined
+            ? { state: "mach-o" }
+            : { state: "malformed", ...invalidRange };
+    const validRanges = header.slices.filter((_slice, index) => header.rangeIssues[index] === null);
+    const missingHeaders = [];
+    let observedMachO = false;
+    for (const slice of validRanges) {
+        const magic = sliceHeaderAt(slice.offset);
+        if (magic === undefined)
+            missingHeaders.push(slice.offset);
+        else if (magic !== null && MACHO_HEADER_MAGICS.includes(magic))
+            observedMachO = true;
+    }
+    if (observedMachO) {
+        return invalidRange === undefined
+            ? { state: "mach-o" }
+            : { state: "malformed", ...invalidRange };
+    }
+    if (missingHeaders.length > 0)
+        return { state: "needs-slice-header", offsets: missingHeaders };
+    return { state: "not-mach-o" };
+};
 /** Decode FAT table entries once so artifact and native readers share identity facts. */
 export const readFatSliceDeclarations = (tableBytes, options) => {
     const { count, wide, littleEndian } = options;
@@ -32,23 +124,46 @@ export const readFatSliceDeclarations = (tableBytes, options) => {
 };
 /** Validate byte-range and table/header identity facts shared by Mach-O readers. */
 export const validateFatSlice = (declaration, containerSize, tableEnd, embedded) => {
-    const { index, offset, size, alignmentExponent, cpuType, cpuSubtype } = declaration;
+    const rangeIssue = inspectFatSliceRange(declaration, containerSize, tableEnd);
+    if (rangeIssue !== null)
+        return rangeIssue.reason;
+    return embedded === undefined
+        ? null
+        : validateFatSliceIdentity(declaration, embedded);
+};
+/** Validate table placement, container bounds, and alignment with a typed failure. */
+export const inspectFatSliceRange = (declaration, containerSize, tableEnd) => {
+    const { index, offset, size, alignmentExponent } = declaration;
     if (!Number.isSafeInteger(offset) ||
         !Number.isSafeInteger(size) ||
         size <= 0 ||
         offset < tableEnd)
-        return `FAT architecture ${index} has an invalid slice range`;
+        return {
+            category: "malformed",
+            reason: `FAT architecture ${index} has an invalid slice range`,
+        };
     if (offset > containerSize || size > containerSize - offset)
-        return `FAT architecture ${index} slice range extends beyond the file`;
+        return {
+            category: "malformed",
+            reason: `FAT architecture ${index} slice range extends beyond the file`,
+        };
     if (!Number.isInteger(alignmentExponent) ||
         alignmentExponent < 0 ||
         alignmentExponent > 52)
-        return `FAT architecture ${index} alignment exponent ${alignmentExponent} is unsupported`;
+        return {
+            category: "unsupported",
+            reason: `FAT architecture ${index} alignment exponent ${alignmentExponent} is unsupported`,
+        };
     if (offset % 2 ** alignmentExponent !== 0)
-        return `FAT architecture ${index} offset is not aligned to 2^${alignmentExponent}`;
-    if (embedded !== undefined &&
-        (embedded.cpuType !== cpuType || embedded.cpuSubtype !== cpuSubtype))
-        return `FAT architecture ${index} CPU type/subtype disagrees with its Mach-O header`;
+        return {
+            category: "malformed",
+            reason: `FAT architecture ${index} offset is not aligned to 2^${alignmentExponent}`,
+        };
     return null;
 };
+/** Validate only the identity claim after the owner has validated its range. */
+export const validateFatSliceIdentity = (declaration, embedded) => embedded.cpuType === declaration.cpuType &&
+    embedded.cpuSubtype === declaration.cpuSubtype
+    ? null
+    : `FAT architecture ${declaration.index} CPU type/subtype disagrees with its Mach-O header`;
 const safeNumber = (value) => value > BigInt(Number.MAX_SAFE_INTEGER) ? null : Number(value);

package/dist/domain/apple/machoCpuIdentity.js

@@ -0,0 +1,4 @@
+/** CPU subtype bits reserved for ABI/capability flags, not the base subtype. */
+const CPU_SUBTYPE_CAPABILITY_MASK = 0xff000000;
+/** Return the CPU subtype identity shared across capability-flag variations. */
+export const machoCpuSubtypeBase = (cpuSubtype) => cpuSubtype & ~CPU_SUBTYPE_CAPABILITY_MASK;

package/dist/domain/apple/plistNumbers.js

@@ -1,3 +1,44 @@
+/** XML numeric decoding could not establish a representable value identity. */
+export class UnknownPlistReal {
+}
+/** Exact decimal or signed hexadecimal XML integer text. */
+export const parsePlistIntegerLiteral = (text) => {
+    const match = /^([+-]?)(?:0[xX]([\da-fA-F]+)|(\d+))$/u.exec(text.trim());
+    if (match === null)
+        return undefined;
+    const magnitude = BigInt(match[2] === undefined ? match[3] : `0x${match[2]}`);
+    return match[1] === "-" ? -magnitude : magnitude;
+};
+export const incompletePlistNumberLimitation = "Property-list number metadata could not be completely observed; decoded numbers may lose integer precision and exact integer/real association is unavailable.";
+/** Collect facts at the decoder boundary before integer values are rounded. */
+export const createPlistNumberCollector = () => {
+    const integers = new Map();
+    const reals = new Set();
+    let unsafeIntegerLiterals = 0;
+    let incompleteMetadata = false;
+    return {
+        integer: (exact) => {
+            if (exact >= BigInt(Number.MIN_SAFE_INTEGER) &&
+                exact <= BigInt(Number.MAX_SAFE_INTEGER))
+                return;
+            unsafeIntegerLiterals++;
+            const rounded = Number(exact);
+            integers.set(rounded, (integers.get(rounded) ?? new Set()).add(exact.toString()));
+        },
+        real: (value) => {
+            reals.add(value);
+        },
+        markIncomplete: () => {
+            incompleteMetadata = true;
+        },
+        result: (incomplete = false) => ({
+            integers,
+            reals,
+            unsafeIntegerLiterals,
+            incomplete: incomplete || incompleteMetadata,
+        }),
+    };
+};
 /** Preserve unambiguous exact integers; disclose rounded or unclassified numbers. */
 export const createPlistNumberProjection = (literals) => {
     let exactIntegerCount = 0;
@@ -51,11 +92,7 @@ export const createPlistNumberProjection = (literals) => {
     return {
         project: map,
         limitations: () => [
-            ...(literals.incomplete
-                ? [
-                    "Original archive number metadata could not be completely observed; decoded numbers may lose integer precision and exact integer/real association is unavailable.",
-                ]
-                : []),
+            ...(literals.incomplete ? [incompletePlistNumberLimitation] : []),
             ...(literals.unsafeIntegerLiterals === 0
                 ? []
                 : [
@@ -74,3 +111,28 @@ export const createPlistNumberProjection = (literals) => {
         ],
     };
 };
+/**
+ * Read a whole `<real>` text as one of CFPropertyList's non-finite spellings.
+ * Its parser compares the complete text case-insensitively and also accepts
+ * `infinity`, `inf`, `+inf` and `-inf`; its writer emits `nan`, `+infinity`
+ * and `-infinity`. Any other text, including surrounding whitespace, is not
+ * a spelled non-finite real.
+ */
+export const parsePlistNonFiniteRealLiteral = (text) => {
+    if (text.length < 3 || text.length > 9)
+        return undefined;
+    switch (text.toLowerCase()) {
+        case "nan":
+            return Number.NaN;
+        case "+infinity":
+        case "infinity":
+        case "+inf":
+        case "inf":
+            return Number.POSITIVE_INFINITY;
+        case "-infinity":
+        case "-inf":
+            return Number.NEGATIVE_INFINITY;
+        default:
+            return undefined;
+    }
+};

package/dist/domain/apple/plistValue.js

@@ -1,35 +1,111 @@
+import { types } from "node:util";
 import { z } from "zod";
-const MAX_PLIST_DEPTH = 128;
+import { UnknownPlistReal } from "./plistNumbers.js";
 /**
- * Project a decoded plist into JSON. Data and dates become explicit
- * `$plist_type` objects; a non-finite real becomes an explicit unknown
- * because the XML decoder reports NaN and ±infinity alike.
+ * Maximum plist value nesting the JSON projection supports. The XML decode
+ * preflight shares this limit so oversized documents are rejected before any
+ * recursive pass rather than during one.
  */
-export const projectPlistValue = (value) => {
+export const MAX_PLIST_DEPTH = 128;
+/** Limitation for results whose plist held dates the decoder could not represent. */
+export const unknownDateLimitation = (count) => `${String(count)} date value(s) are reported as { "$plist_type": "date", "iso8601": null } because the decoder could not represent them, such as XML dates with years beyond 9999 or negative years, or dates outside the JavaScript date range.`;
+/** Limitation for known non-finite values; the labels do not imply XML provenance. */
+export const nonFiniteRealLimitation = (count) => `${String(count)} non-finite real value(s) are reported as { "$plist_type": "real", "value": "<spelling>" } using canonical numeric labels nan, +infinity or -infinity because a JSON number cannot carry them.`;
+/** Limitation for XML numeric values the decoder could not establish. */
+export const unknownRealLimitation = (count) => `${String(count)} numeric value(s) are reported as { "$plist_type": "real", "value": null } because XML numeric decoding could not establish their value identity.`;
+/** The typed scalar that keeps a negative-zero real distinct from positive zero. */
+export const negativeZeroReal = () => ({
+    $plist_type: "real",
+    value: "-0",
+});
+/** Limitation for results whose plist held negative-zero reals. */
+export const negativeZeroRealLimitation = (count) => `${String(count)} negative-zero real value(s) are reported as { "$plist_type": "real", "value": "-0" } because a JSON number cannot carry the sign of zero.`;
+/**
+ * Project a decoded plist into JSON. Data, dates, retained big integers and
+ * known non-finite reals become explicit `$plist_type` objects. Unresolved XML
+ * numeric values remain explicit unknowns, and a negative-zero
+ * real keeps its sign, which JSON serialization would drop.
+ */
+export const projectPlistValue = (value, 
+/** Observe generated wrappers before consumers classify the JSON value tree. */
+onWrappedScalar) => {
+    let nonFiniteRealCount = 0;
     let unknownRealCount = 0;
+    let negativeZeroRealCount = 0;
+    let unknownDateCount = 0;
+    const scalar = (value) => {
+        onWrappedScalar?.(value);
+        return value;
+    };
     const project = (item, depth) => {
         if (depth > MAX_PLIST_DEPTH)
             throw new RangeError(`Plist exceeds ${String(MAX_PLIST_DEPTH)} nesting levels`);
+        if (item !== null && typeof item === "object" && types.isProxy(item))
+            throw new TypeError("Plist values cannot contain proxies");
         if (item instanceof Uint8Array)
-            return {
+            return scalar({
                 $plist_type: "data",
                 base64: Buffer.from(item).toString("base64"),
-            };
-        if (item instanceof Date)
-            return { $plist_type: "date", iso8601: item.toISOString() };
-        if (typeof item === "number" && !Number.isFinite(item)) {
+            });
+        if (item instanceof UnknownPlistReal) {
             unknownRealCount += 1;
-            return { $plist_type: "real", value: null };
+            return scalar({ $plist_type: "real", value: null });
+        }
+        if (item instanceof Date) {
+            if (!Number.isNaN(Date.prototype.getTime.call(item)))
+                return scalar({
+                    $plist_type: "date",
+                    iso8601: Date.prototype.toISOString.call(item),
+                });
+            unknownDateCount += 1;
+            return scalar({ $plist_type: "date", iso8601: null });
+        }
+        if (typeof item === "number" && !Number.isFinite(item)) {
+            nonFiniteRealCount += 1;
+            const label = Number.isNaN(item)
+                ? "nan"
+                : item > 0
+                    ? "+infinity"
+                    : "-infinity";
+            return scalar({ $plist_type: "real", value: label });
+        }
+        // Integer decoders never yield -0, so a signed zero here is a real.
+        if (typeof item === "number" && Object.is(item, -0)) {
+            negativeZeroRealCount += 1;
+            return scalar(negativeZeroReal());
+        }
+        if (typeof item === "bigint")
+            return scalar({ $plist_type: "integer", decimal: item.toString() });
+        if (Array.isArray(item)) {
+            const result = [];
+            for (let index = 0; index < item.length; index++) {
+                const descriptor = Object.getOwnPropertyDescriptor(item, index);
+                if (descriptor === undefined || !Object.hasOwn(descriptor, "value"))
+                    throw new TypeError("Plist arrays require dense data properties without accessors");
+                result.push(project(descriptor.value, depth + 1));
+            }
+            return result;
+        }
+        if (item !== null && typeof item === "object") {
+            const entries = [];
+            for (const key of Reflect.ownKeys(item)) {
+                const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                if (descriptor?.enumerable !== true)
+                    continue;
+                if (typeof key !== "string" || !Object.hasOwn(descriptor, "value"))
+                    throw new TypeError("Plist dictionary entries require string keys and data properties");
+                entries.push([key, project(descriptor.value, depth + 1)]);
+            }
+            return Object.fromEntries(entries);
         }
-        if (Array.isArray(item))
-            return item.map((entry) => project(entry, depth + 1));
-        if (item !== null && typeof item === "object")
-            return Object.fromEntries(Object.entries(item).map(([key, entry]) => [
-                key,
-                project(entry, depth + 1),
-            ]));
         return z.union([z.string(), z.number(), z.boolean(), z.null()]).parse(item);
     };
     const projected = project(value, 0);
-    return { value: projected, unknownRealCount };
+    return {
+        value: projected,
+        nonFiniteRealCount,
+        unknownRealCount,
+        negativeZeroRealCount,
+        unknownDateCount,
+    };
 };