rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{artifacts__ArtifactProvider-zXI0QjSL.js → artifacts__ArtifactProvider-wx2K0F2I.js}

@@ -1,192 +1,88 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { artifactExtractionResultSchema, artifactInventoryOutputSchema, buildInterfaceBuilderAnalysis, compareUnicodeCodePoints, createArtifactInspection, createEvidence, digestCanonicalValue, err, init_artifactGraph, init_artifactInspection, init_binaryTargetTypes, init_canonicalDigest, init_evidence, init_inputIssueProjection, init_interfaceBuilderGraph, init_interfaceBuilderKeyedArchive, init_result, init_unicodeCodePointOrder, init_zipPackageFormat, interfaceBuilderConnectionFieldNames, interfaceBuilderLimitsSchema, isMachOFormat, isUIKitRuntimeConnectionClass, isZipPackageFormat, ok, projectInputIssues } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisUnsupportedTargetError, freezeJsonSnapshot, init_analysisErrorCore, init_immutableJson, init_jsonValue, jsonValueSchema } from "./errorSchemas-CTRmvMl3.js";
-import { ArtifactReaderFailure, init_ArtifactReader, sameArtifactSourceIdentity } from "./ArtifactReader-BXkffc1D.js";
-import { createAnalysisExecution, init_AnalysisProvider } from "./AnalysisProvider-D0Us2OTk.js";
-import { ArtifactResourceScope, init_ArtifactResourceScope } from "./ArtifactResourceScope-DQWTcUwE.js";
-import { ArtifactOperationError, init_artifactOperationError } from "./artifactOperationError-B7n03FbD.js";
-import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-Ceq8f0wK.js";
-import { init_snapshotEnvironment, snapshotEnvironment } from "./snapshotEnvironment-D_tWyOub.js";
-import { execFileOutput, init_ExecFileOutput } from "./ExecFileOutput-BEQs-lDD.js";
-import { KeyedArchiveKindError, appleAssetCatalogInputSchema, appleResourceKeyFields, dylibResolutionInputSchema, dylibResolutionResultSchema, init_appleAssetCatalog, init_dyldPaths, init_dylibResolution, init_keyedArchive, keyedArchiveInputSchema, keyedArchiveResultSchema, parseAppleAssetCatalogRecords, projectAppleAssetCatalogPage, projectKeyedArchive, resolveTreePath, traceDylibLoading } from "./toolOutputSchemaGroups-DRiYs1je.js";
-import { ARTIFACT_GRAPH_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-DoQRIHii.js";
-import { hasBinaryPlistSignature, hasNibArchiveSignature, init_appleArchiveFormat } from "./appleArchiveFormat-tVoI2ykA.js";
-import { ArtifactPathRegistry, hasMachoMagic, init_ArtifactPaths, init_MachoLoadCommandReader, normalizeArtifactPath, readMachoImage } from "./MachoLoadCommandReader-C7e074Ze.js";
-import { InterfaceBuilderDecodeBudget, InterfaceBuilderDecodeBudgetExceeded, decodeXmlPlistText, estimateBinaryPlistExpansion, init_InterfaceBuilderDecodeBudget, init_propertyListXmlText, preflightPropertyListDecode } from "./InterfaceBuilderDecodeBudget-D4omRUe4.js";
-import { decodeXmlText, init_plistValue, init_propertyListKeys, omittedPrototypeKeysLimitation, parseXmlPropertyList, projectPlistValue } from "./propertyListKeys-G8e74YWb.js";
-import { SafeOutputTree, SafeOutputTreeCreationFailure, init_SafeOutputTree, init_SafeOutputTreeCreationFailure } from "./SafeOutputTree-D6U15GXd.js";
-import { ZipArtifactReader, init_ZipArtifactReader } from "./ZipArtifactReader-B8ZgNe4D.js";
-import { ARTIFACT_ANALYSIS_OPERATIONS, artifactExtractionExecutionSchema, artifactInventoryInputSchema, init_artifactToolContracts } from "./officialToolContracts-CCFF0an9.js";
-import { AsarArtifactReader, DirectoryArtifactReader, MachOSliceArtifactReader, abortIfNeeded, init_ArtifactHash, init_AsarArtifactReader, init_DirectoryArtifactReader, init_MachOSliceArtifactReader, init_scanCanonical, scanCanonicalArtifactInventoryInScope } from "./scanCanonical-KP4T9jSl.js";
-import { artifactCapabilities, init_ArtifactProviderMetadata } from "./binary-BVOr2mgE.js";
+import { artifactExtractionResultSchema, artifactInventoryResultSchema, buildInterfaceBuilderAnalysis, compareUnicodeCodePoints, createArtifactInspection, createEvidence, createPlistNumberCollector, createPlistNumberProjection, digestCanonicalValue, err, init_artifactGraph, init_artifactInspection, init_binaryTargetTypes, init_canonicalDigest, init_evidence, init_inputIssueProjection, init_interfaceBuilderGraph, init_interfaceBuilderKeyedArchive, init_plistNumbers, init_result, init_unicodeCodePointOrder, init_zipPackageFormat, interfaceBuilderConnectionFieldNames, interfaceBuilderLimitsSchema, isMachOFormat, isUIKitRuntimeConnectionClass, isZipPackageFormat, ok, projectInputIssues } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisUnsupportedTargetError, freezeJsonSnapshot, init_analysisErrorCore, init_immutableJson, init_jsonValue, jsonValueSchema } from "./errorSchemas-Ixz_q7qt.js";
+import { NonRegularFileReadError, init_RegularFile, sameRegularFileState } from "./OwnedRegularFile-D1f5nUCx.js";
+import { ArtifactReaderFailure, init_ArtifactReader, sameArtifactSourceIdentity } from "./ArtifactReader-DMwm42bk.js";
+import { artifactFileCancellationCause, assertArtifactReadActive, bindArtifactFileCleanup, init_ArtifactFileOperation, mapArtifactFileFailure, withArtifactRegularFile } from "./ArtifactFileOperation-Dg4BcoEM.js";
+import { createAnalysisExecution, init_AnalysisProvider } from "./AnalysisProvider-BGrYaMVo.js";
+import { ArtifactResourceScope, init_ArtifactResourceScope } from "./ArtifactResourceScope-CokZGcII.js";
+import { ArtifactOperationError, init_artifactOperationError } from "./cliResultOutput-10sd6xGx.js";
+import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-BhsJyAhk.js";
+import { execFileOutput, init_ExecFileOutput } from "./ExecFileOutput-D6KLYTve.js";
+import { init_snapshotEnvironment, snapshotEnvironment } from "./snapshotEnvironment-Yvx5qwsl.js";
+import { InterfaceBuilderDecodeBudget, InterfaceBuilderDecodeBudgetExceeded, decodeXmlPlistText, estimateBinaryPlistExpansion, init_InterfaceBuilderDecodeBudget, init_propertyListXmlText, preflightPropertyListDecode } from "./InterfaceBuilderDecodeBudget-CW1IO3dG.js";
+import { KeyedArchiveKindError, appleAssetCatalogInputSchema, appleResourceKeyFields, dylibResolutionInputSchema, dylibResolutionResultSchema, init_appleAssetCatalog, init_dyldPaths, init_dylibResolution, init_keyedArchive, init_plistValue, keyedArchiveInputSchema, keyedArchiveResultSchema, negativeZeroRealLimitation, nonFiniteRealLimitation, parseAppleAssetCatalogRecords, projectAppleAssetCatalogPage, projectKeyedArchive, projectPlistValue, resolveTreePath, traceDylibLoading, unknownDateLimitation, unknownRealLimitation } from "./toolOutputSchemaGroups-BqdSzySu.js";
+import { ARTIFACT_GRAPH_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-CFh4a64d.js";
+import { hasBinaryPlistSignature, hasNibArchiveSignature, init_appleArchiveFormat } from "./appleArchiveFormat-Bb3G5CCI.js";
+import { init_readArtifactFileChunks, readArtifactFileChunks } from "./readArtifactFileChunks-BbTL_PtB.js";
+import { init_propertyListKeys, omittedPrototypeKeysLimitation, parseXmlPropertyList } from "./propertyListKeys-D5dSASEy.js";
+import { ArtifactPathRegistry, DirectoryArtifactReader, init_ArtifactPaths, init_DirectoryArtifactReader, normalizeArtifactPath } from "./DirectoryArtifactReader-CokAJ8vo.js";
+import { SafeOutputTree, SafeOutputTreeCreationFailure, init_SafeOutputTree, init_SafeOutputTreeCreationFailure } from "./SafeOutputTree-i904hd_2.js";
+import { ZipArtifactReader, init_ZipArtifactReader } from "./ZipArtifactReader-Jed69LEL.js";
+import { hasMachoMagic, init_MachoLoadCommandReader, readMachoImage } from "./MachoLoadCommandReader-CZm6N5vF.js";
+import { ARTIFACT_ANALYSIS_OPERATIONS, artifactExtractionExecutionSchema, artifactInventoryInputSchema, init_artifactToolContracts } from "./officialToolContracts-CzzVLx8I.js";
+import { AsarArtifactReader, MachOSliceArtifactReader, abortIfNeeded, init_ArtifactHash, init_AsarArtifactReader, init_MachOSliceArtifactReader, init_scanCanonical, scanCanonicalArtifactInventoryInScope } from "./scanCanonical-CcDFUr-w.js";
+import { artifactCapabilities, init_ArtifactProviderMetadata } from "./binary-CWVNJhAC.js";
 import { z } from "zod";
-import { basename, dirname, join, relative, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
 import { createHash } from "node:crypto";
 import { TextDecoder } from "node:util";
-import { lstat, open, readlink, realpath } from "node:fs/promises";
-import { constants } from "node:fs";
+import { lstat, readlink, realpath } from "node:fs/promises";
 import { parseBinary } from "plist";
 
-//#region dist/domain/apple/plistNumbers.js
-var createPlistNumberProjection;
-function init_plistNumbers() {
-	return (init_plistNumbers = __esmMin((() => {
-		createPlistNumberProjection = (literals) => {
-			let exactIntegerCount = 0;
-			let ambiguousNumberCount = 0;
-			const mapNumber = (item) => {
-				if (Number.isSafeInteger(item) || !Number.isInteger(item)) return item;
-				if (literals.incomplete) {
-					ambiguousNumberCount += 1;
-					return item;
-				}
-				const decimals = literals.integers.get(item);
-				if (decimals === undefined) {
-					if (!literals.reals.has(item)) ambiguousNumberCount += 1;
-					return item;
-				}
-				const [decimal] = decimals;
-				if (decimals.size !== 1 || decimal === undefined || literals.reals.has(item)) {
-					ambiguousNumberCount += 1;
-					return item;
-				}
-				exactIntegerCount += 1;
-				return {
-					$plist_type: "integer",
-					decimal
-				};
-			};
-			const map = (item) => {
-				if (typeof item === "number") return mapNumber(item);
-				if (Array.isArray(item)) return item.map(map);
-				if (item !== null && typeof item === "object") {
-					const keys = Object.keys(item);
-					const marker = item[keys[0] ?? ""];
-					const reference = keys.length === 1 && (keys[0] === "UID" || keys[0] === "CF$UID") && typeof marker === "number";
-					if (reference) {
-						if (typeof marker === "number" && !Number.isSafeInteger(marker) && (literals.integers.has(marker) || !literals.reals.has(marker))) ambiguousNumberCount += 1;
-						return item;
-					}
-					return Object.fromEntries(Object.entries(item).map(([key, child]) => [key, map(child)]));
-				}
-				return item;
-			};
-			return {
-				project: map,
-				limitations: () => [
-					...literals.incomplete ? ["Original archive number metadata could not be completely observed; decoded numbers may lose integer precision and exact integer/real association is unavailable."] : [],
-					...literals.unsafeIntegerLiterals === 0 ? [] : [`${String(literals.unsafeIntegerLiterals)} observed integer literal(s) in the original archive exceed the exact range of a JSON number. Decoded numbers may lose integer precision unless represented as { "$plist_type": "integer", "decimal": "<exact digits>" }; the original archive bytes retain those literals.`],
-					...exactIntegerCount === 0 ? [] : [`${String(exactIntegerCount)} unambiguous integer value(s) are reported with exact decimal text as { "$plist_type": "integer", "decimal": "<exact digits>" }.`],
-					...ambiguousNumberCount === 0 ? [] : [`${String(ambiguousNumberCount)} number(s) beyond the exact integer range remain as decoded because their source integer/real type or reference marker cannot be associated unambiguously; integer precision loss remains possible.`]
-				]
-			};
-		};
-	})))();
-}
-
-//#endregion
 //#region dist/artifacts/apple/PlistNumberLiterals.js
-var collector, XML_TOKEN, OPAQUE_ELEMENTS, xmlPlistNumberLiterals, binaryPlistNumberLiterals;
+var binaryObjectEnd, scanBinaryPlistNumberLiterals, decodeBinaryPlistNumbers;
 function init_PlistNumberLiterals() {
 	return (init_PlistNumberLiterals = __esmMin((() => {
-		init_propertyListKeys();
+		init_plistNumbers();
 		init_appleArchiveFormat();
-		collector = () => {
-			const integers = new Map();
-			const reals = new Set();
-			let unsafeIntegerLiterals = 0;
-			let incompleteMetadata = false;
-			return {
-				integer: (literal) => {
-					if (!/^[+-]?\d+$/u.test(literal)) {
-						incompleteMetadata = true;
-						return;
-					}
-					const exact = BigInt(literal);
-					if (exact >= BigInt(Number.MIN_SAFE_INTEGER) && exact <= BigInt(Number.MAX_SAFE_INTEGER)) return;
-					unsafeIntegerLiterals += 1;
-					const rounded = Number(exact);
-					integers.set(rounded, (integers.get(rounded) ?? new Set()).add(exact.toString()));
-				},
-				real: (value) => {
-					reals.add(value);
-				},
-				markIncomplete: () => {
-					incompleteMetadata = true;
-				},
-				result: (incomplete = false) => ({
-					incomplete: incomplete || incompleteMetadata,
-					integers,
-					reals,
-					unsafeIntegerLiterals
-				})
-			};
-		};
-		XML_TOKEN = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<(?:[^>"']|"[^"]*"|'[^']*')*>/gu;
-		OPAQUE_ELEMENTS = new Set([
-			"string",
-			"key",
-			"data",
-			"date"
-		]);
-		xmlPlistNumberLiterals = (xml) => {
-			const output = collector();
-			const elements = [];
-			let number;
-			let cursor = 0;
-			for (const match of xml.matchAll(XML_TOKEN)) {
-				const index = match.index;
-				if (number !== undefined) number.text += xml.slice(cursor, index);
-				const token = match[0];
-				cursor = index + token.length;
-				if (token.startsWith("<!--") || token.startsWith("<![CDATA[")) {
-					if (number !== undefined) {
-						number.plainText = false;
-						output.markIncomplete();
-					}
-					continue;
-				}
-				const tag = /^<\s*(\/?)\s*([\w:-]+)/u.exec(token);
-				if (tag === null) {
-					if (number !== undefined) {
-						number.plainText = false;
-						output.markIncomplete();
-					}
-					continue;
-				}
-				const closing = tag[1] === "/";
-				const name = tag[2];
-				if (name === undefined) continue;
-				if (closing) {
-					if (number !== undefined && number.kind === name && number.depth === elements.length) {
-						if (number.plainText) {
-							const text = decodeXmlText(number.text).trim();
-							if (number.kind === "integer") output.integer(text);
-							else output.real(Number.parseFloat(text));
-						}
-						number = undefined;
-					}
-					elements.pop();
-					continue;
-				}
-				if (number !== undefined) {
-					number.plainText = false;
-					output.markIncomplete();
-				}
-				if (/\/\s*>$/u.test(token)) continue;
-				if (number === undefined && (name === "integer" || name === "real") && !elements.some((parent) => OPAQUE_ELEMENTS.has(parent))) number = {
-					kind: name,
-					text: "",
-					depth: elements.length + 1,
-					plainText: true
-				};
-				elements.push(name);
+		binaryObjectEnd = (bytes, offset, objectEnd, referenceWidth) => {
+			const marker = bytes[offset];
+			if (marker === undefined) return undefined;
+			const type = marker >> 4;
+			let length = marker & 15;
+			let cursor = offset + 1;
+			if (length === 15 && type !== 0 && type !== 8) {
+				const extendedMarker = bytes[cursor];
+				if (extendedMarker === undefined || extendedMarker >> 4 !== 1) return undefined;
+				const width = 1 << (extendedMarker & 15);
+				if (width > 8 || cursor + 1 + width > objectEnd) return undefined;
+				cursor += 1;
+				let extendedLength = 0n;
+				for (let index = 0; index < width; index += 1) extendedLength = extendedLength << 8n | BigInt(bytes[cursor + index] ?? 0);
+				if (extendedLength > BigInt(Number.MAX_SAFE_INTEGER)) return undefined;
+				length = Number(extendedLength);
+				cursor += width;
 			}
-			return output.result();
-		};
-		binaryPlistNumberLiterals = (bytes) => {
-			const output = collector();
-			if (bytes.length < 40 || !hasBinaryPlistSignature(bytes)) return output.result(true);
+			let payloadLength;
+			if (type === 0) payloadLength = 0;
+			else if (type === 1 || type === 2) {
+				if ((marker & 15) > 4) return undefined;
+				payloadLength = 1 << (marker & 15);
+			} else if (type === 3) {
+				if (marker !== 51) return undefined;
+				payloadLength = 8;
+			} else if (type === 4 || type === 5 || type === 7) {
+				payloadLength = length;
+			} else if (type === 6) {
+				payloadLength = length * 2;
+			} else if (type === 8) {
+				payloadLength = (marker & 15) + 1;
+			} else if (type === 10 || type === 11 || type === 12) {
+				payloadLength = length * referenceWidth;
+			} else if (type === 13) {
+				payloadLength = length * 2 * referenceWidth;
+			} else return undefined;
+			const end = cursor + payloadLength;
+			return Number.isSafeInteger(end) && end <= objectEnd ? end : undefined;
+		};
+		scanBinaryPlistNumberLiterals = (bytes) => {
+			const output = createPlistNumberCollector();
+			const wideIntegers = [];
+			if (bytes.length < 40 || !hasBinaryPlistSignature(bytes)) return {
+				literals: output.result(true),
+				wideIntegers
+			};
 			const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 			const trailer = bytes.length - 32;
 			const offsetWidth = bytes[trailer + 6] ?? 0;
@@ -195,16 +91,38 @@ function init_PlistNumberLiterals() {
 				2,
 				4,
 				8
-			].includes(offsetWidth)) return output.result(true);
+			].includes(offsetWidth)) return {
+				literals: output.result(true),
+				wideIntegers
+			};
 			const countRaw = view.getBigUint64(trailer + 8);
 			const tableRaw = view.getBigUint64(trailer + 24);
 			const safeMaximum = BigInt(Number.MAX_SAFE_INTEGER);
-			if (countRaw === 0n || countRaw > safeMaximum || tableRaw > safeMaximum) return output.result(true);
-			if (tableRaw < 8n || tableRaw >= BigInt(trailer)) return output.result(true);
+			if (countRaw === 0n || countRaw > safeMaximum || tableRaw > safeMaximum) return {
+				literals: output.result(true),
+				wideIntegers
+			};
+			if (tableRaw < 8n || tableRaw >= BigInt(trailer)) return {
+				literals: output.result(true),
+				wideIntegers
+			};
 			const offsetTable = Number(tableRaw);
 			const capacity = Math.floor((trailer - offsetTable) / offsetWidth);
-			if (countRaw > BigInt(capacity)) return output.result(true);
+			if (countRaw > BigInt(capacity)) return {
+				literals: output.result(true),
+				wideIntegers
+			};
 			const count = Number(countRaw);
+			const referenceWidth = bytes[trailer + 7] ?? 0;
+			if (![
+				1,
+				2,
+				4,
+				8
+			].includes(referenceWidth)) return {
+				literals: output.result(true),
+				wideIntegers
+			};
 			const unsigned = (offset) => {
 				if (offset < offsetTable || offset + offsetWidth > trailer) return undefined;
 				if (offsetWidth === 1) return view.getUint8(offset);
@@ -213,21 +131,66 @@ function init_PlistNumberLiterals() {
 				const value = view.getBigUint64(offset);
 				return value > safeMaximum ? undefined : Number(value);
 			};
+			const objectOffsets = [];
 			for (let index = 0; index < count; index += 1) {
 				const offset = unsigned(offsetTable + index * offsetWidth);
-				if (offset === undefined || offset < 8 || offset >= offsetTable) return output.result(true);
+				if (offset === undefined || offset < 8 || offset >= offsetTable) return {
+					literals: output.result(true),
+					wideIntegers
+				};
+				objectOffsets.push(offset);
+			}
+			const sortedOffsets = [...new Set(objectOffsets)].sort((a, b) => a - b);
+			for (let index = 0; index < sortedOffsets.length; index += 1) {
+				const offset = sortedOffsets[index];
+				if (offset === undefined) continue;
+				const nextOffset = sortedOffsets[index + 1] ?? offsetTable;
+				if (binaryObjectEnd(bytes, offset, nextOffset, referenceWidth) === undefined) return {
+					literals: output.result(true),
+					wideIntegers: []
+				};
+			}
+			for (const offset of objectOffsets) {
 				const marker = bytes[offset] ?? 0;
 				const type = marker >> 4;
 				if (type !== 1 && type !== 2) continue;
 				const width = 2 ** (marker & 15);
-				if (offset + 1 + width > offsetTable) return output.result(true);
-				if (type === 1 && width === 8) output.integer(view.getBigInt64(offset + 1).toString());
-				else if (type === 1 && width > 4) return output.result(true);
+				if (offset + 1 + width > offsetTable) return {
+					literals: output.result(true),
+					wideIntegers
+				};
+				if (type === 1 && width === 8) output.integer(view.getBigInt64(offset + 1));
+				else if (type === 1 && width === 16) {
+					const value = BigInt.asIntN(128, view.getBigUint64(offset + 1) << 64n | view.getBigUint64(offset + 9));
+					output.integer(value);
+					wideIntegers.push({
+						offset,
+						value
+					});
+				} else if (type === 1 && width > 4) return {
+					literals: output.result(true),
+					wideIntegers
+				};
 				else if (type === 2 && width === 4) output.real(view.getFloat32(offset + 1));
 				else if (type === 2 && width === 8) output.real(view.getFloat64(offset + 1));
-				else if (type === 2) return output.result(true);
+				else if (type === 2) return {
+					literals: output.result(true),
+					wideIntegers
+				};
 			}
-			return output.result();
+			return {
+				literals: output.result(),
+				wideIntegers
+			};
+		};
+		decodeBinaryPlistNumbers = (bytes, metadata) => {
+			if (metadata.wideIntegers.length === 0) return bytes;
+			const compatible = Buffer.from(bytes);
+			for (const { offset, value } of metadata.wideIntegers) {
+				compatible[offset] = 35;
+				compatible.writeDoubleBE(Number(value), offset + 1);
+			}
+			return compatible;
 		};
 	})))();
 }
@@ -258,15 +221,17 @@ function init_KeyedArchiveReader() {
 			const binaryExpansion = binary ? estimateBinaryPlistExpansion(bytes, MAX_DECODE_BYTES, {
 				budget: "the keyed archive decode budget",
 				fail: (kind, message) => kind === "cycle" ? new TypeError("binary plist object references form a cycle, which a property list cannot represent") : new RangeError(message),
-				bounds: "decoder"
+				bounds: "decoder",
+				numberProjection: true
 			}) : undefined;
+			const binaryNumberMetadata = binary ? scanBinaryPlistNumberLiterals(bytes) : undefined;
 			const parsed = binaryExpansion !== undefined ? {
-				value: parseBinary(bytes),
+				value: parseBinary(decodeBinaryPlistNumbers(bytes, binaryNumberMetadata)),
+				numberLiterals: binaryNumberMetadata.literals,
 				omittedPrototypeKeys: binaryExpansion.binaryPrototypeKeyObserved ? null : 0
 			} : parseXmlPropertyList(xmlText ?? "");
-			const { value: plistValue, unknownRealCount } = projectPlistValue(parsed.value);
-			const graph = projectKeyedArchive(plistValue, selection);
-			const numbers = createPlistNumberProjection(binary ? binaryPlistNumberLiterals(bytes) : xmlPlistNumberLiterals(xmlText ?? ""));
+			const { nonFiniteRealCount, unknownRealCount, negativeZeroRealCount, unknownDateCount, ...graph } = projectKeyedArchive(parsed.value, selection);
+			const numbers = createPlistNumberProjection(parsed.numberLiterals);
 			const roots = Object.fromEntries(Object.entries(graph.roots).map(([name, value]) => [name, numbers.project(value)]));
 			const objects = graph.objects.map((object) => ({
 				...object,
@@ -281,7 +246,10 @@ function init_KeyedArchiveReader() {
 					...graph.limitations,
 					...numbers.limitations(),
 					...parsed.omittedPrototypeKeys === 0 ? [] : [omittedPrototypeKeysLimitation(parsed.omittedPrototypeKeys)],
-					...unknownRealCount === 0 ? [] : [`${String(unknownRealCount)} non-finite real value(s) are reported as { "$plist_type": "real", "value": null } because JSON evidence cannot preserve NaN vs infinity.`]
+					...nonFiniteRealCount === 0 ? [] : [nonFiniteRealLimitation(nonFiniteRealCount)],
+					...unknownRealCount === 0 ? [] : [unknownRealLimitation(unknownRealCount)],
+					...negativeZeroRealCount === 0 ? [] : [negativeZeroRealLimitation(negativeZeroRealCount)],
+					...unknownDateCount === 0 ? [] : [unknownDateLimitation(unknownDateCount)]
 				]
 			};
 		};
@@ -401,9 +369,102 @@ function init_OrderedReads() {
 	})))();
 }
 
+//#endregion
+//#region dist/artifacts/apple/DylibFileAccess.js
+var DylibFileAccess, classifyDylibReadFailure, deniedDisplayPath, changed;
+function init_DylibFileAccess() {
+	return (init_DylibFileAccess = __esmMin((() => {
+		init_RegularFile();
+		init_ArtifactReader();
+		init_ArtifactFileOperation();
+		init_readArtifactFileChunks();
+		init_MachoLoadCommandReader();
+		DylibFileAccess = class {
+			resources;
+			root;
+			signal;
+			constructor(resources, root, signal) {
+				this.resources = resources;
+				this.root = root;
+				this.signal = signal;
+			}
+			startsWithMachoMagic(entry) {
+				return this.#read(entry.adapterKey, async (file, initial) => {
+					if (!sameArtifactSourceIdentity(entry.sourceIdentity, initial)) throw changed(entry.adapterKey);
+					const bytes = new Uint8Array(4);
+					const { bytesRead } = await file.read(bytes, 0, bytes.length, 0);
+					return hasMachoMagic(bytes.subarray(0, bytesRead));
+				});
+			}
+			image(path) {
+				return this.#read(path, async (file, identity) => {
+					const size = Number(identity.size);
+					if (!Number.isSafeInteger(size)) throw new ArtifactReaderFailure("limit", `Mach-O file extent is not safely addressable: ${path}`);
+					const facts = await readMachoImage(async (offset, length) => {
+						assertArtifactReadActive(this.signal);
+						const bytes = new Uint8Array(Math.max(0, Math.min(length, size - offset)));
+						const { bytesRead } = await file.read(bytes, 0, bytes.length, offset);
+						assertArtifactReadActive(this.signal);
+						return bytes.subarray(0, bytesRead);
+					}, size);
+					return {
+						facts,
+						identity
+					};
+				});
+			}
+			sha256(path, expected) {
+				return this.#read(path, async (file, initial) => {
+					if (expected !== undefined && !sameRegularFileState(expected, initial)) throw changed(path);
+					const hash = createHash("sha256");
+					const source = readArtifactFileChunks(file, {
+						end: initial.size,
+						signal: this.signal
+					});
+					for await (const chunk of source) hash.update(chunk);
+					const coverage = source.readCoverage();
+					if (coverage.kind !== "complete" || coverage.bytes !== initial.size) throw changed(path);
+					return hash.digest("hex");
+				});
+			}
+			async #read(path, operation) {
+				try {
+					return await withArtifactRegularFile(path, this.resources, this.signal, async (file) => {
+						const initial = await file.stat({ bigint: true });
+						assertArtifactReadActive(this.signal);
+						const result = await operation(file, initial);
+						const opened = await file.stat({ bigint: true });
+						const named = await lstat(path, { bigint: true });
+						if (!sameRegularFileState(initial, opened) || !sameRegularFileState(initial, named)) throw changed(path);
+						assertArtifactReadActive(this.signal);
+						return result;
+					});
+				} catch (cause) {
+					throw classifyDylibReadFailure(this.root, cause);
+				}
+			}
+		};
+		classifyDylibReadFailure = (root, cause) => mapArtifactFileFailure(cause, (primary) => {
+			if (primary instanceof NonRegularFileReadError) return new ArtifactReaderFailure("format", `Dyld input is not a regular file: ${primary.path}`, { cause: primary });
+			if (primary instanceof Error && "code" in primary && (primary.code === "EACCES" || primary.code === "EPERM")) {
+				const path = "path" in primary && typeof primary.path === "string" ? primary.path : undefined;
+				const display = path === undefined ? "a file in the analyzed root" : deniedDisplayPath(root, path);
+				return new ArtifactReaderFailure("unavailable", `Permission denied (${primary.code}) reading ${display}`, { cause: primary });
+			}
+			return primary;
+		});
+		deniedDisplayPath = (root, path) => {
+			const inside = relative(root, path);
+			const outside = isAbsolute(inside) || inside === ".." || inside.startsWith(`..${sep}`);
+			return inside === "" || outside ? path : inside;
+		};
+		changed = (path) => new ArtifactReaderFailure("integrity", `${path} changed while its dyld load commands were traced`);
+	})))();
+}
+
 //#endregion
 //#region dist/artifacts/apple/DylibResolutionReader.js
