rea-agents 6.0.0 → 6.2.0

package/dist/artifacts/apple/InterfaceBuilderDecodeBudget.js

@@ -0,0 +1,195 @@
+import { decodeXmlPlistText } from "../../domain/propertyListXmlText.js";
+/** A named resource-limit failure that keeps budget exhaustion out of decode errors. */
+export class InterfaceBuilderDecodeBudgetExceeded extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = "InterfaceBuilderDecodeBudgetExceeded";
+    }
+}
+/** Shared byte budget for decoder records and projected archive data. */
+export class InterfaceBuilderDecodeBudget {
+    #initialBytes;
+    #remainingBytes;
+    constructor(maxBytes) {
+        this.#initialBytes = maxBytes;
+        this.#remainingBytes = maxBytes;
+    }
+    /** Representation bytes still available for the current inspection. */
+    get remainingBytes() {
+        return this.#remainingBytes;
+    }
+    /** Representation bytes reserved so far. */
+    get usedBytes() {
+        return this.#initialBytes - this.#remainingBytes;
+    }
+    /** Reserve representation bytes before allocation, or report exhaustion. */
+    reserve(bytes, message) {
+        if (!Number.isSafeInteger(bytes) ||
+            bytes < 0 ||
+            bytes > this.#remainingBytes)
+            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", message);
+        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
+        // quotes. Count occurrences even when the source string is shared.
+        this.reserve(value.length * 6 + 2, "projected JSON strings exceed the aggregate Interface Builder decode budget");
+    }
+    /** Reserve the exact JSON string length for a base64 value from Buffer. */
+    reserveBase64JsonStringOccurrence(value) {
+        // Buffer's base64 alphabet contains no JSON-escaped characters.
+        this.reserve(value.length + 2, "projected NIB base64 values exceed the aggregate Interface Builder decode budget");
+    }
+    /** Reserve an upper bound for one JSON object property name occurrence. */
+    reserveJsonPropertyNameOccurrence(value) {
+        this.reserve(value.length * 6 + 3, "projected JSON property names exceed the aggregate Interface Builder decode budget");
+    }
+    /** Reserve bytes for an optional projection without throwing on exhaustion. */
+    tryReserve(bytes) {
+        if (!Number.isSafeInteger(bytes) ||
+            bytes < 0 ||
+            bytes > this.#remainingBytes)
+            return false;
+        this.#remainingBytes -= bytes;
+        return true;
+    }
+}
+/** Preflight the representation created by the pinned plist decoder. */
+export const estimatePropertyListDecodeBytes = (bytes, maxBytes, xmlText) => {
+    const estimate = bytes.subarray(0, 8).toString("ascii") === "bplist00"
+        ? estimateBinaryPlistExpansion(bytes, maxBytes)
+        : estimateXmlPlistExpansion(bytes, maxBytes, xmlText);
+    if (estimate > maxBytes)
+        throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "plist representation exceeds the aggregate Interface Builder decode budget");
+    return estimate;
+};
+const estimateXmlPlistExpansion = (bytes, maxBytes, xmlText) => {
+    const xml = xmlText ?? decodeXmlPlistText(bytes);
+    if (/<!DOCTYPE\b[^>]*\[/iu.test(xml))
+        throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "XML plist internal entity expansion exceeds the aggregate Interface Builder decode budget");
+    const elementPattern = /<!--[^]*?-->|<!\[CDATA\[[^]*?\]\]>|<!DOCTYPE[^>]*>|<\?[^]*?\?>|<\/?[A-Za-z][^>]*>/giu;
+    const decodedSourceBytes = xml.length * 2;
+    let elementCount = 0;
+    let xmlDepth = 0;
+    for (const match of xml.matchAll(elementPattern)) {
+        const token = match[0] ?? "";
+        if (token.startsWith("<!--") ||
+            token.startsWith("<![CDATA[") ||
+            token.startsWith("<!DOCTYPE") ||
+            token.startsWith("<?"))
+            continue;
+        elementCount += 1;
+        if (token.startsWith("</"))
+            xmlDepth -= 1;
+        else if (!token.endsWith("/>")) {
+            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)
+            return maxBytes + 1;
+    }
+    return decodedSourceBytes * 2 + elementCount * 128;
+};
+/** Count every expanded binary-plist reference before calling plist.parseBinary. */
+const estimateBinaryPlistExpansion = (bytes, maxBytes) => {
+    if (bytes.length < 40)
+        throw new TypeError("binary plist trailer is truncated");
+    const trailer = bytes.length - 32;
+    const offsetSize = bytes[trailer + 6] ?? 0;
+    const referenceSize = bytes[trailer + 7] ?? 0;
+    if (![1, 2, 4, 8].includes(offsetSize) ||
+        ![1, 2, 4, 8].includes(referenceSize))
+        throw new TypeError("binary plist trailer integer sizes are invalid");
+    const readInteger = (offset, size) => {
+        if (offset < 0 || size < 1 || offset + size > bytes.length)
+            return -1;
+        let value = 0;
+        for (let index = 0; index < size; index += 1)
+            value = value * 256 + (bytes[offset + index] ?? 0);
+        return Number.isSafeInteger(value) ? value : -1;
+    };
+    const objectCount = readInteger(trailer + 8, 8);
+    const topObject = readInteger(trailer + 16, 8);
+    const offsetTable = readInteger(trailer + 24, 8);
+    if (objectCount < 1 ||
+        topObject < 0 ||
+        topObject >= objectCount ||
+        offsetTable < 8 ||
+        offsetTable + objectCount * offsetSize > trailer)
+        throw new TypeError("binary plist trailer or object table is invalid");
+    let estimate = bytes.length * 2 + objectCount * 16;
+    if (estimate > maxBytes)
+        throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist object table exceeds the aggregate Interface Builder decode budget");
+    const active = new Set();
+    const pending = [
+        { object: topObject, depth: 0, exit: false },
+    ];
+    let pendingObjectCount = 1;
+    while (pending.length > 0) {
+        const entry = pending.pop();
+        if (entry === undefined)
+            break;
+        if (entry.exit) {
+            active.delete(entry.object);
+            continue;
+        }
+        pendingObjectCount -= 1;
+        if (entry.depth > 128)
+            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist nesting exceeds the aggregate Interface Builder decode budget");
+        if (active.has(entry.object))
+            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist reference cycle exceeds the aggregate Interface Builder decode budget");
+        estimate += 96;
+        if (estimate > maxBytes)
+            throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", "binary plist reference expansion exceeds the aggregate Interface Builder decode budget");
+        const offset = readInteger(offsetTable + entry.object * offsetSize, offsetSize);
+        if (offset < 8 || offset >= offsetTable)
+            throw new TypeError("binary plist object offset is invalid");
+        const marker = bytes[offset] ?? 0;
+        const type = marker >> 4;
+        let size = marker & 0x0f;
+        let cursor = offset + 1;
+        if (size === 0x0f && type !== 0 && type !== 8) {
+            const extMarker = bytes[cursor] ?? 0;
+            if (extMarker >> 4 !== 1 || (extMarker & 0x0f) > 3)
+                throw new TypeError("binary plist extended object size is invalid");
+            cursor += 1;
+            const integerSize = 1 << (extMarker & 0x0f);
+            size = readInteger(cursor, integerSize);
+            cursor += integerSize;
+            if (size < 0 || cursor > offsetTable)
+                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)
+                throw new TypeError("binary plist scalar object is truncated");
+            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");
+            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)
+            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");
+        active.add(entry.object);
+        pending.push({ object: entry.object, depth: entry.depth, exit: true });
+        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 });
+        }
+        pendingObjectCount += childCount;
+    }
+    return estimate;
+};

