rea-agents 6.5.0 → 6.7.0

package/dist/domain/native/objcSwiftMetadata.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
+import { isMachOFormat } from "../binaryTargetTypes.js";
 import { providerSchema } from "../evidence.js";
 import { isSwiftMangledSymbolName } from "../swiftSymbolClassification.js";
 import { compareUnicodeCodePoints, compositeKey, } from "../unicodeCodePointOrder.js";
+/** Targets admitted to the Apple byte reader; the reader validates slice support. */
+export const isAppleDispatchMetadataTarget = (target) => target.kind === "executable" && isMachOFormat(target.format);
 /** Objective-C method type. */
 export const objcMethodTypeSchema = z.enum([
     "instance",
@@ -99,6 +102,8 @@ export const nativeMetadataEvidenceSchema = z.strictObject({
     description: z.string().min(1),
     provider: providerSchema.optional(),
     location: nativeMetadataLocationSchema,
+    /** Preserve a provider's source value when it does not establish a location. */
+    reported_address: z.string().optional(),
     artifact_path: z.string().min(1).nullable().default(null),
     artifact_sha256: z
         .string()
@@ -190,7 +195,7 @@ export const relativePointerSchema = z.strictObject({
 /** A raw Swift-mangled symbol when a provider has not decoded its metadata. */
 export const swiftSymbolSchema = z.strictObject({
     mangled_name: z.string().min(1),
-    address: z.string().min(1),
+    address: z.string().min(1).nullable(),
     decode: nativeMetadataDecodeSchema,
     evidence: z.array(nativeMetadataEvidenceSchema).min(1),
 });
@@ -287,11 +292,12 @@ export const nativeDispatchMetadataResultSchema = z.strictObject({
 });
 /** Decode only facts visible in a provider's existing name inventory. */
 export const inspectNativeDispatchMetadata = (names, maxRecords = 5_000) => {
-    const symbolEvidence = (name, address) => [
+    const symbolEvidence = (entry, address) => [
         {
             kind: "symbol",
-            description: `Provider symbol ${name}`,
+            description: `Provider symbol ${entry.name}`,
             location: { address, file_offset: null },
+            ...(address === null ? { reported_address: entry.address } : {}),
             artifact_path: null,
             artifact_sha256: null,
         },
@@ -301,6 +307,7 @@ export const inspectNativeDispatchMetadata = (names, maxRecords = 5_000) => {
     const swiftSymbols = [];
     const examinedNames = names.slice(0, maxRecords);
     for (const entry of examinedNames) {
+        const address = entry.address === "" ? null : entry.address;
         const classMatch = /(?:OBJC_CLASS_|OBJC_METACLASS_)\$_([^\s]+)/u.exec(entry.name);
         if (classMatch?.[1] !== undefined)
             classNames.add(classMatch[1]);
@@ -312,19 +319,19 @@ export const inspectNativeDispatchMetadata = (names, maxRecords = 5_000) => {
                 class_name: methodMatch[2],
                 selector,
                 method_type: methodType,
-                implementation_address: entry.address,
-                location: { address: entry.address, file_offset: null },
+                implementation_address: address,
+                location: { address, file_offset: null },
                 decode: { status: "partial", reason: "symbol_name_only" },
-                evidence: symbolEvidence(entry.name, entry.address),
+                evidence: symbolEvidence(entry, address),
             });
             classNames.add(methodMatch[2]);
         }
         if (isSwiftMangledSymbolName(entry.name) || entry.name.startsWith("_Tt"))
             swiftSymbols.push({
                 mangled_name: entry.name,
-                address: entry.address,
+                address,
                 decode: { status: "partial", reason: "mangled_symbol_not_demangled" },
-                evidence: symbolEvidence(entry.name, entry.address),
+                evidence: symbolEvidence(entry, address),
             });
     }
     const methodsByClass = new Map();

package/dist/domain/native/peResources.js

@@ -11,6 +11,10 @@ const identity = z.discriminatedUnion("kind", [
         location: range,
     }),
 ]);
+/** Hard ceiling on the caller-selected input read budget. */
+export const MAX_INSPECT_PE_FILE_BYTES = 536870912;
+/** Hard ceiling on the caller-selected resource-directory-entry budget. */
+export const MAX_INSPECT_PE_DIRECTORY_ENTRIES = 65536;
 /** Complete bounded inspection of a caller-selected PE image, without execution. */
 export const inspectPeResourcesInputSchema = z.strictObject({
     path: localPathStringSchema.describe("Absolute filesystem path to a PE image"),
@@ -18,7 +22,7 @@ export const inspectPeResourcesInputSchema = z.strictObject({
         .number()
         .int()
         .min(64)
-        .max(536870912)
+        .max(MAX_INSPECT_PE_FILE_BYTES)
         .default(67108864)
         .describe("Maximum stable artifact bytes to read (default 64 MiB)"),
     // Windows resource images carry thousands of entries: Windows 11 25H2
@@ -30,7 +34,7 @@ export const inspectPeResourcesInputSchema = z.strictObject({
         .number()
         .int()
         .min(1)
-        .max(65536)
+        .max(MAX_INSPECT_PE_DIRECTORY_ENTRIES)
         .default(16384)
         .describe("Maximum resource directory entries to examine; exceeding the budget fails without partial success"),
 });

package/dist/domain/peMachine.js

@@ -13,6 +13,8 @@ const architectureForMachine = (machine) => {
     }
     return undefined;
 };
+/** The optional-header magic a machine's architecture requires: PE32+ for 64-bit, PE32 otherwise. */
+export const peOptionalHeaderMagic = (architecture) => architecture === "x86_64" || architecture === "arm64" ? 0x20b : 0x10b;
 /**
  * ReadyToRun images compiled for a non-Windows OS store the COFF machine XORed
  * with IMAGE_FILE_MACHINE_NATIVE_OS_OVERRIDE (dotnet/runtime

package/dist/domain/process/processComparison.js

@@ -226,7 +226,8 @@ const applyTraceVerdict = (dimensions, specification, trace, captures) => {
     const sources = new Set(specification.events.map(({ source }) => source));
     const covered = dimensionsForTraceSources(sources);
     // A different verdict names the failing events and observations; attribute
-    // it only to their dimensions so equal observations keep their exact status.
+    // it only to their dimensions; unrelated comparisons keep their own status,
+    // including unknown coverage and independently observed additions/removals.
     const diagnosticSources = new Set([
         ...specification.events
             .filter(({ id }) => trace.diagnostic?.event_ids.includes(id) === true)
@@ -243,8 +244,7 @@ const applyTraceVerdict = (dimensions, specification, trace, captures) => {
         if (trace.verdict === "nonconforming")
             return exact;
         if (trace.verdict === "different")
-            return traceShowsDifference &&
-                (exact !== "unchanged" || attributed.has(dimension))
+            return traceShowsDifference && attributed.has(dimension)
                 ? "changed"
                 : exact;
         if (trace.verdict === "unknown" &&

package/dist/domain/process/processTraceDimensionProjection.js

@@ -28,7 +28,7 @@ export const traceCoversObservedDimension = (dimension, sources, left, right) =>
         case "exit":
             return sources.has("lifecycle");
         case "filesystem":
-            return false;
+            return sources.has("filesystem");
         case "process":
             return sources.has("process");
     }

package/dist/domain/process/processTraceEvaluation.js

@@ -75,29 +75,67 @@ const failure = (input) => ({
         locations: [...input.locations],
     },
 });
-const evaluateFiniteTrace = (ids, specification) => {
-    if (specification.language.kind !== "finite_traces")
-        return null;
-    for (const variant of specification.language.variants) {
+/** Match variants once, retaining the best-prefix mismatch for attribution. */
+const evaluateFiniteTrace = (ids, language) => {
+    let bestPrefix = -1;
+    const bestEventIds = new Set();
+    const bestLocationIndexes = new Set();
+    const recordMismatch = (offset, missing, unexpected) => {
+        if (offset > bestPrefix) {
+            bestPrefix = offset;
+            bestEventIds.clear();
+            bestLocationIndexes.clear();
+        }
+        if (offset !== bestPrefix)
+            return;
+        for (const eventId of missing)
+            bestEventIds.add(eventId);
+        for (const { id, index } of unexpected) {
+            bestEventIds.add(id);
+            bestLocationIndexes.add(index);
+        }
+    };
+    for (const variant of language.variants) {
         let offset = 0;
-        let accepted = true;
+        let mismatched = false;
         for (const token of variant.trace) {
-            if (typeof token === "string") {
-                if (ids[offset] !== token)
-                    accepted = false;
-                offset += 1;
-                continue;
+            const expected = typeof token === "string" ? [token] : token.unordered;
+            const actual = ids.slice(offset, offset + expected.length);
+            const remaining = new Map();
+            for (const eventId of expected)
+                remaining.set(eventId, (remaining.get(eventId) ?? 0) + 1);
+            const unexpected = [];
+            for (const [index, eventId] of actual.entries()) {
+                const count = remaining.get(eventId) ?? 0;
+                if (count === 0)
+                    unexpected.push({ id: eventId, index: offset + index });
+                else if (count === 1)
+                    remaining.delete(eventId);
+                else
+                    remaining.set(eventId, count - 1);
+            }
+            const missing = [...remaining].flatMap(([eventId, count]) => Array.from({ length: count }, () => eventId));
+            if (missing.length > 0 ||
+                unexpected.length > 0 ||
+                actual.length < expected.length) {
+                recordMismatch(offset, missing, unexpected);
+                mismatched = true;
+                break;
             }
-            const actual = ids.slice(offset, offset + token.unordered.length).sort();
-            const expected = [...token.unordered].sort();
-            if (canonicalTraceJson(actual) !== canonicalTraceJson(expected))
-                accepted = false;
-            offset += token.unordered.length;
+            offset += expected.length;
         }
-        if (accepted && offset === ids.length)
-            return variant.id;
+        if (mismatched)
+            continue;
+        if (offset === ids.length)
+            return { status: "pass", variant: variant.id };
+        const unexpected = ids[offset];
+        recordMismatch(offset, [], unexpected === undefined ? [] : [{ id: unexpected, index: offset }]);
     }
-    return null;
+    return {
+        status: "fail",
+        eventIds: [...bestEventIds],
+        locationIndexes: [...bestLocationIndexes],
+    };
 };
 const collectRecords = (capture, sources) => {
     const records = [];
@@ -278,20 +316,23 @@ const evaluateMatchedTrace = (trace, specification) => {
     if (specification.language.kind === "partial_order")
         return evaluatePartialOrder(trace, specification.language);
     const ids = trace.rawTrace.map(({ event_id }) => event_id);
-    const variant = evaluateFiniteTrace(ids, specification);
-    return variant === null
+    const evaluation = evaluateFiniteTrace(ids, specification.language);
+    return evaluation.status === "fail"
         ? failure({
             kind: "trace",
             message: "Observed events do not match any finite trace variant.",
-            eventIds: ids,
-            locations: trace.rawTrace.map(({ location }) => location),
+            eventIds: evaluation.eventIds,
+            locations: evaluation.locationIndexes.flatMap((index) => {
+                const location = trace.rawTrace[index]?.location;
+                return location === undefined ? [] : [location];
+            }),
             rawTrace: trace.rawTrace,
         })
         : {
             result: {
                 status: "pass",
-                matched_variant: variant,
-                satisfied_constraints: [`variant:${variant}`],
+                matched_variant: evaluation.variant,
+                satisfied_constraints: [`variant:${evaluation.variant}`],
                 raw_trace: trace.rawTrace,
             },
             diagnostic: null,

package/dist/domain/propertyListKeys.js

@@ -1,13 +1,17 @@
-import { DOMParser, normalizeLineEndings, } from "@xmldom/xmldom";
-import { parse } from "plist";
+import { normalizeLineEndings } from "@xmldom/xmldom";
+import { parseOpenStep } from "plist";
+import { decodeXmlPropertyList } from "./propertyListXml.js";
+import { UnknownPlistReal, createPlistNumberCollector, } from "./apple/plistNumbers.js";
 import { MAX_PLIST_DEPTH } from "./apple/plistValue.js";
+import { parseXmlDocument } from "./xmlDocument.js";
 /** The dictionary key REA results cannot carry: validation strips it. */
 const PROTOTYPE_KEY = "__proto__";
 /** Limitation for results whose source plist held `__proto__` entries. */
 export const omittedPrototypeKeysLimitation = (count) => count === null
     ? "Dictionary entries keyed __proto__ were omitted because REA results cannot represent that key."
     : `${String(count)} dictionary ${count === 1 ? "entry" : "entries"} keyed __proto__ ${count === 1 ? "was" : "were"} omitted because REA results cannot represent that key.`;
-const withoutKey = (value, key) => {
+/** Remove own `__proto__` entries, such as JSON.parse creates, and count them. */
+export const omitPrototypeKeys = (value) => {
     let omitted = 0;
     const strip = (item) => {
         if (Array.isArray(item))
@@ -15,10 +19,11 @@ const withoutKey = (value, key) => {
         if (item === null ||
             typeof item !== "object" ||
             item instanceof Date ||
-            item instanceof Uint8Array)
+            item instanceof Uint8Array ||
+            item instanceof UnknownPlistReal)
             return item;
         return Object.fromEntries(Object.entries(item).flatMap(([name, entry]) => {
-            if (name !== key)
+            if (name !== PROTOTYPE_KEY)
                 return [[name, strip(entry)]];
             omitted += 1;
             return [];
@@ -27,8 +32,6 @@ const withoutKey = (value, key) => {
     const stripped = strip(value);
     return { value: stripped, omittedPrototypeKeys: omitted };
 };
-/** Remove own `__proto__` entries, such as JSON.parse creates, and count them. */
-export const omitPrototypeKeys = (value) => withoutKey(value, PROTOTYPE_KEY);
 const XML_ENTITIES = {
     amp: "&",
     apos: "'",
@@ -49,32 +52,48 @@ export const decodeXmlText = (text) => text.replace(/&(?:#x([\da-f]+)|#(\d+)|([a
             : undefined;
     if (codePoint !== undefined)
         return codePoint <= 0x10ffff ? String.fromCodePoint(codePoint) : entity;
-    return (name === undefined ? undefined : XML_ENTITIES[name]) ?? entity;
+    return name !== undefined && Object.hasOwn(XML_ENTITIES, name)
+        ? XML_ENTITIES[name]
+        : entity;
 });
 /**
- * Decode an XML plist whose dictionaries may use the legal key `__proto__`,
- * which the `plist` decoder rejects outright. Those entries are omitted and
- * counted so callers can report them instead of failing the whole document.
+ * Decode one validated XML DOM into values and numeric source facts.
+ * Entries keyed `__proto__` are omitted and counted at the same boundary.
  */
 export const parseXmlPropertyList = (text) => {
     // Preserve the pinned decoder's existing OpenStep autodetection, also used
-    // by app Info.plist resolution. Only XML needs the key-element substitution.
+    // by app Info.plist resolution.
     const first = text.trimStart()[0];
     if (first === "{" || first === "(") {
-        assertOpenStepDepthWithinLimit(text);
-        return omitPrototypeKeys(parse(text));
+        // The pinned decoder assigns a `__proto__` key to the object prototype, so
+        // the entry is gone before the decoded value can be counted. Count keys in
+        // the source instead; the rebuild still drops any prototype it replaced.
+        const prototypeKeys = scanOpenStep(text);
+        return {
+            value: omitPrototypeKeys(parseOpenStep(text)).value,
+            numberLiterals: createPlistNumberCollector().result(true),
+            omittedPrototypeKeys: prototypeKeys,
+        };
     }
     // Normalize only the literal line endings the pinned decoder normalizes.
-    // Preserve character references in the source: serializing a DOM would turn
-    // e.g. an encoded carriage return into a literal newline on the second parse.
+    // Decode this DOM directly so character references are never reserialized
+    // into literal line endings and normalized a second time.
     const normalized = normalizeLineEndings(text);
-    // The pinned XML parser is iterative. Reuse its document for the depth
-    // preflight and key lookup so quoted attributes and declarations have the
-    // same meaning at both boundaries, before plist's recursive value decode.
-    const document = new DOMParser().parseFromString(normalized, "text/xml");
+    // Strict syntax owns well-formedness before value interpretation. Reuse the
+    // same DOM for depth, keys, values and number facts.
+    const parsed = parseXmlDocument(normalized, {
+        doctype: "allow",
+        lineEndings: "preserve",
+    });
+    if (!parsed.ok)
+        throw parsed.error;
+    const document = parsed.value;
     assertXmlPlistDepthWithinLimit(document);
-    const { substituted, placeholder } = substitutePrototypeKeys(normalized, document);
-    return withoutKey(parse(substituted), placeholder);
+    const decoded = decodeXmlPropertyList(document);
+    return {
+        ...omitPrototypeKeys(decoded.value),
+        numberLiterals: decoded.numberLiterals,
+    };
 };
 /** Consume only the punctuation expected between the pinned decoder's values. */
 const consumeOpenStepSeparator = (parent, character) => {
@@ -93,8 +112,12 @@ const consumeOpenStepSeparator = (parent, character) => {
 const admitsOpenStepCloser = (parent, character) => parent?.end === character &&
     parent.next !== "equals" &&
     !(parent.end === "}" && parent.next === "value");
-/** Bound OpenStep value nesting before the pinned decoder recursively reads it. */
-const assertOpenStepDepthWithinLimit = (text) => {
+/**
+ * Bound OpenStep value nesting before the pinned decoder recursively reads it,
+ * and count the dictionary keys that decode to `__proto__`.
+ */
+const scanOpenStep = (text) => {
+    let prototypeKeys = 0;
     const containers = [];
     const completeValue = () => {
         const parent = containers.at(-1);
@@ -123,18 +146,21 @@ const assertOpenStepDepthWithinLimit = (text) => {
         // diagnostics. A later deep suffix cannot change that failure into a limit.
         if (character === "}" || character === ")") {
             if (!admitsOpenStepCloser(parent, character))
-                return;
-            containers.pop();
+                return prototypeKeys;
+            const closed = containers.pop();
+            if (closed?.keyStart !== undefined &&
+                isOpenStepPrototypeKey(text.slice(closed.keyStart, cursor + 1)))
+                prototypeKeys += 1;
             // parseOpenStep returns the first root value without reading trailing text.
             if (containers.length === 0)
-                return;
+                return prototypeKeys;
             completeValue();
             cursor += 1;
             continue;
         }
         const separator = consumeOpenStepSeparator(parent, character);
         if (separator === "invalid")
-            return;
+            return prototypeKeys;
         if (separator === "consumed") {
             cursor += 1;
             continue;
@@ -144,18 +170,44 @@ const assertOpenStepDepthWithinLimit = (text) => {
             containers.push({
                 end: character === "{" ? "}" : ")",
                 next: character === "{" ? "key" : "value",
+                // A compound key is coerced to a string, e.g. `(__proto__)`.
+                ...(parent?.next === "key" ? { keyStart: cursor } : {}),
             });
             cursor += 1;
             continue;
         }
         const end = skipOpenStepScalar(text, cursor);
         if (end === cursor)
-            return;
-        if (parent?.next !== "key")
+            return prototypeKeys;
+        if (parent?.next === "key") {
+            if (isOpenStepPrototypeKey(text.slice(cursor, end)))
+                prototypeKeys += 1;
+        }
+        else
             assertDepth();
         cursor = end;
         completeValue();
     }
+    return prototypeKeys;
+};
+/**
+ * Whether one OpenStep key, scalar or compound, becomes the property name
+ * `__proto__` when the decoder assigns `obj[key]`. Plain strings compare
+ * directly; any other key is decoded by the pinned decoder itself and
+ * coerced to a property name the same way that assignment does.
+ */
+const isOpenStepPrototypeKey = (token) => {
+    if (!/^["({<]/u.test(token))
+        return token === PROTOTYPE_KEY;
+    if (token.startsWith('"') && !token.includes("\\"))
+        return token === `"${PROTOTYPE_KEY}"`;
+    try {
+        return String(parseOpenStep(token)) === PROTOTYPE_KEY;
+    }
+    catch {
+        // An unterminated token is the decoder's syntax error to report.
+        return false;
+    }
 };
 /** Skip grammar trivia without interpreting delimiter examples inside comments. */
 const skipOpenStepTrivia = (text, cursor) => {
@@ -193,11 +245,11 @@ const skipOpenStepScalar = (text, start) => {
     }
     return cursor;
 };
-/** Elements whose children the pinned plist value decoder visits recursively. */
+/** Elements whose children the plist value decoder visits recursively. */
 const PLIST_CONTAINER_ELEMENTS = new Set(["plist", "dict", "array"]);
 /**
  * Reject XML plists nested deeper than the projection supports before any
- * recursive value pass runs. `plist` and the prototype-key traversal recurse once
+ * recursive value pass runs. Value decoding and prototype omission recurse once
  * per nesting level, so a deeply nested document exhausts the call stack
  * before the projection limit can report the resource bound. The failure
  * matches `projectPlistValue` so callers classify it as a limit failure.
@@ -232,40 +284,3 @@ const assertXmlPlistDepthWithinLimit = (document) => {
             pending.push({ node: node.firstChild, depth: depth + 1 });
     }
 };
-/** Locate keys with the same XML parser and first-child semantics as plist. */
-const substitutePrototypeKeys = (text, document) => {
-    const keys = Array.from(document.getElementsByTagName("key"));
-    const decodedKeys = new Set(keys.map((key) => key.firstChild?.nodeValue));
-    let placeholder = "__rea_prototype_key__";
-    while (decodedKeys.has(placeholder))
-        placeholder = `_${placeholder}`;
-    const omitted = keys
-        .map((key) => key.firstChild)
-        .filter((node) => node?.nodeValue === PROTOTYPE_KEY);
-    if (omitted.length === 0)
-        return { substituted: text, placeholder };
-    // xmldom uses one-based locators in document order. Scan forward only to
-    // needed lines instead of retaining an offset for every source newline.
-    let line = 1;
-    let lineStart = 0;
-    const parts = [];
-    let cursor = 0;
-    for (const node of omitted) {
-        const nodeLine = node?.lineNumber;
-        const column = node?.columnNumber;
-        if (nodeLine === undefined || column === undefined)
-            throw new TypeError("XML plist key has no source location");
-        while (line < nodeLine) {
-            const newline = text.indexOf("\n", lineStart);
-            if (newline === -1)
-                throw new TypeError("XML plist key has an invalid source location");
-            lineStart = newline + 1;
-            line += 1;
-        }
-        const offset = lineStart + column - 1;
-        parts.push(text.slice(cursor, offset), `<![CDATA[${placeholder}]]>`);
-        cursor = offset;
-    }
-    parts.push(text.slice(cursor));
-    return { substituted: parts.join(""), placeholder };
-};

package/dist/domain/propertyListXml.js

@@ -0,0 +1,149 @@
+import { UnknownPlistReal, createPlistNumberCollector, parsePlistIntegerLiteral, parsePlistNonFiniteRealLiteral, } from "./apple/plistNumbers.js";
+/** Interpret an already validated, depth-bounded DOM, owning values and number facts together. */
+export const decodeXmlPropertyList = (document) => {
+    const root = document.documentElement;
+    if (root?.nodeName !== "plist")
+        throw new TypeError("malformed document. First element should be <plist>");
+    const numbers = createPlistNumberCollector();
+    const requireContent = (node) => {
+        if (node.firstChild === null)
+            throw new TypeError(`Cannot parse "" as ${node.nodeName}`);
+        return node.firstChild;
+    };
+    const textNode = (node) => node.nodeType === node.TEXT_NODE;
+    const characterNode = (node) => textNode(node) || node.nodeType === node.CDATA_SECTION_NODE;
+    const content = (node, accepts) => {
+        let text = "";
+        let complete = true;
+        for (let child = node.firstChild; child !== null; child = child.nextSibling) {
+            if (accepts(child))
+                text += child.nodeValue ?? "";
+            else
+                complete = false;
+        }
+        return { text, complete };
+    };
+    const dictionaryKey = (node) => {
+        for (let child = node.firstChild; child !== null; child = child.nextSibling)
+            if (child.nodeType === child.ELEMENT_NODE)
+                return String(node.firstChild?.nodeValue ?? null);
+        return content(node, characterNode).text;
+    };
+    const members = function* (node) {
+        for (let child = node.firstChild; child !== null; child = child.nextSibling)
+            if (child.nodeType !== child.TEXT_NODE &&
+                child.nodeType !== child.CDATA_SECTION_NODE &&
+                child.nodeType !== child.COMMENT_NODE)
+                yield child;
+    };
+    const decode = (node) => {
+        switch (node.nodeName) {
+            case "plist":
+                return Array.from(members(node), decode);
+            case "array": {
+                const values = [];
+                for (const member of members(node)) {
+                    const value = decode(member);
+                    if (value !== null)
+                        values.push(value);
+                }
+                return values;
+            }
+            case "dict": {
+                const entries = [];
+                let key;
+                for (const child of members(node)) {
+                    if (key === undefined) {
+                        if (child.nodeName !== "key")
+                            throw new TypeError("Missing key while parsing <dict/>");
+                        key = dictionaryKey(child);
+                    }
+                    else {
+                        if (child.nodeName === "key")
+                            throw new TypeError("Unexpected <key> while parsing <dict/>. Keys and values must alternate.");
+                        entries.push([key, decode(child)]);
+                        key = undefined;
+                    }
+                }
+                if (key !== undefined)
+                    entries.push([key, ""]);
+                // Define own properties safely, including __proto__; the caller owns omission accounting.
+                return Object.fromEntries(entries);
+            }
+            case "key": {
+                // The pinned decoder also accepted key elements as scalars. Keep their
+                // first-child interpretation separate from dictionary key identities.
+                const value = node.firstChild === null ? "" : node.firstChild.nodeValue;
+                if (value === "__proto__")
+                    throw new TypeError("__proto__ is not a scalar plist key");
+                return value;
+            }
+            case "string":
+                return content(node, characterNode).text;
+            case "integer": {
+                const first = requireContent(node);
+                const literal = content(node, textNode);
+                const exact = literal.complete
+                    ? parsePlistIntegerLiteral(literal.text)
+                    : undefined;
+                if (exact === undefined) {
+                    numbers.markIncomplete();
+                    const partial = Number.parseInt(first.nodeValue ?? "", 10);
+                    // An integer has no signed zero; keep -0 from reading as a real.
+                    return !Number.isFinite(partial)
+                        ? new UnknownPlistReal()
+                        : partial === 0
+                            ? 0
+                            : partial;
+                }
+                numbers.integer(exact);
+                const decoded = Number(exact);
+                // Keep a finite integer's identity when it cannot fit even a Number
+                // approximation; otherwise it would be mislabeled as a non-finite real.
+                return Number.isFinite(decoded) ? decoded : exact;
+            }
+            case "real": {
+                requireContent(node);
+                const literal = content(node, characterNode);
+                if (!literal.complete)
+                    numbers.markIncomplete();
+                // CFPropertyList spells NaN and the infinities; parseFloat would read
+                // the lowercase spellings as NaN and lose the kind and sign.
+                const known = literal.complete
+                    ? parsePlistNonFiniteRealLiteral(literal.text)
+                    : undefined;
+                if (known !== undefined) {
+                    numbers.real(known);
+                    return known;
+                }
+                const value = Number.parseFloat(literal.text);
+                if (!Number.isFinite(value))
+                    return new UnknownPlistReal();
+                if (literal.complete)
+                    numbers.real(value);
+                return value;
+            }
+            case "data": {
+                const binary = atob(content(node, textNode).text.replace(/\s+/gu, ""));
+                return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+            }
+            case "date": {
+                const value = requireContent(node).nodeValue;
+                return new Date(value === null ? 0 : value);
+            }
+            case "null":
+                return null;
+            case "true":
+                return true;
+            case "false":
+                return false;
+            default:
+                throw new TypeError(`Invalid PLIST tag ${node.nodeName}`);
+        }
+    };
+    const values = Array.from(members(root), decode);
+    return {
+        value: values.length === 1 ? values[0] : values,
+        numberLiterals: numbers.result(),
+    };
+};