-var OPERATION, HASH_CHUNK_BYTES, MAGIC_READ_CONCURRENCY, FilesystemTreeView, traceDylibResolution, executableRoots, compare, requireMachoRoots, startsWithMachoMagic, identityOf, readImage, fileSha256, cancelled, deniedPath, permissionDenied, missing;
+var OPERATION, MAGIC_READ_CONCURRENCY, FilesystemTreeView, traceDylibResolution, executableRoots, compare, requireMachoRoots, missing;
 function init_DylibResolutionReader() {
 	return (init_DylibResolutionReader = __esmMin((() => {
 		init_analysisErrorCore();
@@ -413,18 +474,21 @@ function init_DylibResolutionReader() {
 		init_ArtifactReader();
 		init_DirectoryArtifactReader();
 		init_OrderedReads();
-		init_MachoLoadCommandReader();
+		init_DylibFileAccess();
+		init_ArtifactResourceScope();
+		init_ArtifactFileOperation();
 		OPERATION = "trace_dylib_resolution";
-		HASH_CHUNK_BYTES = 1024 * 1024;
 		MAGIC_READ_CONCURRENCY = 8;
 		FilesystemTreeView = class {
 			root;
+			files;
 			signal;
 			#entries = new Map();
 			#images = new Map();
 			#identities = new Map();
-			constructor(root, signal) {
+			constructor(root, files, signal) {
 				this.root = root;
+				this.files = files;
 				this.signal = signal;
 			}
 			entry(path) {
@@ -437,7 +501,7 @@ function init_DylibResolutionReader() {
 			image(path) {
 				const cached = this.#images.get(path);
 				if (cached !== undefined) return cached;
-				const pending = readImage(join(this.root, path), this.signal).then(({ facts, identity }) => {
+				const pending = this.files.image(join(this.root, path)).then(({ facts, identity }) => {
 					this.#identities.set(path, identity);
 					return facts;
 				});
@@ -449,7 +513,7 @@ function init_DylibResolutionReader() {
 				return this.#identities.get(path);
 			}
 			async #readEntry(path) {
-				cancelled(this.signal);
+				assertArtifactReadActive(this.signal);
 				const absolute = join(this.root, path);
 				try {
 					const metadata = await lstat(absolute);
@@ -468,57 +532,54 @@ function init_DylibResolutionReader() {
 		traceDylibResolution = async (options) => {
 			const parsed = dylibResolutionInputSchema.safeParse(options.parameters);
 			if (!parsed.success) throw new AnalysisInputError(OPERATION, { cause: parsed.error }, projectInputIssues(parsed.error.issues, options.parameters));
-			let root = options.rootPath;
-			try {
-				root = await realpath(options.rootPath);
-				const target = relative(root, await realpath(options.targetPath)).split(sep).join("/");
-				const view = new FilesystemTreeView(root, options.signal);
-				const { roots: requested, unclassified } = parsed.data.roots !== undefined ? {
-					roots: parsed.data.roots,
-					unclassified: []
-				} : options.enumerateRoots ? await executableRoots(root, view, options.signal) : {
-					roots: [target],
-					unclassified: []
-				};
-				const roots = await requireMachoRoots(view, requested, parsed.data.roots !== undefined);
-				const trace = await traceDylibLoading(view, {
-					roots,
-					unclassified,
-					...parsed.data.architecture === undefined ? {} : { architecture: parsed.data.architecture },
-					...options.signal === undefined ? {} : { signal: options.signal }
-				});
-				const digests = new Map();
-				for (const { path } of trace.images) digests.set(path, await fileSha256(join(root, path), {
-					path,
-					expected: view.identity(path),
-					...options.signal === undefined ? {} : { signal: options.signal }
-				}));
-				const targetDigest = digests.get(target) ?? await fileSha256(join(root, target), {
-					path: target,
-					expected: undefined,
-					...options.signal === undefined ? {} : { signal: options.signal }
-				});
-				if (targetDigest !== options.targetSha256) throw new ArtifactReaderFailure("integrity", `Active target digest changed: expected ${options.targetSha256}, observed ${targetDigest}`);
-				return dylibResolutionResultSchema.parse({
-					...trace,
-					root_path: options.rootPath,
-					target_sha256: options.targetSha256,
-					images: trace.images.map((image) => ({
-						...image,
-						sha256: digests.get(image.path)
-					}))
-				});
-			} catch (cause) {
-				if (options.signal?.aborted === true) throw new ArtifactReaderFailure("cancelled", "Dylib resolution was cancelled", { cause });
-				const denied = permissionDenied(cause);
-				if (denied !== undefined) throw new ArtifactReaderFailure("unavailable", `Permission denied (${denied.code}) reading ${deniedPath(root, denied.path)}`, { cause });
-				throw cause;
-			}
+			const resources = options.resourceScope ?? new ArtifactResourceScope();
+			return await resources.run(async () => {
+				let root = options.rootPath;
+				try {
+					assertArtifactReadActive(options.signal);
+					root = await realpath(options.rootPath);
+					assertArtifactReadActive(options.signal);
+					const files = new DylibFileAccess(resources, root, options.signal);
+					const target = relative(root, await realpath(options.targetPath)).split(sep).join("/");
+					assertArtifactReadActive(options.signal);
+					const view = new FilesystemTreeView(root, files, options.signal);
+					const { roots: requested, unclassified } = parsed.data.roots !== undefined ? {
+						roots: parsed.data.roots,
+						unclassified: []
+					} : options.enumerateRoots ? await executableRoots(root, view, files, options.signal) : {
+						roots: [target],
+						unclassified: []
+					};
+					const roots = await requireMachoRoots(view, requested, parsed.data.roots !== undefined);
+					const trace = await traceDylibLoading(view, {
+						roots,
+						unclassified,
+						...parsed.data.architecture === undefined ? {} : { architecture: parsed.data.architecture },
+						...options.signal === undefined ? {} : { signal: options.signal }
+					});
+					const digests = new Map();
+					for (const { path } of trace.images) digests.set(path, await files.sha256(join(root, path), view.identity(path)));
+					const targetDigest = digests.get(target) ?? await files.sha256(join(root, target), undefined);
+					if (targetDigest !== options.targetSha256) throw new ArtifactReaderFailure("integrity", `Active target digest changed: expected ${options.targetSha256}, observed ${targetDigest}`);
+					assertArtifactReadActive(options.signal);
+					return dylibResolutionResultSchema.parse({
+						...trace,
+						root_path: options.rootPath,
+						target_sha256: options.targetSha256,
+						images: trace.images.map((image) => ({
+							...image,
+							sha256: digests.get(image.path)
+						}))
+					});
+				} catch (cause) {
+					throw classifyDylibReadFailure(root, cause);
+				}
+			});
 		};
-		executableRoots = async (root, view, signal) => {
+		executableRoots = async (root, view, files, signal) => {
 			const roots = [];
 			const unclassified = [];
-			await consumeWithOrderedReads(new DirectoryArtifactReader(root).entries(signal), MAGIC_READ_CONCURRENCY, (entry) => entry.kind === "file" ? startsWithMachoMagic(entry.adapterKey) : undefined, async (entry, macho) => {
+			await consumeWithOrderedReads(new DirectoryArtifactReader(root).entries(signal), MAGIC_READ_CONCURRENCY, (entry) => entry.kind === "file" ? files.startsWithMachoMagic(entry) : undefined, async (entry, macho) => {
 				if (!macho) return;
 				const facts = await view.image(entry.path);
 				if (facts.status === "malformed" || facts.status === "unsupported") unclassified.push(entry.path);
@@ -546,81 +607,6 @@ function init_DylibResolutionReader() {
 			}
 			return resolved;
 		};
-		startsWithMachoMagic = async (path) => {
-			const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-			try {
-				const buffer = new Uint8Array(4);
-				const { bytesRead } = await handle.read(buffer, 0, 4, 0);
-				return hasMachoMagic(buffer.subarray(0, bytesRead));
-			} finally {
-				await handle.close();
-			}
-		};
-		identityOf = (metadata) => [
-			metadata.dev,
-			metadata.ino,
-			metadata.size,
-			metadata.mtimeNs,
-			metadata.ctimeNs
-		].join(":");
-		readImage = async (path, signal) => {
-			cancelled(signal);
-			const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-			try {
-				const metadata = await handle.stat({ bigint: true });
-				const size = Number(metadata.size);
-				const facts = await readMachoImage(async (offset, length) => {
-					cancelled(signal);
-					const buffer = new Uint8Array(Math.max(0, Math.min(length, size - offset)));
-					const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
-					return buffer.subarray(0, bytesRead);
-				}, size);
-				return {
-					facts,
-					identity: identityOf(metadata)
-				};
-			} finally {
-				await handle.close();
-			}
-		};
-		fileSha256 = async (absolute, options) => {
-			const { signal } = options;
-			const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
-			const unchanged = async () => {
-				if (options.expected !== undefined && identityOf(await handle.stat({ bigint: true })) !== options.expected) throw new ArtifactReaderFailure("integrity", `${options.path} changed while its dyld load commands were traced`);
-			};
-			try {
-				await unchanged();
-				const hash = createHash("sha256");
-				const buffer = new Uint8Array(HASH_CHUNK_BYTES);
-				for (;;) {
-					cancelled(signal);
-					const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
-					if (bytesRead === 0) break;
-					hash.update(buffer.subarray(0, bytesRead));
-				}
-				await unchanged();
-				return hash.digest("hex");
-			} finally {
-				await handle.close();
-			}
-		};
-		cancelled = (signal) => {
-			if (signal?.aborted === true) throw new ArtifactReaderFailure("cancelled", "Dylib resolution was cancelled");
-		};
-		deniedPath = (root, path) => {
-			if (path === undefined) return "a file in the analyzed root";
-			const inside = relative(root, path);
-			return inside === "" || inside.startsWith("..") ? path : inside;
-		};
-		permissionDenied = (cause) => {
-			if (!(cause instanceof Error) || !("code" in cause)) return undefined;
-			if (cause.code !== "EACCES" && cause.code !== "EPERM") return undefined;
-			return {
-				code: cause.code,
-				path: "path" in cause && typeof cause.path === "string" ? cause.path : undefined
-			};
-		};
 		missing = (cause) => cause instanceof Error && "code" in cause && (cause.code === "ENOENT" || cause.code === "ENOTDIR");
 	})))();
 }
@@ -635,7 +621,7 @@ function init_ArtifactInventory() {
 		init_scanCanonical();
 		inventoryArtifact = async (inputPath, options) => {
 			const snapshot = await scanArtifactInventory(inputPath, options);
-			return artifactInventoryOutputSchema.parse(snapshot);
+			return artifactInventoryResultSchema.parse(snapshot);
 		};
 		scanArtifactInventory = async (inputPath, options) => options.resourceScope.run(() => scanArtifactInventoryInScope(inputPath, options));
 		scanArtifactInventoryInScope = async (inputPath, options) => {
@@ -728,7 +714,12 @@ function init_ArtifactExtraction() {
 			});
 		};
 		materializeSelection = async ({ input, sourcePath, inventory, selected, signal }) => {
-			const byPath = new Map(selected.map((item) => [item.occurrence.logical_path, item]));
+			const byPath = new Map();
+			for (const item of selected) {
+				const path = item.occurrence.logical_path;
+				if (byPath.has(path)) throw new ArtifactReaderFailure("path", `Artifact extraction path collision: ${JSON.stringify(path)}. Multiple selected occurrences share this normalized logical path; they cannot be materialized at the same destination path, even when the archive is valid. Inventory retains each occurrence.`);
+				byPath.set(path, item);
+			}
 			const reader = await createReader(sourcePath, input);
 			const readerOwner = {
 				kind: "reader",
@@ -755,19 +746,19 @@ function init_ArtifactExtraction() {
 				});
 				localReaderOwner = undefined;
 				const closeAttempt = await input.resourceScope.release(readerOwner);
-				if (closeAttempt.kind === "failed") throw ArtifactReaderFailure.withCleanup(closeAttempt.cause, ArtifactReaderFailure.cleanupObservation(closeAttempt.cause, readerOwner.resource));
+				if (closeAttempt.kind === "failed") throw input.resourceScope.cleanupFailure({ kind: "completed" }, [closeAttempt]);
 				extracted.sort((left, right) => compareUnicodeCodePoints(left.relative_path, right.relative_path));
 				completed = createExtractionResult(input, inventory, selected, extracted);
 				await output.commit(signal);
 				return completed;
 			} catch (cause) {
 				const cleanupFailures = await releaseExtractionOwners(input.resourceScope, localReaderOwner, output, input.outputRoot);
-				if (cleanupFailures.length > 0) {
-					const observations = cleanupFailures.map(({ cause: cleanupCause, resource }) => ArtifactReaderFailure.cleanupObservation(cleanupCause, resource));
-					throw ArtifactReaderFailure.withCleanup(cause, {
-						reason: observations.map(({ reason }) => reason).join("; "),
-						resources: [...new Set(observations.flatMap(({ resources }) => resources))]
-					}, output?.published === true && completed !== undefined ? {
+				const [firstCleanup, ...remainingCleanup] = cleanupFailures;
+				if (firstCleanup !== undefined) {
+					throw input.resourceScope.cleanupFailure({
+						kind: "failed",
+						cause
+					}, [firstCleanup, ...remainingCleanup], output?.published === true && completed !== undefined ? {
 						kind: "artifact-extraction",
 						extraction: completed
 					} : undefined);
@@ -807,10 +798,7 @@ function init_ArtifactExtraction() {
 			const failures = [];
 			if (readerOwner !== undefined) {
 				const attempt = await resourceScope.release(readerOwner);
-				if (attempt.kind === "failed") failures.push({
-					cause: attempt.cause,
-					resource: readerOwner.resource
-				});
+				if (attempt.kind === "failed") failures.push(attempt);
 			}
 			if (output !== undefined) {
 				const owner = {
@@ -819,10 +807,7 @@ function init_ArtifactExtraction() {
 					resource: outputRoot
 				};
 				const attempt = await resourceScope.release(owner);
-				if (attempt.kind === "failed") failures.push({
-					cause: attempt.cause,
-					resource: owner.resource
-				});
+				if (attempt.kind === "failed") failures.push(attempt);
 			}
 			return failures;
 		};
@@ -1341,7 +1326,7 @@ function init_NibViewHierarchy() {
 
 //#endregion
 //#region dist/artifacts/apple/InterfaceBuilderAnalysis.js
-var MAX_AGGREGATE_INPUT_BYTES, MAX_AGGREGATE_DECODE_BYTES, MAX_REPORTED_OMITTED_ARCHIVES, analyzeInterfaceBuilderBundle, selectInterfaceBuilderCandidates, retainCandidate, finalizeHierarchyCoverage, projectNibArchive, isInterfaceBuilderArchive, readEntry, decodePlist;
+var MAX_AGGREGATE_INPUT_BYTES, MAX_AGGREGATE_DECODE_BYTES, MAX_REPORTED_OMITTED_ARCHIVES, analyzeInterfaceBuilderBundle, selectInterfaceBuilderCandidates, retainCandidate, finalizeHierarchyCoverage, projectNibArchive, isInterfaceBuilderArchive, readEntry, parseXmlWithinDecodeBudget, decodePlist;
 function init_InterfaceBuilderAnalysis() {
 	return (init_InterfaceBuilderAnalysis = __esmMin((() => {
 		init_appleAssetCatalog();
@@ -1356,6 +1341,7 @@ function init_InterfaceBuilderAnalysis() {
 		init_jsonValue();
 		init_unicodeCodePointOrder();
 		init_propertyListXmlText();
+		init_PlistNumberLiterals();
 		init_appleArchiveFormat();
 		MAX_AGGREGATE_INPUT_BYTES = 32 * 1024 * 1024;
 		MAX_AGGREGATE_DECODE_BYTES = 256 * 1024 * 1024;
@@ -1370,6 +1356,7 @@ function init_InterfaceBuilderAnalysis() {
 			const incompleteHierarchies = new Map();
 			const unresolvedConnections = new Map();
 			const prototypeKeyOmissions = new Map();
+			const unknownDates = new Map();
 			let omitted = 0;
 			let attempted = 0;
 			let aggregateInputBytes = 0;
@@ -1387,6 +1374,7 @@ function init_InterfaceBuilderAnalysis() {
 				for (const entry of selection.omittedSamples) recordOmittedArchive(entry.path, "max_documents");
 				unreportedOmittedArchives += selection.unreportedOmitted;
 				for (const entry of selection.selected) {
+					let plistReservation = 0;
 					try {
 						const remainingInputBytes = MAX_AGGREGATE_INPUT_BYTES - aggregateInputBytes;
 						if (entry.declaredSize !== null && entry.declaredSize > remainingInputBytes) {
@@ -1407,28 +1395,34 @@ function init_InterfaceBuilderAnalysis() {
 							decodeBudget.reserve(documentBudget.usedBytes, "NIBArchive representation exceeds the aggregate Interface Builder decode budget");
 						} else {
 							if (!hasBinaryPlistSignature(bytes)) xmlText = decodeXmlPlistText(bytes);
-							const decodedReservation = preflightPropertyListDecode(bytes, decodeBudget.remainingBytes, xmlText);
+							const decodedReservation = preflightPropertyListDecode(bytes, decodeBudget.remainingBytes, xmlText, { numberProjection: true });
 							decodeBudget.reserve(decodedReservation.estimatedBytes, "plist representation exceeds the aggregate Interface Builder decode budget");
+							plistReservation = decodedReservation.estimatedBytes;
 							binaryPrototypeKeyObserved = decodedReservation.binaryPrototypeKeyObserved;
 						}
-						const { value: raw, omittedPrototypeKeys } = nib === null ? decodePlist(bytes, xmlText, binaryPrototypeKeyObserved) : {
+						const { value: raw, omittedPrototypeKeys, unknownDateCount, numberLiterals } = nib === null ? decodePlist(bytes, xmlText, binaryPrototypeKeyObserved) : {
 							value: nib.raw,
-							omittedPrototypeKeys: 0
+							omittedPrototypeKeys: 0,
+							unknownDateCount: 0,
+							numberLiterals: undefined
 						};
 						if (nib !== null && nib.omitted > 0) incompleteHierarchies.set(entry.path, nib.omitted);
 						if (nib !== null && nib.unresolvedConnections > 0) unresolvedConnections.set(entry.path, nib.unresolvedConnections);
 						if (omittedPrototypeKeys !== 0) prototypeKeyOmissions.set(entry.path, omittedPrototypeKeys);
+						if (unknownDateCount !== 0) unknownDates.set(entry.path, unknownDateCount);
 						const documentHash = createHash("sha256").update(bytes).digest("hex");
 						documents.push({
 							relativePath: entry.path,
 							archiveSha256: documentHash,
 							documentKind: entry.path.includes(".storyboardc/") ? "storyboard_scene" : "nib",
 							raw,
+							...numberLiterals === undefined ? {} : { numberLiterals },
 							...nib === null || nib.omitted === 0 ? {} : { omittedSerializedHierarchyReferences: nib.omitted }
 						});
 					} catch (cause) {
 						if (input.signal?.aborted === true) throw cause;
 						if (cause instanceof InterfaceBuilderDecodeBudgetExceeded) {
+							decodeBudget.release(plistReservation);
 							omitted += 1;
 							recordOmittedArchive(entry.path, cause.reason);
 							continue;
@@ -1449,6 +1443,7 @@ function init_InterfaceBuilderAnalysis() {
 				incompleteHierarchies,
 				unresolvedConnections,
 				prototypeKeyOmissions,
+				unknownDates,
 				invalid,
 				omittedArchives,
 				unreportedOmittedArchives,
@@ -1486,7 +1481,7 @@ function init_InterfaceBuilderAnalysis() {
 			if (candidates.length > maximum) candidates.pop();
 		};
 		finalizeHierarchyCoverage = (result, counts) => {
-			const { incompleteHierarchies, unresolvedConnections, prototypeKeyOmissions, invalid, omittedArchives, unreportedOmittedArchives } = counts;
+			const { incompleteHierarchies, unresolvedConnections, prototypeKeyOmissions, unknownDates, invalid, omittedArchives, unreportedOmittedArchives } = counts;
 			const archiveDecodePartial = invalid.length > 0 || prototypeKeyOmissions.size > 0 || omittedArchives.length > 0;
 			return {
 				...result,
@@ -1520,6 +1515,7 @@ function init_InterfaceBuilderAnalysis() {
 					...unresolvedConnections.size === 0 ? [] : ["Some recognized NIBArchive connectors declare no resolvable owner; they carry no connection evidence and are reported as omissions."],
 					...invalid.length === 0 ? [] : [`Some Interface Builder archives could not be decoded: ${invalid.slice(0, 16).join("; ")}`],
 					...[...prototypeKeyOmissions].map(([path, count]) => `${path}: ${omittedPrototypeKeysLimitation(count)}`),
+					...[...unknownDates].map(([path, count]) => `${path}: ${unknownDateLimitation(count)}`),
 					...omittedArchives.map(({ path, reason }) => `${path}: omitted because ${reason.replaceAll("_", " ")}.`),
 					...unreportedOmittedArchives === 0 ? [] : [`${unreportedOmittedArchives} additional omitted archive path(s) and their reasons were not retained; reporting is bounded to ${MAX_REPORTED_OMITTED_ARCHIVES} paths.`]
 				]
@@ -1754,15 +1750,28 @@ function init_InterfaceBuilderAnalysis() {
 			}
 			return Buffer.concat(chunks, length);
 		};
+		parseXmlWithinDecodeBudget = (text) => {
+			try {
+				return parseXmlPropertyList(text);
+			} catch (cause) {
+				if (cause instanceof RangeError) throw new InterfaceBuilderDecodeBudgetExceeded("aggregate_decode_budget_exhausted", cause.message);
+				throw cause;
+			}
+		};
 		decodePlist = (bytes, xmlText, binaryPrototypeKeyObserved) => {
 			const binary = hasBinaryPlistSignature(bytes);
-			const { value, omittedPrototypeKeys } = binary ? {
-				value: parseBinary(bytes),
-				omittedPrototypeKeys: binaryPrototypeKeyObserved ? null : 0
-			} : parseXmlPropertyList(xmlText ?? decodeXmlPlistText(bytes));
+			const binaryNumberMetadata = binary ? scanBinaryPlistNumberLiterals(bytes) : undefined;
+			const { value, omittedPrototypeKeys, numberLiterals } = binary ? {
+				value: parseBinary(decodeBinaryPlistNumbers(bytes, binaryNumberMetadata)),
+				omittedPrototypeKeys: binaryPrototypeKeyObserved ? null : 0,
+				numberLiterals: binaryNumberMetadata.literals
+			} : parseXmlWithinDecodeBudget(xmlText ?? decodeXmlPlistText(bytes));
+			const projected = projectPlistValue(value);
 			return {
-				value: projectPlistValue(value).value,
-				omittedPrototypeKeys
+				value: projected.value,
+				omittedPrototypeKeys,
+				unknownDateCount: projected.unknownDateCount,
+				numberLiterals
 			};
 		};
 	})))();
@@ -1834,7 +1843,7 @@ function init_AppleAssetCatalogAnalysis() {
 			let totalMetadataBytes = 0;
 			try {
 				for await (const entry of reader.entries(input.signal)) {
-					if (!entry.path.endsWith("Assets.car")) continue;
+					if (entry.path.split("/").at(-1) !== "Assets.car") continue;
 					if (entry.kind !== "file") {
 						uninspected.push(`${entry.path} (${entry.kind})`);
 						continue;
@@ -1951,6 +1960,7 @@ function init_ArtifactProvider() {
 		init_result();
 		init_ArtifactReader();
 		init_ArtifactResourceScope();
+		init_ArtifactFileOperation();
 		init_ArtifactProviderMetadata();
 		init_InvestigationProviders();
 		init_evidence();
@@ -2076,10 +2086,12 @@ function init_ArtifactProvider() {
 			close() {
 				return this.#resourceScope.close().then(() => ok(null), (cause) => {
 					const failure = cause instanceof ArtifactReaderFailure ? cause : undefined;
-					return err(new ProviderCleanupError(ARTIFACT_GRAPH_PROVIDER.id, failure?.cleanup?.resources ?? ["artifact resources"], { reason: failure?.cleanup?.reason ?? (cause instanceof Error ? cause.message : String(cause)) }, {
+					const error = new ProviderCleanupError(ARTIFACT_GRAPH_PROVIDER.id, failure?.cleanup?.resources ?? ["artifact resources"], { reason: failure?.cleanup?.reason ?? (cause instanceof Error ? cause.message : String(cause)) }, {
 						cause,
 						operation: "close_binary"
-					}));
+					});
+					bindArtifactFileCleanup(cause, error);
+					return err(error);
 				});
 			}
 			/** The active target's kind is outside this operation's supported targets. */
@@ -2113,6 +2125,7 @@ function init_ArtifactProvider() {
 					targetSha256: this.target.sha256,
 					enumerateRoots: bundle !== undefined,
 					parameters,
+					resourceScope: this.#resourceScope,
 					...options?.signal === undefined ? {} : { signal: options.signal }
 				});
 				return ok(createAnalysisExecution(result, ARTIFACT_GRAPH_PROVIDER, {
@@ -2167,11 +2180,16 @@ function init_ArtifactProvider() {
 		};
 		isArtifactOperation = (operation) => ARTIFACT_ANALYSIS_OPERATIONS.includes(operation);
 		translateArtifactFailure = (operation, cause) => {
-			if (cause instanceof ArtifactReaderFailure) return new ArtifactOperationError(operation, cause.reason, cause.details, cause.message, {
-				...cause.cleanup === undefined ? {} : { cleanup: cause.cleanup },
-				...cause.partialObservation === undefined ? {} : { partialObservation: cause.partialObservation }
-			});
-			if (cause instanceof AnalysisInputError || cause instanceof AnalysisUnsupportedTargetError) return cause;
+			if (cause instanceof ArtifactReaderFailure) {
+				const error = new ArtifactOperationError(operation, cause.reason, cause.details, cause.message, {
+					cause: cause.reason === "cancelled" ? artifactFileCancellationCause(cause) : cause,
+					...cause.cleanup === undefined ? {} : { cleanup: cause.cleanup },
+					...cause.partialObservation === undefined ? {} : { partialObservation: cause.partialObservation }
+				});
+				bindArtifactFileCleanup(cause, error);
+				return error;
+			}
+			if (cause instanceof AnalysisInputError || cause instanceof AnalysisCancelledError || cause instanceof AnalysisUnsupportedTargetError) return cause;
 			return new ArtifactOperationError(operation, "io");
 		};
 		subjectFor = (path, manifest) => ({