package/dist/artifacts/apple/KeyedArchiveReader.js

@@ -1,55 +1,73 @@
 import { createHash } from "node:crypto";
-import { TextDecoder } from "node:util";
+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 { createPlistNumberProjection } from "../../domain/apple/plistNumbers.js";
+import { binaryPlistNumberLiterals, xmlPlistNumberLiterals, } from "./PlistNumberLiterals.js";
 import { omittedPrototypeKeysLimitation, parseXmlPropertyList, } from "../../domain/propertyListKeys.js";
-import { keyedArchiveInputSchema, keyedArchiveResultSchema, projectKeyedArchive, } from "../../domain/apple/keyedArchive.js";
+import { KeyedArchiveKindError, keyedArchiveInputSchema, keyedArchiveResultSchema, projectKeyedArchive, } from "../../domain/apple/keyedArchive.js";
 import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
 import { ArtifactReaderFailure } from "../ArtifactReader.js";
+import { decodeXmlPlistText } from "../../domain/propertyListXmlText.js";
 const MAX_BYTES = 64 * 1024 * 1024;
 /** Parse inert plist bytes, preserving data and dates with explicit typed values. */
 export const decodeKeyedArchiveBytes = (bytes, selection) => {
     if (bytes.length > MAX_BYTES)
         throw new RangeError("Keyed archive exceeds 64 MiB");
+    if (bytes.subarray(0, 10).toString("ascii") === "NIBArchive")
+        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 }
-        : parseXmlPropertyList(decodeXmlPlistText(bytes));
+        : parseXmlPropertyList(xmlText ?? "");
     const graph = projectKeyedArchive(normalizePlist(parsed.value), selection);
