rea-agents 4.1.0 → 6.0.0

package/dist/{application → artifacts/apple}/InterfaceBuilderAnalysis.js

@@ -1,9 +1,12 @@
 import { createHash } from "node:crypto";
-import { parse, parseBinary } from "plist";
-import { DirectoryArtifactReader } from "../artifacts/DirectoryArtifactReader.js";
-import { decodeNibArchive, } from "../artifacts/NibArchive.js";
-import { buildInterfaceBuilderAnalysis, interfaceBuilderLimitsSchema, } from "../domain/interfaceBuilderGraph.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
+import { parseBinary } from "plist";
+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 { buildInterfaceBuilderAnalysis, interfaceBuilderLimitsSchema, } from "../../domain/apple/interfaceBuilderGraph.js";
+import { mergeNibHierarchies, projectNibViewHierarchy, } from "./NibViewHierarchy.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
 const MAX_DOCUMENT_BYTES = 64 * 1024 * 1024;
 /** Decode compiled Interface Builder archives from a local app bundle. */
 export const analyzeInterfaceBuilderBundle = async (input) => {
@@ -11,6 +14,8 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
     const reader = new DirectoryArtifactReader(input.bundlePath);
     const documents = [];
     const invalid = [];
+    const incompleteHierarchies = new Map();
+    const prototypeKeyOmissions = new Map();
     let omitted = 0;
     let attempted = 0;
     try {
@@ -24,9 +29,16 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
             attempted += 1;
             try {
                 const bytes = await readEntry(reader, entry, input.signal);
-                const raw = bytes.subarray(0, 10).toString("ascii") === "NIBArchive"
+                const nib = bytes.subarray(0, 10).toString("ascii") === "NIBArchive"
                     ? projectNibArchive(decodeNibArchive(bytes))
-                    : decodePlist(bytes);
+                    : null;
+                const { value: raw, omittedPrototypeKeys } = nib === null
+                    ? decodePlist(bytes)
+                    : { value: nib.raw, omittedPrototypeKeys: 0 };
+                if (nib !== null && nib.omitted > 0)
+                    incompleteHierarchies.set(entry.path, nib.omitted);
+                if (omittedPrototypeKeys > 0)
+                    prototypeKeyOmissions.set(entry.path, omittedPrototypeKeys);
                 const documentHash = createHash("sha256").update(bytes).digest("hex");
                 documents.push({
                     relativePath: entry.path,
@@ -53,30 +65,71 @@ export const analyzeInterfaceBuilderBundle = async (input) => {
         documents,
         limits,
     });
+    return finalizeHierarchyCoverage(result, {
+        incompleteHierarchies,
+        prototypeKeyOmissions,
+        invalid,
+        attempted,
+        omitted,
+    });
+};
+const finalizeHierarchyCoverage = (result, counts) => {
+    const { incompleteHierarchies, prototypeKeyOmissions, invalid } = counts;
+    const archiveDecodePartial = invalid.length > 0 || prototypeKeyOmissions.size > 0;
     return {
         ...result,
+        documents: result.documents.map((document) => ({
+            ...document,
+            hierarchy_complete: document.hierarchy_complete &&
+                !incompleteHierarchies.has(document.relative_path),
+        })),
         graph: {
             ...result.graph,
             coverage: [
-                ...result.graph.coverage,
+                ...result.graph.coverage.map((facet) => {
+                    const omitted = incompleteHierarchies.get(facet.facet.replace(/^hierarchy:/u, ""));
+                    return facet.facet.startsWith("hierarchy:") && omitted !== undefined
+                        ? {
+                            ...facet,
+                            status: "partial",
+                            reason: "serialized_view_hierarchy_incomplete",
+                            omitted: facet.omitted + omitted,
+                        }
+                        : facet;
+                }),
                 {
                     facet: "archive_decode",
-                    status: invalid.length > 0 ? "partial" : "complete",
-                    reason: invalid.length > 0 ? "one_or_more_archives_invalid" : null,
-                    examined: attempted,
-                    omitted,
+                    status: archiveDecodePartial
+                        ? "partial"
+                        : "complete",
+                    reason: invalid.length > 0
+                        ? "one_or_more_archives_invalid"
+                        : prototypeKeyOmissions.size > 0
+                            ? "dictionary_entries_omitted"
+                            : null,
+                    examined: counts.attempted,
+                    omitted: counts.omitted,
                 },
             ],
-            truncated: result.graph.truncated || omitted > 0 || invalid.length > 0,
+            truncated: result.graph.truncated ||
+                counts.omitted > 0 ||
+                archiveDecodePartial ||
+                incompleteHierarchies.size > 0,
         },
         limitations: [
             ...result.limitations,
             "Compiled Interface Builder archives are private serialized object graphs. The decoder reports only recognized keyed-archive objects and connections; unrecognized object classes and fields remain unknown.",
+            ...(incompleteHierarchies.size === 0
+                ? []
+                : [
+                    "Some serialized hierarchy links could not be projected within the bounded hierarchy; their parentage remains unknown.",
+                ]),
             ...(invalid.length === 0
                 ? []
                 : [
                     `Some Interface Builder archives could not be decoded: ${invalid.slice(0, 16).join("; ")}`,
                 ]),
+            ...[...prototypeKeyOmissions].map(([path, count]) => `${path}: ${omittedPrototypeKeysLimitation(count)}`),
         ],
     };
 };
@@ -124,14 +177,16 @@ const projectNibArchive = (archive) => {
         if (object === undefined)
             return null;
         const storedClass = object.class_name.replace(/\0+$/u, "");
-        return storedClass === "NSClassSwapper"
-            ? (referencedString(object.values.NSClassName) ?? storedClass)
+        if (storedClass === "NSClassSwapper")
+            return referencedString(object.values.NSClassName) ?? storedClass;
+        return storedClass === "UIClassSwapper"
+            ? (referencedString(object.values.UIClassName) ?? storedClass)
             : storedClass;
     };
     const objects = Object.fromEntries(archive.objects
         .filter((object) => {
         const name = runtimeClass(object.id) ?? "";
-        return !/^(?:NSObject|NSIBObjectData|NSString|NSMutableString|NSNumber|NSArray|NSMutableArray|NSSet|NSMutableSet|NSDictionary|NSMutableDictionary|NSApplication|NSNib.*Connector)$/u.test(name);
+        return !/^(?:NSObject|NSIBObjectData|NSString|NSMutableString|NSNumber|NSArray|NSMutableArray|NSSet|NSMutableSet|NSDictionary|NSMutableDictionary|NSApplication|NSNib.*Connector|UIRuntime\w*Connection)$/u.test(name);
     })
         .map((object) => {
         const className = runtimeClass(object.id) ?? object.class_name.replace(/\0+$/u, "");
@@ -164,35 +219,46 @@ const projectNibArchive = (archive) => {
     };
     for (const object of archive.objects) {
         const className = object.class_name.replace(/\0+$/u, "");
-        const source = reference(object.values.NSSource);
-        const destination = reference(object.values.NSDestination);
-        if (className.includes("Connector") && source !== null) {
-            const label = referencedString(object.values.NSLabel);
-            const type = className.includes("Outlet")
-                ? "outlet"
-                : className.includes("Control")
-                    ? "action"
-                    : className;
-            const controlAction = className.includes("Control");
-            const connectionSource = controlAction ? destination : source;
-            const connectionDestination = controlAction ? source : destination;
-            if (connectionSource === null)
-                continue;
-            (connections[String(connectionSource)] ??= []).push({
-                type,
-                "destination-id": connectionDestination === null ? null : String(connectionDestination),
-                label,
-                source_id: String(connectionSource),
-                archive_object_id: String(object.id),
-            });
-        }
+        // AppKit connectors use NS-prefixed keys; UIKit's runtime outlet and
+        // event connections use UI-prefixed keys with the same roles.
+        const uiKit = /^UIRuntime\w*Connection$/u.test(className);
+        if (!uiKit && !className.includes("Connector"))
+            continue;
+        const values = object.values;
+        const source = reference(uiKit ? values.UISource : values.NSSource);
+        if (source === null)
+            continue;
+        const destination = reference(uiKit ? values.UIDestination : values.NSDestination);
+        const label = referencedString(uiKit ? values.UILabel : values.NSLabel);
+        const type = className.includes("Outlet")
+            ? "outlet"
+            : className.includes("Control") || className.includes("Event")
+                ? "action"
+                : className;
+        const eventMask = values.UIEventMask;
+        // The source is the outlet owner or the sending control; the destination
+        // is the outlet value or the action target, and a nil target is the
+        // first responder.
+        (connections[String(source)] ??= []).push({
+            type,
+            "destination-id": destination === null ? null : String(destination),
+            label,
+            source_id: String(source),
+            archive_object_id: String(object.id),
+            ...(typeof eventMask === "number" ? { ui_event_mask: eventMask } : {}),
+        });
     }
+    let hierarchyOmitted = 0;
     const hierarchyFor = (objectId, seen, depth) => {
-        if (depth > 32 || seen.has(objectId))
+        if (depth > 32 || seen.has(objectId)) {
+            hierarchyOmitted += 1;
             return null;
+        }
         const object = byId.get(objectId);
-        if (object === undefined)
+        if (object === undefined) {
+            hierarchyOmitted += 1;
             return null;
+        }
         const nextSeen = new Set(seen).add(objectId);
         const children = [];
         for (const [key, value] of Object.entries(object.values)) {
@@ -202,8 +268,10 @@ const projectNibArchive = (archive) => {
             if (direct === null)
                 continue;
             const target = byId.get(direct);
-            if (target === undefined)
+            if (target === undefined) {
+                hierarchyOmitted += 1;
                 continue;
+            }
             if (/array|set/iu.test(target.class_name)) {
                 for (const candidate of Object.values(target.values)) {
                     const child = reference(candidate);
@@ -228,12 +296,17 @@ const projectNibArchive = (archive) => {
         if (root !== null)
             hierarchy.push(root);
     }
-    return jsonValueSchema.parse({
-        "com.apple.ibtool.document.objects": objects,
-        "com.apple.ibtool.document.connections": connections,
-        "com.apple.ibtool.document.hierarchy": hierarchy,
-        "com.apple.ibtool.document.classes": Object.fromEntries(archive.classes.map((name) => [name.replace(/\0+$/u, ""), {}])),
-    });
+    const viewHierarchy = projectNibViewHierarchy(archive.objects, new Set(Object.keys(objects).map(Number)));
+    const merged = mergeNibHierarchies(hierarchy, viewHierarchy.hierarchy ?? []);
+    return {
+        omitted: viewHierarchy.omitted + hierarchyOmitted + merged.omitted,
+        raw: jsonValueSchema.parse({
+            "com.apple.ibtool.document.objects": objects,
+            "com.apple.ibtool.document.connections": connections,
+            "com.apple.ibtool.document.hierarchy": merged.hierarchy,
+            "com.apple.ibtool.document.classes": Object.fromEntries(archive.classes.map((name) => [name.replace(/\0+$/u, ""), {}])),
+        }),
+    };
 };
 const isInterfaceBuilderArchive = (path) => {
     const lower = path.toLowerCase();
@@ -258,9 +331,10 @@ const readEntry = async (reader, entry, signal) => {
     }
     return Buffer.concat(chunks, length);
 };
+/** Project decoded plist data and dates while retaining omitted-key coverage. */
 const decodePlist = (bytes) => {
-    const parsed = bytes.subarray(0, 8).toString("ascii") === "bplist00"
-        ? parseBinary(bytes)
-        : parse(bytes.toString("utf8"));
-    return jsonValueSchema.parse(parsed);
+    const { value, omittedPrototypeKeys } = bytes.subarray(0, 8).toString("ascii") === "bplist00"
+        ? { value: parseBinary(bytes), omittedPrototypeKeys: 0 }
+        : parseXmlPropertyList(bytes.toString("utf8"));
+    return { value: projectPlistValue(value).value, omittedPrototypeKeys };
 };

package/dist/artifacts/{KeyedArchiveReader.js → apple/KeyedArchiveReader.js}

@@ -1,10 +1,12 @@
 import { createHash } from "node:crypto";
 import { TextDecoder } from "node:util";
-import { parse, parseBinary } from "plist";
+import { parseBinary } from "plist";
 import { z } from "zod";
-import { keyedArchiveInputSchema, keyedArchiveResultSchema, projectKeyedArchive, } from "../domain/keyedArchive.js";
-import { DirectoryArtifactReader } from "./DirectoryArtifactReader.js";
-import { ArtifactReaderFailure } from "./ArtifactReader.js";
+import { projectPlistValue } from "../../domain/apple/plistValue.js";
+import { omittedPrototypeKeysLimitation, parseXmlPropertyList, } from "../../domain/propertyListKeys.js";
+import { keyedArchiveInputSchema, keyedArchiveResultSchema, projectKeyedArchive, } from "../../domain/apple/keyedArchive.js";
+import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
+import { ArtifactReaderFailure } from "../ArtifactReader.js";
 const MAX_BYTES = 64 * 1024 * 1024;
 /** Parse inert plist bytes, preserving data and dates with explicit typed values. */
 export const decodeKeyedArchiveBytes = (bytes, selection) => {
@@ -12,11 +14,18 @@ export const decodeKeyedArchiveBytes = (bytes, selection) => {
         throw new RangeError("Keyed archive exceeds 64 MiB");
     const binary = bytes.subarray(0, 8).toString("ascii") === "bplist00";
     const parsed = binary
-        ? parseBinary(bytes)
-        : parse(decodeXmlPlistText(bytes));
+        ? { value: parseBinary(bytes), omittedPrototypeKeys: 0 }
+        : parseXmlPropertyList(decodeXmlPlistText(bytes));
+    const graph = projectKeyedArchive(normalizePlist(parsed.value), selection);
     return {
         archive_format: binary ? "binary-plist" : "xml-plist",
-        ...projectKeyedArchive(normalizePlist(parsed), selection),
+        ...graph,
+        limitations: [
+            ...graph.limitations,
+            ...(parsed.omittedPrototypeKeys === 0
+                ? []
+                : [omittedPrototypeKeysLimitation(parsed.omittedPrototypeKeys)]),
+        ],
     };
 };
 const decodeXmlPlistText = (bytes) => {
@@ -35,26 +44,11 @@ const decodeXmlPlistText = (bytes) => {
         throw new TypeError("XML encoding declaration disagrees with its bytes");
     return text;
 };
-const normalizePlist = (value, depth = 0) => {
-    if (depth > 128)
-        throw new RangeError("Plist exceeds 128 nesting levels");
-    if (value instanceof Uint8Array)
-        return {
-            $plist_type: "data",
-            base64: Buffer.from(value).toString("base64"),
-        };
-    if (value instanceof Date)
-        return { $plist_type: "date", iso8601: value.toISOString() };
-    if (Array.isArray(value))
-        return value.map((item) => normalizePlist(item, depth + 1));
-    if (value !== null && typeof value === "object")
-        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-            key,
-            normalizePlist(item, depth + 1),
-        ]));
-    return z
-        .union([z.string(), z.number().finite(), z.boolean(), z.null()])
-        .parse(value);
+const normalizePlist = (value) => {
+    const projected = projectPlistValue(value);
+    if (projected.unknownRealCount > 0)
+        throw new RangeError("Keyed archive contains a non-finite real");
+    return projected.value;
 };
 /** Read exactly one regular, contained bundle entry without following symlinks. */
 export const inspectBundleKeyedArchive = async (input) => {

package/dist/artifacts/apple/MachoLoadCommandReader.js

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