rea-agents 4.1.0 → 5.0.0

package/dist/artifacts/NativeDmgArtifactReader.js

@@ -13,21 +13,32 @@ const attachOutputSchema = z.object({
         "mount-point": z.string().optional(),
     })),
 });
+const infoOutputSchema = z.object({
+    images: z.array(z.object({
+        "system-entities": z.array(z.object({ "dev-entry": z.string() })),
+    })),
+});
 const systemHost = {
     async run(arguments_, signal, options) {
         try {
-            const { stdout } = await execFileOutput("/usr/bin/hdiutil", [...arguments_], {
+            const { stdout, stderr } = await execFileOutput("/usr/bin/hdiutil", [...arguments_], {
                 ...(options === undefined ? {} : { timeout: options.timeoutMs }),
                 ...(signal === undefined ? {} : { signal }),
             });
-            return { stdout, exitCode: 0 };
+            return { stdout, stderr, exitCode: 0 };
         }
         catch (cause) {
             if (cause instanceof Error && cause.name === "AbortError")
                 throw new ArtifactReaderFailure("cancelled", "DMG operation cancelled");
-            throw new ArtifactReaderFailure("format", "hdiutil rejected the DMG", {
-                cause,
-            });
+            const exitCode = processExitCode(cause);
+            if (exitCode !== undefined)
+                return {
+                    stdout: processOutput(cause, "stdout"),
+                    stderr: processOutput(cause, "stderr"),
+                    exitCode,
+                    cause,
+                };
+            throw new ArtifactReaderFailure(commandFailureReason(cause, arguments_[0]), `hdiutil ${arguments_[0] ?? "operation"} failed: ${describeCommandFailure(cause, arguments_)}`, { cause });
         }
     },
 };
@@ -77,7 +88,11 @@ export class NativeDmgArtifactReader {
                 this.#provenance.push(command(["detach", device], ["mount"]));
             }
             catch (cause) {
-                detachFailure ??= cause;
+                // Detaching a synthesized APFS container also ejects the image that
+                // backs it, so a later whole disk of the same image may already be
+                // gone. Only a device that is still attached is a cleanup failure.
+                if (await this.#isAttached(device))
+                    detachFailure ??= cause;
             }
         }
         this.#devices = [];
@@ -88,6 +103,23 @@ export class NativeDmgArtifactReader {
         if (detachFailure !== undefined)
             throw new ArtifactReaderFailure("unavailable", "DMG detach or mount-root cleanup failed", { cause: detachFailure });
     }
+    /**
+     * Report whether hdiutil still lists a device; unknown state counts as
+     * attached. Like detach, this cleanup query runs after the inventory
+     * snapshot has captured provenance, so it is not recorded there.
+     */
+    async #isAttached(device) {
+        try {
+            const info = await runChecked(this.host, ["info", "-plist"], undefined, {
+                timeoutMs: DETACH_TIMEOUT_MS,
+            });
+            const parsed = infoOutputSchema.parse(parse(info.stdout));
+            return parsed.images.some((image) => image["system-entities"].some((entity) => entity["dev-entry"] === device));
+        }
+        catch {
+            return true;
+        }
+    }
     async attach(signal) {
         await runChecked(this.host, ["verify", this.path], signal);
         this.#provenance.push(command(["verify", this.path], ["read"]));
@@ -143,11 +175,131 @@ export class NativeDmgArtifactReader {
     }
 }
 const runChecked = async (host, arguments_, signal, options) => {
-    const result = await host.run(arguments_, signal, options);
-    if (result.exitCode !== 0)
-        throw new ArtifactReaderFailure("unavailable", `hdiutil ${arguments_[0] ?? "operation"} failed with a non-zero exit code`);
+    let result;
+    try {
+        result = await host.run(arguments_, signal, options);
+    }
+    catch (cause) {
+        if (cause instanceof ArtifactReaderFailure)
+            throw cause;
+        if (cause instanceof Error && cause.name === "AbortError")
+            throw new ArtifactReaderFailure("cancelled", "DMG operation cancelled", {
+                cause,
+            });
+        throw new ArtifactReaderFailure(commandFailureReason(cause, arguments_[0]), `hdiutil ${arguments_[0] ?? "operation"} failed: ${describeCommandFailure(cause, arguments_)}`, { cause });
+    }
+    if (result.exitCode !== 0) {
+        const failure = {
+            command: "/usr/bin/hdiutil",
+            exitCode: result.exitCode,
+            ...(result.cause === undefined
+                ? {}
+                : { code: processExitCode(result.cause) }),
+            stdout: result.stdout,
+            ...(result.stderr === undefined ? {} : { stderr: result.stderr }),
+        };
+        const reason = commandFailureReason(failure, arguments_[0]);
+        const details = describeCommandFailure(failure, arguments_);
+        const unknownVerifyFailure = arguments_[0] === "verify" && reason === "unavailable";
+        throw new ArtifactReaderFailure(reason, unknownVerifyFailure
+            ? `hdiutil verify failed; captured diagnostics do not establish the failure cause: ${details}`
+            : `hdiutil ${arguments_[0] ?? "operation"} failed: ${details}`, result.cause === undefined ? undefined : { cause: result.cause });
+    }
     return { stdout: result.stdout, exitCode: 0 };
 };
+const describeCommandFailure = (cause, arguments_) => {
+    const fields = {
+        command: "/usr/bin/hdiutil",
+        arguments: [...arguments_],
+    };
+    if (typeof cause === "object" && cause !== null) {
+        for (const key of [
+            "code",
+            "exitCode",
+            "errno",
+            "syscall",
+            "signal",
+            "stdout",
+            "stderr",
+        ]) {
+            const value = Reflect.get(cause, key);
+            if (typeof value === "string" || typeof value === "number")
+                fields[key] = value;
+        }
+        const code = Reflect.get(cause, "code");
+        if (typeof code === "number")
+            fields.exitCode = code;
+    }
+    if (cause instanceof ArtifactReaderFailure)
+        fields.message = cause.message;
+    else if (cause instanceof Error)
+        fields.message = cause.message;
+    return JSON.stringify(fields);
+};
+const processExitCode = (cause) => {
+    if (typeof cause !== "object" || cause === null)
+        return undefined;
+    const exitCode = Reflect.get(cause, "exitCode");
+    if (typeof exitCode === "number")
+        return exitCode;
+    const code = Reflect.get(cause, "code");
+    return typeof code === "number" ? code : undefined;
+};
+const processOutput = (cause, field) => {
+    if (typeof cause !== "object" || cause === null)
+        return "";
+    const value = Reflect.get(cause, field);
+    return typeof value === "string" ? value : "";
+};
+const commandFailureReason = (cause, operation) => {
+    if (typeof cause !== "object" || cause === null)
+        return "unavailable";
+    const code = Reflect.get(cause, "code");
+    const exitCode = Reflect.get(cause, "exitCode");
+    if (typeof code === "number" || typeof exitCode === "number")
+        return operation === "verify" ? verifyFailureReason(cause) : "unavailable";
+    if (code === "ENOENT") {
+        const syscall = Reflect.get(cause, "syscall");
+        return typeof syscall === "string" && syscall.startsWith("spawn")
+            ? "unavailable"
+            : "io";
+    }
+    if (code === "EACCES" ||
+        code === "EPERM" ||
+        code === "EIO" ||
+        code === "ENOTDIR" ||
+        code === "EISDIR" ||
+        code === "ENODEV" ||
+        code === "EROFS" ||
+        code === "EMFILE" ||
+        code === "ENFILE")
+        return "io";
+    return "unavailable";
+};
+const verifyFailureReason = (cause) => {
+    const diagnostic = verifyFailureDiagnostic(processOutput(cause, "stdout"), processOutput(cause, "stderr"));
+    switch (diagnostic) {
+        case "image not recognized":
+            return "format";
+        case "invalid checksum":
+        case "image data corrupted":
+            return "integrity";
+        case "No such file or directory":
+        case "Permission denied":
+        case "Input/output error":
+            return "io";
+        default:
+            return "unavailable";
+    }
+};
+const verifyFailureDiagnostic = (stdout, stderr) => {
+    const prefix = "hdiutil: verify failed - ";
+    return `${stdout}\n${stderr}`
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find((line) => line.startsWith(prefix))
+        ?.slice(prefix.length);
+};
 const command = (arguments_, effects) => ({
     tool: "/usr/bin/hdiutil",
     arguments: [...arguments_],

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

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import { lstat } from "node:fs/promises";
-import { DirectoryArtifactReader } from "../artifacts/DirectoryArtifactReader.js";
-import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
+import { ArtifactReaderFailure } from "../ArtifactReader.js";
 import { analyzeInterfaceBuilderBundle } from "./InterfaceBuilderAnalysis.js";
-import { appleAssetCatalogInputSchema, parseAppleAssetCatalogRecords, projectAppleAssetCatalogPage, } from "../domain/appleAssetCatalog.js";
-import { execFileOutput } from "../process/ExecFileOutput.js";
+import { appleAssetCatalogInputSchema, parseAppleAssetCatalogRecords, projectAppleAssetCatalogPage, } from "../../domain/apple/appleAssetCatalog.js";
+import { execFileOutput } from "../../process/ExecFileOutput.js";
 const ASSETUTIL = "/usr/bin/assetutil";
 const MAX_CATALOG_BYTES = 64 * 1024 * 1024;
 const MAX_TOTAL_METADATA_BYTES = 64 * 1024 * 1024;

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) => {