+    const numbers = createPlistNumberProjection(binary
+        ? binaryPlistNumberLiterals(bytes)
+        : xmlPlistNumberLiterals(xmlText ?? ""));
+    // 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]) => [
+        name,
+        numbers.project(value),
+    ]));
+    const objects = graph.objects.map((object) => ({
+        ...object,
+        value: numbers.project(object.value),
+    }));
     return {
         archive_format: binary ? "binary-plist" : "xml-plist",
         ...graph,
+        roots,
+        objects,
         limitations: [
             ...graph.limitations,
+            ...numbers.limitations(),
             ...(parsed.omittedPrototypeKeys === 0
                 ? []
                 : [omittedPrototypeKeysLimitation(parsed.omittedPrototypeKeys)]),
         ],
     };
 };
-const decodeXmlPlistText = (bytes) => {
-    const encoding = bytes[0] === 0xff && bytes[1] === 0xfe
-        ? "utf-16le"
-        : bytes[0] === 0xfe && bytes[1] === 0xff
-            ? "utf-16be"
-            : "utf-8";
-    const text = new TextDecoder(encoding, { fatal: true }).decode(bytes);
-    const declared = /^<\?xml\s[^?]*\bencoding\s*=\s*["']([^"']+)["']/u
-        .exec(text)?.[1]
-        ?.toLowerCase();
-    if (declared !== undefined &&
-        ((encoding !== "utf-8" && declared !== encoding && declared !== "utf-16") ||
-            (encoding === "utf-8" && declared.startsWith("utf-16"))))
-        throw new TypeError("XML encoding declaration disagrees with its bytes");
-    return text;
-};
 const normalizePlist = (value) => {
     const projected = projectPlistValue(value);
     if (projected.unknownRealCount > 0)
         throw new RangeError("Keyed archive contains a non-finite real");
     return projected.value;
 };
+/**
+ * Point to the workflow that reads the selected kind of file on this host.
+ * decode_interface_builder is portable; inspect_plist requires macOS.
+ */
+const keyedArchiveKindRemediation = (kind, platform) => {
+    if (kind === "nib-archive")
+        return "Decode compiled NIBArchive files with decode_interface_builder on the app bundle.";
+    return platform === "darwin"
+        ? "Inspect an ordinary property list with inspect_plist; inspect_keyed_archive decodes NSKeyedArchiver archives only."
+        : "Select an NSKeyedArchiver archive; inspect_keyed_archive decodes only those. inspect_plist, which reads ordinary property lists, requires a macOS host.";
+};
 /** Read exactly one regular, contained bundle entry without following symlinks. */
 export const inspectBundleKeyedArchive = async (input) => {
     const selected = keyedArchiveInputSchema.parse(input.parameters);
@@ -57,14 +75,16 @@ export const inspectBundleKeyedArchive = async (input) => {
         selected.path
             .split("/")
             .some((part) => part === ".." || part === "." || part.length === 0))
-        throw new ArtifactReaderFailure("path", "Archive path must be a canonical relative bundle path");
+        throw archivePathError("invalid_format", selected.path === "."
+            ? "Select a keyed archive path relative to the active app bundle."
+            : `Archive path must be a canonical relative bundle path without empty, '.', or '..' segments: ${selected.path}`);
     const reader = new DirectoryArtifactReader(input.bundlePath);
     try {
         for await (const entry of reader.entries(input.signal)) {
             if (entry.path !== selected.path)
                 continue;
             if (entry.kind !== "file")
-                throw new ArtifactReaderFailure("path", "Archive must be a regular file, not a symlink or directory");
+                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);
@@ -93,12 +113,24 @@ export const inspectBundleKeyedArchive = async (input) => {
                 });
             }
             catch (cause) {
-                throw new ArtifactReaderFailure(cause instanceof RangeError ? "limit" : "format", "Cannot decode selected Foundation keyed archive", { cause });
+                if (cause instanceof AnalysisInputError)
+                    throw cause;
+                // An intact file of another kind is not a damaged archive.
+                if (cause instanceof KeyedArchiveKindError)
+                    throw new AnalysisUnsupportedTargetError("inspect_keyed_archive", join(input.bundlePath, entry.path), cause.message, {
+                        cause,
+                        remediationAction: keyedArchiveKindRemediation(cause.kind, input.platform ?? process.platform),
+                    });
+                throw new ArtifactReaderFailure(cause instanceof RangeError ? "limit" : "format", `Cannot decode selected Foundation keyed archive: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
             }
         }
-        throw new ArtifactReaderFailure("path", `Archive not found in bundle: ${selected.path}`);
+        throw archivePathError("invalid_value", `No regular file exists at ${selected.path} in the active app bundle.`);
     }
     finally {
         await reader.close();
     }
 };
+/** A caller-selected archive path, not the artifact, failed its constraint. */
+const archivePathError = (reason, message) => new AnalysisInputError("inspect_keyed_archive", undefined, [
+    { path: ["path"], reason, message },
+]);

package/dist/artifacts/apple/MachoLoadCommandReader.js

@@ -1,3 +1,4 @@
+import { readFatSliceDeclarations, validateFatSlice, } from "../../domain/apple/machoContainer.js";
 /** 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. */
@@ -23,6 +24,11 @@ const LC_LOAD_UPWARD_DYLIB = 0x80000023;
 const LC_RPATH = 0x8000001c;
 const LC_DYLD_ENVIRONMENT = 0x27;
 const LC_CODE_SIGNATURE = 0x1d;
+const LC_VERSION_MIN_MACOSX = 0x24;
+const LC_VERSION_MIN_IPHONEOS = 0x25;
+const LC_VERSION_MIN_TVOS = 0x2f;
+const LC_VERSION_MIN_WATCHOS = 0x30;
+const LC_BUILD_VERSION = 0x32;
 /** `mach-o/loader.h` `dylib_use_command`: `nameoff == 28` and this marker. */
 const DYLIB_USE_MARKER = 0x1a741800;
 const DYLIB_USE_WEAK_LINK = 0x1;
@@ -85,18 +91,35 @@ export const readMachoImage = async (readAt, size) => {
                 };
             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"));
+            const tableBytes = await readExact(readAt, 8, count * (wide ? 32 : 20), "FAT table");
+            const declarations = readFatSliceDeclarations(tableBytes, {
+                count,
+                wide,
+                littleEndian,
+            });
+            if (declarations.status !== "parsed")
+                throw new MachoFormatIssue("malformed", declarations.reason);
             // 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" };
+            if (!declarations.slices.some(({ cpuType }) => KNOWN_CPU_TYPES.includes(cpuType))) {
+                let hasMachOSliceHeader = false;
+                for (const declaration of declarations.slices) {
+                    if (validateFatSlice(declaration, size, 8 + count * (wide ? 32 : 20)) !== null)
+                        continue;
+                    const bytes = await readAt(declaration.offset, 4);
+                    if (bytes.byteLength < 4)
+                        continue;
+                    const sliceMagic = viewOf(bytes).getUint32(0, false);
+                    if ([MH_MAGIC, MH_MAGIC_64, MH_CIGAM, MH_CIGAM_64].includes(sliceMagic)) {
+                        hasMachOSliceHeader = true;
+                        break;
+                    }
+                }
+                if (!hasMachOSliceHeader)
+                    return { status: "not-mach-o" };
+            }
             return {
                 status: "parsed",
-                slices: await readFatSlices(readAt, size, {
-                    wide,
-                    littleEndian,
-                    count,
-                }),
+                slices: await readFatSlices(readAt, size, 8 + count * (wide ? 32 : 20), declarations.slices),
             };
         }
         if (magic === MH_CIGAM || magic === MH_CIGAM_64)
@@ -111,26 +134,29 @@ export const readMachoImage = async (readAt, size) => {
         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 readFatSlices = async (readAt, size, tableEnd, declarations) => {
     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));
+    for (const declaration of declarations) {
+        const { index, offset, size: length, cpuType, cpuSubtype } = declaration;
+        const rangeIssue = validateFatSlice(declaration, size, tableEnd);
+        if (rangeIssue !== null)
+            throw new MachoFormatIssue(rangeIssue.includes("unsupported") ? "unsupported" : "malformed", rangeIssue);
+        const slice = await readSlice(readAt, offset, length, {
+            fatCpuType: cpuType,
+            fatCpuSubtype: cpuSubtype,
+            alignmentExponent: declaration.alignmentExponent,
+        });
+        const identityIssue = validateFatSlice(declaration, size, tableEnd, {
+            cpuType: slice.cpu_type,
+            cpuSubtype: slice.cpu_subtype,
+        });
+        if (identityIssue !== null)
+            throw new MachoFormatIssue("malformed", identityIssue);
+        slices.push(slice);
     }
     return slices;
 };
-const readSlice = async (readAt, base, length) => {
+const readSlice = async (readAt, base, length, fat = null) => {
     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) {
@@ -143,13 +169,22 @@ const readSlice = async (readAt, base, length) => {
         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, {
+        const slice = decodeCommands(commands, {
             wide,
             cpuType: header.getUint32(4, true),
             cpuSubtype: header.getUint32(8, true),
             fileType: header.getUint32(12, true),
             commandCount,
+            sliceOffset: base,
+            sliceSize: length,
+            fatCpuType: fat?.fatCpuType ?? null,
+            fatCpuSubtype: fat?.fatCpuSubtype ?? null,
+            fatAlignmentExponent: fat?.alignmentExponent ?? null,
         });
+        const distinctPlatforms = [...new Set(slice.platforms)];
+        slice.platform =
+            distinctPlatforms.length === 1 ? (distinctPlatforms[0] ?? null) : null;
+        return slice;
     }
     throw new MachoFormatIssue(magic === swap(MH_MAGIC) || magic === swap(MH_MAGIC_64)
         ? "unsupported"
@@ -163,7 +198,17 @@ const decodeCommands = (bytes, header) => {
     const view = viewOf(bytes);
     const slice = {
         architecture: architectureName(header.cpuType, header.cpuSubtype),
+        slice_offset: header.sliceOffset,
+        slice_size: header.sliceSize,
+        cpu_type: header.cpuType,
+        cpu_subtype: header.cpuSubtype,
+        fat_cpu_type: header.fatCpuType,
+        fat_cpu_subtype: header.fatCpuSubtype,
+        fat_alignment_exponent: header.fatAlignmentExponent,
         file_type: fileTypeName(header.fileType),
+        file_type_code: header.fileType,
+        platform: null,
+        platforms: [],
         install_name: null,
         dependencies: [],
         rpaths: [],
@@ -182,6 +227,8 @@ const decodeCommands = (bytes, header) => {
         decodeCommand(command, body, index, slice);
         offset += size;
     }
+    if (offset !== bytes.byteLength)
+        throw new MachoFormatIssue("malformed", `load commands declare ${header.commandCount} commands but sizeofcmds holds ${bytes.byteLength} bytes`);
     return slice;
 };
 const decodeCommand = (command, body, index, slice) => {
@@ -204,6 +251,25 @@ const decodeCommand = (command, body, index, slice) => {
         slice.code_signature_present = true;
         return;
     }
+    if (command === LC_BUILD_VERSION) {
+        if (body.byteLength < 24)
+            throw new MachoFormatIssue("malformed", `load command ${index} is too short for LC_BUILD_VERSION`);
+        const platform = viewOf(body).getUint32(8, true);
+        slice.platforms.push(platform);
+        return;
+    }
+    const legacyPlatform = new Map([
+        [LC_VERSION_MIN_MACOSX, 1],
+        [LC_VERSION_MIN_IPHONEOS, 2],
+        [LC_VERSION_MIN_TVOS, 3],
+        [LC_VERSION_MIN_WATCHOS, 4],
+    ]).get(command);
+    if (legacyPlatform !== undefined) {
+        if (body.byteLength < 16)
+            throw new MachoFormatIssue("malformed", `load command ${index} is too short for a version-min command`);
+        slice.platforms.push(legacyPlatform);
+        return;
+    }
     const name = DEPENDENCY_COMMANDS.get(command);
     if (name !== undefined)
         slice.dependencies.push(decodeDependency(name, body, index));
@@ -286,9 +352,4 @@ const swap = (value) => (((value & 0xff) << 24) |
     ((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);