rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{native__NativeMacOSProvider-YBTvUeJO.js → native__NativeMacOSProvider-DTcRhuGA.js}

@@ -1,37 +1,188 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { analysisInputErrorFromIssues, compareUnicodeCodePoints, err, init_binaryTargetTypes, init_inputIssueProjection, init_machoCpuIdentity, init_objcSwiftMetadata, init_result, init_swiftSymbolClassification, init_unicodeCodePointOrder, isMachOFormat, isSwiftMangledSymbolName, machoCpuSubtypeBase, nativeDispatchMetadataResultSchema, objcSwiftMetadataSchema, ok } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
-import { NATIVE_TOOL_CONTRACTS, init_nativeToolContracts } from "./cutterToolContracts-TZH9EHr5.js";
-import { AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisError, AnalysisInputError, AnalysisOutputError, AnalysisResourceConstraintError, AnalysisTimeoutError, BinaryTargetError, init_analysisErrorBase, init_analysisErrorCore, init_configurationErrors, init_jsonValue, jsonValueSchema } from "./errorSchemas-CTRmvMl3.js";
-import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-BXkffc1D.js";
-import { OwnedFileHandle, init_OwnedFileHandle, init_RegularFile, openRegularFile } from "./RegularFile-B_6KPCNQ.js";
-import { createAnalysisExecution, init_AnalysisProvider } from "./AnalysisProvider-D0Us2OTk.js";
-import { ArtifactResourceScope, init_ArtifactResourceScope } from "./ArtifactResourceScope-DQWTcUwE.js";
-import { ProviderAdapterError, init_providerAdapterError } from "./providerAdapterError-DAjhICdr.js";
-import { EvidenceIntegrityError, init_evidenceErrors } from "./analysisErrorPresentation-DGt7TdsH.js";
-import { init_analysisErrorProjection, projectAnalysisError } from "./cliResultOutput-DsRMI8CJ.js";
-import { analysisErrorWithCleanupFailure, init_analysisErrorCleanup } from "./analysisErrorCleanup-Do6YeeoD.js";
-import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-Ceq8f0wK.js";
-import { ProviderProcessSupervisor, init_ProviderProcess, init_snapshotEnvironment, snapshotEnvironment, spawnOwnedProviderProcess } from "./snapshotEnvironment-D_tWyOub.js";
-import { SWIFTC_INTERRUPT, cleanupOwnedProcessGroup, init_DarwinProcessRunTokenReader, init_ProcessOwnership, init_ProcessOwnershipObservation, observeProcessStartIdentity, signalProcessWithStartIdentity } from "./ProcessOwnership-DXC5-UWt.js";
-import { execFileOutput, init_ExecFileOutput } from "./ExecFileOutput-BEQs-lDD.js";
+import { analysisInputErrorFromIssues, compareUnicodeCodePoints, createPlistNumberProjection, err, incompletePlistNumberLimitation, init_binaryTargetTypes, init_inputIssueProjection, init_machoCpuIdentity, init_objcSwiftMetadata, init_plistNumbers, init_result, init_swiftSymbolClassification, init_unicodeCodePointOrder, isAppleDispatchMetadataTarget, isMachOFormat, isSwiftMangledSymbolName, machoCpuSubtypeBase, nativeDispatchMetadataResultSchema, objcSwiftMetadataSchema, ok } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { NATIVE_TOOL_CONTRACTS, init_nativeToolContracts } from "./cutterToolContracts-BQtG_Nzo.js";
+import { AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisError, AnalysisInputError, AnalysisOutputError, AnalysisResourceConstraintError, AnalysisTimeoutError, BinaryTargetError, init_analysisErrorBase, init_analysisErrorCore, init_configurationErrors, init_jsonValue, jsonValueSchema, resolvedAnalysisError } from "./errorSchemas-Ixz_q7qt.js";
+import { OwnedFileHandle, RegularFileCancelled, RegularFileChangedError, RegularFileCleanupFailure, RegularFileOperationCancelled, assertRegularFileActive, init_OwnedFileHandle, init_OwnedRegularFile, init_RegularFile, regularFileCancellation } from "./OwnedRegularFile-D1f5nUCx.js";
+import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-DMwm42bk.js";
+import { AnalysisCleanupLease, AnalysisCleanupLeaseGroup, init_AnalysisCleanupLease } from "./AnalysisCleanupLease-CWfTGYKd.js";
+import { ArtifactFileCleanupFailure, artifactFileCancellationCause, artifactFilePrimaryFailure, bindArtifactFileCleanup, init_ArtifactFileOperation, withArtifactRegularFile } from "./ArtifactFileOperation-Dg4BcoEM.js";
+import { createAnalysisExecution, init_AnalysisProvider } from "./AnalysisProvider-BGrYaMVo.js";
+import { ArtifactResourceRetryFailure, ArtifactResourceScope, init_ArtifactResourceScope } from "./ArtifactResourceScope-CokZGcII.js";
+import { EvidenceIntegrityError, ProviderAdapterError, init_analysisErrorProjection, init_evidenceErrors, init_providerAdapterError, projectAnalysisError } from "./cliResultOutput-10sd6xGx.js";
+import { analysisErrorWithCleanupFailure, init_analysisErrorCleanup } from "./analysisErrorCleanup-COdAmDsb.js";
+import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-BhsJyAhk.js";
+import { SWIFTC_INTERRUPT, init_DarwinProcessRunTokenReader, init_ProcessOwnershipObservation, observeProcessStartIdentity, signalProcessWithStartIdentity } from "./ProcessOwnershipObservation-C006iCtZ.js";
+import { ExecFileOutputCancelledError, execFileOutput, init_ExecFileOutput } from "./ExecFileOutput-D6KLYTve.js";
 import { init_safeJson, safeParseJson } from "./safeJson-DKKACtdy.js";
-import { ProviderStartupDeadline, init_ProviderDeadline, waitForAbortableDelay } from "./ProviderDeadline-8m2pFRDc.js";
-import { PrivateRuntimeRoot, init_PrivateRuntimeRoot } from "./PrivateRuntimeRoot-DAy0PiBM.js";
-import { demangleSwiftSchema, init_nativeCallObservation, init_nativeInspection, init_nativeUiObservation, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, nativeCallEventSchema, nativeCallObservationInputSchema, nativeCallObservationResultSchema, nativeCodeLocationSchema, nativeUiObservationInputSchema, nativeUiResultSchema, nativeUiScenarioInputSchema, nativeUiSnapshotSchema } from "./toolOutputSchemaGroups-DRiYs1je.js";
-import { init_BoundedFileBytes, readBoundedFileBytes } from "./BoundedFileBytes-BU30odTm.js";
-import { init_machoContainer, readFatSliceDeclarations, validateFatSlice } from "./machoContainer-C8BIkkq3.js";
-import { init_plistValue, init_propertyListKeys, omitPrototypeKeys, omittedPrototypeKeysLimitation, parseXmlPropertyList, projectPlistValue } from "./propertyListKeys-G8e74YWb.js";
-import { init_toolContracts, toolContract } from "./toolContracts-D2FOG_Nb.js";
-import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, NATIVE_COMMAND_TIMEOUT_MS, NativeCommandFailure, XcrunCommandRunner, failureCapture, init_CommandRunner, init_lipo, parseLipoOutput, resolveXcrunTool } from "./lipo-DSWP6fv-.js";
-import { NATIVE_MACOS_PROVIDER_IDENTITY, init_NativeMacOSProviderMetadata, nativeMacOSCapabilities } from "./binary-BVOr2mgE.js";
+import { ProviderProcessSupervisor, init_ProviderProcess, spawnOwnedProviderProcess } from "./ProviderProcess-D87A7ctp.js";
+import { cleanupOwnedProcessGroup, init_ProcessOwnership } from "./ProcessOwnership-CtrNr6ee.js";
+import { ProviderStartupDeadline, init_ProviderDeadline, waitForAbortableDelay } from "./ProviderDeadline-rSuH4Pm8.js";
+import { init_snapshotEnvironment, snapshotEnvironment } from "./snapshotEnvironment-Yvx5qwsl.js";
+import { PrivateRuntimeRoot, init_PrivateRuntimeRoot } from "./PrivateRuntimeRoot-Cd23u6jd.js";
+import { demangleSwiftSchema, init_nativeCallObservation, init_nativeInspection, init_nativeUiObservation, init_plistValue, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, nativeCallEventSchema, nativeCallObservationInputSchema, nativeCallObservationResultSchema, nativeCapturedOutputSchema, nativeCodeLocationSchema, nativeUiObservationInputSchema, nativeUiResultSchema, nativeUiScenarioInputSchema, nativeUiSnapshotSchema, negativeZeroReal, negativeZeroRealLimitation, nonFiniteRealLimitation, projectPlistValue, unknownDateLimitation, unknownRealLimitation } from "./toolOutputSchemaGroups-BqdSzySu.js";
+import { init_BoundedFileBytes, readBoundedFileBytes } from "./BoundedFileBytes-DRtiQNAQ.js";
+import { hashStableFile, init_StableFileHash, stableFileHashCause } from "./StableFileHash-Ame_h3lY.js";
+import { init_machoContainer, readFatSliceDeclarations, validateFatSlice } from "./machoContainer-Cy98bkFm.js";
+import { init_propertyListKeys, omitPrototypeKeys, omittedPrototypeKeysLimitation, parseXmlPropertyList } from "./propertyListKeys-D5dSASEy.js";
+import { init_toolContracts, toolContract } from "./toolContracts-CJzEyZ38.js";
+import { NATIVE_COMMAND_OUTPUT_BUDGET_BYTES, NATIVE_COMMAND_TIMEOUT_MS, NativeCommandFailure, XcrunCommandRunner, failureCapture, init_CommandRunner, init_lipo, parseLipoOutput, resolveXcrunTool } from "./lipo-DPQ6qurH.js";
+import { NATIVE_MACOS_PROVIDER_IDENTITY, init_NativeMacOSProviderMetadata, nativeMacOSCapabilities } from "./binary-CWVNJhAC.js";
 import { z } from "zod";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
-import { lstat, mkdir, mkdtemp, open, readFile, realpath, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { constants } from "node:fs";
-import { fileURLToPath } from "node:url";
 import { tmpdir } from "node:os";
+import { lstat, mkdir, mkdtemp, open, realpath, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 
+//#region dist/native/NativePlistSource.js
+var resolveNativePlistSelection, macOSBundleRoot, unreadablePlist, nativePlistFailure, readPlistFile, requireRegularPlist, PLIST_MARKUP_PROBE_BYTES, plistSourceFormat;
+function init_NativePlistSource() {
+	return (init_NativePlistSource = __esmMin((() => {
+		init_analysisErrorCore();
+		init_configurationErrors();
+		init_providerAdapterError();
+		init_providerCleanupError();
+		init_analysisErrorProjection();
+		init_result();
+		init_ArtifactReader();
+		init_ArtifactFileOperation();
+		init_NativeMacOSProviderMetadata();
+		resolveNativePlistSelection = async (target, requested) => {
+			try {
+				if (requested !== undefined && isAbsolute(requested)) return ok({
+					path: resolve(requested),
+					origin: "selected"
+				});
+				if (requested === undefined && target.kind === "artifact" && target.format === "plist") return ok({
+					path: target.path,
+					origin: "selected"
+				});
+				const source = target.sourcePath ?? target.path;
+				const sourceMetadata = await stat(source);
+				const root = sourceMetadata.isDirectory() ? source : macOSBundleRoot(target.path) ?? dirname(target.path);
+				if (requested !== undefined) return ok({
+					path: resolve(root, requested),
+					origin: "selected"
+				});
+				return ok({
+					path: target.bundleInfoPlist ?? resolve(root, "Contents/Info.plist"),
+					origin: "default"
+				});
+			} catch (cause) {
+				return err(new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_plist", { cause }));
+			}
+		};
+		macOSBundleRoot = (path) => {
+			const programs = dirname(path);
+			const contents = dirname(programs);
+			return basename(programs) === "MacOS" && basename(contents) === "Contents" ? dirname(contents) : undefined;
+		};
+		unreadablePlist = (selection, reason, options) => {
+			const { path } = selection;
+			const sentence = reason.endsWith(".") ? reason : `${reason}.`;
+			const missingDefault = `The target has no readable default plist at ${path}: ${sentence} Select another plist in the target with the path input (CLI: --relative-path).`;
+			return selection.origin === "default" ? new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_plist", missingDefault, {
+				...options,
+				userMessage: missingDefault
+			}) : new AnalysisInputError("inspect_plist", options, [{
+				path: ["path"],
+				reason: "invalid_value",
+				message: `Cannot inspect ${path}: ${sentence}`
+			}]);
+		};
+		nativePlistFailure = (cause, selection, capturedOutput) => {
+			if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined) {
+				const physical = cause instanceof ArtifactFileCleanupFailure ? cause.fileCleanupFailure : undefined;
+				const previous = physical?.outcome.kind === "failed" ? nativePlistFailure(artifactFilePrimaryFailure(cause), selection, capturedOutput) : physical?.completionCancellation === undefined ? undefined : new AnalysisCancelledError("inspect_plist", {
+					cause: physical.completionCancellation.reason,
+					capturedOutput
+				});
+				const previousProjection = previous === undefined ? null : projectAnalysisError(previous);
+				const previousDetails = previousProjection?.details;
+				const { captured_output: _capture, ...reasonDetails } = previousDetails ?? {};
+				const previousError = previousProjection === null ? null : {
+					...previousProjection,
+					...previousDetails === undefined ? {} : { details: reasonDetails }
+				};
+				const failure = new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, cause.cleanup.resources, {
+					reason: cause.cleanup.reason,
+					previous_error: previousError
+				}, {
+					operation: "inspect_plist",
+					cause,
+					cleanupPrimary: previous,
+					capturedOutput
+				});
+				bindArtifactFileCleanup(cause, failure);
+				return failure;
+			}
+			if (cause instanceof ArtifactReaderFailure && cause.reason === "cancelled") return new AnalysisCancelledError("inspect_plist", {
+				cause: artifactFileCancellationCause(cause),
+				capturedOutput
+			});
+			if (cause instanceof ArtifactReaderFailure && cause.reason === "unavailable") return new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_plist", cause.message, {
+				cause,
+				capturedOutput
+			});
+			if (selection === undefined) return new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_plist", {
+				cause,
+				capturedOutput,
+				diagnostics: {
+					phase: "plist-scope",
+					reason: cause instanceof Error ? cause.message : String(cause)
+				}
+			});
+			const { path } = selection;
+			const code = cause instanceof Error && "code" in cause ? cause.code : undefined;
+			if (code === "ENOENT" || code === "ENOTDIR") return unreadablePlist(selection, "no file exists there", {
+				cause,
+				capturedOutput
+			});
+			if (code === "EISDIR" || code === "ENOTFILE") return unreadablePlist(selection, "it is not a regular file", {
+				cause,
+				capturedOutput
+			});
+			if (code === "EACCES" || code === "EPERM") return new BinaryTargetError(path, `permission denied while reading plist (${code})`, {
+				cause,
+				capturedOutput
+			});
+			return new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_plist", {
+				cause,
+				capturedOutput,
+				diagnostics: {
+					path,
+					phase: "plist-file",
+					reason: cause instanceof Error ? cause.message : String(cause)
+				}
+			});
+		};
+		readPlistFile = async (input, read) => {
+			try {
+				return ok(await withArtifactRegularFile(input.selection.path, input.resources, input.signal, read, "follow"));
+			} catch (cause) {
+				return err(nativePlistFailure(cause, input.selection, input.capturedOutput));
+			}
+		};
+		requireRegularPlist = (input) => readPlistFile(input, async () => null);
+		PLIST_MARKUP_PROBE_BYTES = 4096;
+		plistSourceFormat = async (description, input) => {
+			if (/binary property list/iu.test(description)) return ok("binary");
+			if (/\bXML\b/iu.test(description)) return ok("xml");
+			if (/\bJSON\b/iu.test(description)) return ok("json");
+			if (!/\btext\b/iu.test(description)) return ok("unknown");
+			return readPlistFile(input, async (file) => {
+				const head = Buffer.alloc(PLIST_MARKUP_PROBE_BYTES);
+				const { bytesRead } = await file.read(head, 0, head.length, 0);
+				const encoding = head[0] === 255 && head[1] === 254 ? "utf-16le" : head[0] === 254 && head[1] === 255 ? "utf-16be" : "utf-8";
+				const text = new TextDecoder(encoding).decode(head.subarray(0, bytesRead)).trimStart();
+				return /^<(?:[!?]|(?:plist|dict|array|string|integer|real|data|date|true|false)[\s/>])/u.test(text) ? "xml" : "unknown";
+			});
+		};
+	})))();
+}
+
+//#endregion
 //#region dist/native/AppleDispatchCoverage.js
 var describeFixups, pushDispatchCoverage, formatIssue;
 function init_AppleDispatchCoverage() {
@@ -418,27 +569,30 @@ function init_AppleMachoFixups() {
 		};
 		uleb = (bytes, cursor, end) => {
 			let value = 0n;
-			let shift = 0n;
+			let shift = 0;
 			for (;;) {
 				if (cursor.at >= end) throw new RangeError("Truncated bind opcode operand");
 				const byte = bytes[cursor.at++] ?? 0;
-				value |= BigInt(byte & 127) << shift;
-				shift += 7n;
+				const slice = byte & 127;
+				if (shift === 63 && slice > 1 || shift === 64 && slice !== 0) throw new RangeError("Oversized bind opcode operand");
+				if (shift < 64) value |= BigInt(slice) << BigInt(shift);
+				shift = Math.min(64, shift + 7);
 				if ((byte & 128) === 0) return value;
-				if (shift > 63n) throw new RangeError("Oversized bind opcode operand");
 			}
 		};
 		sleb = (bytes, cursor, end) => {
 			let value = 0n;
-			let shift = 0n;
+			let shift = 0;
 			let byte = 0;
 			do {
 				if (cursor.at >= end) throw new RangeError("Truncated bind opcode operand");
 				byte = bytes[cursor.at++] ?? 0;
-				value |= BigInt(byte & 127) << shift;
-				shift += 7n;
-			} while ((byte & 128) !== 0 && shift <= 63n);
-			return (byte & 64) !== 0 ? value - (1n << shift) : value;
+				const slice = byte & 127;
+				if (shift === 63 && slice !== 0 && slice !== 127 || shift === 64 && slice !== (value < 0n ? 127 : 0)) throw new RangeError("Oversized bind opcode operand");
+				if (shift < 64) value = BigInt.asIntN(64, value | BigInt(slice) << BigInt(shift));
+				shift = Math.min(64, shift + 7);
+			} while ((byte & 128) !== 0);
+			return shift < 64 && (byte & 64) !== 0 ? value - (1n << BigInt(shift)) : value;
 		};
 		setBindRegister = (image, stream, state, byte) => {
 			const { bytes } = image;
@@ -914,28 +1068,37 @@ function init_AppleMachoSelection() {
 
 //#endregion
 //#region dist/native/AppleObjcProperties.js
-var parsePropertyAttributes, splitAttributes, readObjcPropertyList, readObjcPropertiesOf;
+var parsePropertyAttributes, decodePropertyAttributes, splitAttributes, readObjcPropertyList, readObjcPropertiesOf;
 function init_AppleObjcProperties() {
 	return (init_AppleObjcProperties = __esmMin((() => {
 		init_AppleDispatchDecodeFacts();
-		parsePropertyAttributes = (name, attributes) => {
-			const tokens = attributes.length === 0 ? [] : splitAttributes(attributes);
+		parsePropertyAttributes = (name, attributes) => decodePropertyAttributes(name, attributes).property;
+		decodePropertyAttributes = (name, attributes) => {
+			const { tokens, complete } = attributes.length === 0 ? {
+				tokens: [],
+				complete: true
+			} : splitAttributes(attributes);
 			const typeAttributes = tokens.filter((token) => token[0] === "T");
 			const typeAttribute = typeAttributes.length === 1 ? typeAttributes[0] : undefined;
 			const typeEncoding = typeAttribute !== undefined && typeAttribute.length > 1 ? typeAttribute.slice(1) : null;
 			const value = (code) => tokens.find((token) => token[0] === code)?.slice(1) ?? null;
-			return {
+			const defaultsEstablished = typeEncoding !== null && complete;
+			const property = {
 				name,
 				type_encoding: typeEncoding,
 				attributes: tokens.map((token) => ({
 					name: token.slice(0, 1),
 					value: token.slice(1)
 				})),
-				atomicity: tokens.includes("N") ? "nonatomic" : typeEncoding === null ? null : "atomic",
-				is_readonly: tokens.includes("R") ? true : typeEncoding === null ? null : false,
+				atomicity: tokens.includes("N") ? "nonatomic" : defaultsEstablished ? "atomic" : null,
+				is_readonly: tokens.includes("R") ? true : defaultsEstablished ? false : null,
 				getter: value("G"),
 				setter: value("S")
 			};
+			return {
+				property,
+				complete
+			};
 		};
 		splitAttributes = (attributes) => {
 			const tokens = [];
@@ -949,24 +1112,53 @@ function init_AppleObjcProperties() {
 				} else current += character;
 			}
 			tokens.push(current);
-			return tokens.filter((token) => token.length > 0);
+			return {
+				tokens: tokens.filter((token) => token.length > 0),
+				complete: !quoted
+			};
 		};
 		readObjcPropertyList = (read, list, admit) => {
-			if (list === 0n) return [];
+			const properties = [];
+			const issues = [];
+			if (list === 0n) return {
+				properties,
+				issues
+			};
 			const entrySize = read.u32(list) & ~3;
 			const count = read.u32(list + 4n);
 			if (entrySize !== 16) throw new TypeError(`Unsupported Objective-C property entry size ${entrySize}`);
-			const properties = [];
 			for (let index = 0; index < count; index++) {
 				if (!admit()) break;
 				const entry = list + 8n + BigInt(index * entrySize);
-				properties.push(parsePropertyAttributes(read.string(read.pointer(entry)), read.string(read.pointer(entry + 8n))));
+				const location = `0x${entry.toString(16)}`;
+				try {
+					const name = read.string(read.pointer(entry));
+					if (name.length === 0) throw new TypeError("the property name is empty");
+					const decoded = decodePropertyAttributes(name, read.string(read.pointer(entry + 8n)));
+					properties.push(decoded.property);
+					if (!decoded.complete) issues.push({
+						code: "property_attributes_incomplete",
+						message: `property ${name} has an unterminated quoted class name in its type attribute, so atomicity and unestablished read-only state are unknown`,
+						location
+					});
+				} catch (cause) {
+					issues.push({
+						code: "property_decode_failed",
+						message: `property ${String(index)} could not be decoded: ${cause instanceof Error ? cause.message : String(cause)}`,
+						location
+					});
+				}
 			}
-			return properties;
+			return {
+				properties,
+				issues
+			};
 		};
 		readObjcPropertiesOf = (read, list, context) => {
 			try {
-				return readObjcPropertyList(read, list, context.admit);
+				const { properties, issues } = readObjcPropertyList(read, list, context.admit);
+				for (const item of issues) context.issues.push(issue("objc_properties_categories", item.code, `${context.owner}: ${item.message}`, item.location));
+				return properties;
 			} catch (cause) {
 				context.issues.push(issue("objc_properties_categories", "property_decode_failed", `${context.owner}: ${cause instanceof Error ? cause.message : String(cause)}`, context.location));
 				return [];
@@ -999,9 +1191,15 @@ function init_AppleObjcCategories() {
 					try {
 						const category = read.pointer(field);
 						const name = read.string(read.pointer(category));
+						if (name.length === 0) throw new TypeError("Objective-C category has an empty name");
 						const external = boundClassName(read, category + 8n);
 						const local = read.pointer(category + 8n);
-						const className = external ?? (local === 0n ? null : input.localClassName(local));
+						let className = external ?? null;
+						if (external === undefined && local !== 0n) try {
+							className = input.localClassName(local);
+						} catch (cause) {
+							input.issues.push(issue("objc_properties_categories", "category_class_unresolved", `Category ${name} class reference 0x${local.toString(16)}: ${cause instanceof Error ? cause.message : String(cause)}`, `0x${(category + 8n).toString(16)}`));
+						}
 						const owner = className ?? `(${name})`;
 						result.objc_categories.push({
 							name,
@@ -1059,7 +1257,7 @@ function init_AppleObjcProtocols() {
 				}
 				return names;
 			};
-			const methods = (address, required, instance) => {
+			const methods = (address, required, instance, emptySelectors) => {
 				const output = [];
 				if (address === 0n) return output;
 				const flags = read.u32(address), count = read.u32(address + 4n);
@@ -1071,8 +1269,13 @@ function init_AppleObjcProtocols() {
 					const entry = address + 8n + BigInt(index * stride);
 					let selector = relative ? entry + BigInt(read.i32(entry)) : read.pointer(entry);
 					if (relative && (flags & 1073741824) === 0) selector = read.pointer(selector);
+					const selectorName = read.string(selector);
+					if (selectorName.length === 0) {
+						emptySelectors.push(`${required ? "required" : "optional"} ${instance ? "instance" : "class"} method ${String(index)} at 0x${entry.toString(16)} has an empty selector`);
+						continue;
+					}
 					output.push({
-						selector: read.string(selector),
+						selector: selectorName,
 						method_type: instance ? "instance" : "class",
 						address: null,
 						is_required: required,
@@ -1088,8 +1291,11 @@ function init_AppleObjcProtocols() {
 					if (read.u32(address + 64n) < 72) throw new RangeError("Truncated Objective-C protocol declaration");
 					const protocolName = name(address);
 					const adopted = list(read.pointer(address + 16n));
-					const required = [...methods(read.pointer(address + 24n), true, true), ...methods(read.pointer(address + 32n), true, false)];
-					const optional = [...methods(read.pointer(address + 40n), false, true), ...methods(read.pointer(address + 48n), false, false)];
+					if (protocolName.length === 0) throw new TypeError("Objective-C protocol has an empty name");
+					const skipped = [];
+					const required = [...methods(read.pointer(address + 24n), true, true, skipped), ...methods(read.pointer(address + 32n), true, false, skipped)];
+					const optional = [...methods(read.pointer(address + 40n), false, true, skipped), ...methods(read.pointer(address + 48n), false, false, skipped)];
+					for (const message of skipped) failures.push(`Protocol 0x${address.toString(16)}: Objective-C protocol ${protocolName} ${message}`);
 					result.objc_protocols.push({
 						name: protocolName,
 						methods: required,
@@ -1102,9 +1308,12 @@ function init_AppleObjcProtocols() {
 						methods: required,
 						optional_methods: optional,
 						location: read.location(address),
-						decode: {
+						decode: skipped.length === 0 ? {
 							status: "decoded",
 							reason: null
+						} : {
+							status: "partial",
+							reason: "protocol_method_selector_empty"
 						},
 						evidence: read.evidence(address, "Objective-C protocol declaration and encoded method lists; IMP fields are not handler targets")
 					});
@@ -1122,7 +1331,7 @@ function init_AppleObjcProtocols() {
 
 //#endregion
 //#region dist/native/AppleObjcDispatchFacets.js
-var hex$1, decoded$1, localClassName, resolveSuperclass, decodeObjcDispatchFacets;
+var hex$1, decoded$1, readLocalClass, resolveSuperclass, decodeObjcDispatchFacets;
 function init_AppleObjcDispatchFacets() {
 	return (init_AppleObjcDispatchFacets = __esmMin((() => {
 		init_result();
@@ -1134,7 +1343,15 @@ function init_AppleObjcDispatchFacets() {
 			status: "decoded",
 			reason: null
 		};
-		localClassName = (read, address) => read.string(read.pointer((read.pointer(address + 32n) & ~7n) + 24n));
+		readLocalClass = (read, address) => {
+			const ro = read.pointer(address + 32n) & ~7n;
+			const name = read.string(read.pointer(ro + 24n));
+			if (name.length === 0) throw new TypeError(`Objective-C class at ${hex$1(address)} has an empty name`);
+			return {
+				ro,
+				name
+			};
+		};
 		resolveSuperclass = (read, address, className, failures) => {
 			const external = boundClassName(read, address + 8n);
 			if (external !== undefined) return {
@@ -1148,12 +1365,11 @@ function init_AppleObjcDispatchFacets() {
 			};
 			try {
 				return {
-					name: localClassName(read, superclass),
+					name: readLocalClass(read, superclass).name,
 					address: hex$1(superclass)
 				};
 			} catch (cause) {
-				void cause;
-				failures.push(`Superclass pointer ${hex$1(superclass)} of ${className} requires unsupported binding/fixup resolution`);
+				failures.push(`Superclass pointer ${hex$1(superclass)} of ${className} could not be decoded: ${cause instanceof Error ? cause.message : String(cause)}`);
 				return {
 					name: null,
 					address: hex$1(superclass)
@@ -1211,6 +1427,7 @@ function init_AppleObjcDispatchFacets() {
 						void cause;
 					}
 					const selector = read.string(selectorAddress);
+					if (selector.length === 0) throw new TypeError("Objective-C method has an empty selector");
 					selectors.push(selector);
 					result.objc_dispatch_implementations.push({
 						class_name: className,
@@ -1287,9 +1504,7 @@ function init_AppleObjcDispatchFacets() {
 			const readClass = (address, meta = false) => {
 				if (address === 0n || visited.has(hex$1(address)) || !budget.admit()) return;
 				visited.add(hex$1(address));
-				const ro = read.pointer(address + 32n) & ~7n;
-				const name = read.string(read.pointer(ro + 24n));
-				if (name.length === 0) throw new TypeError(`Objective-C class at ${hex$1(address)} has an empty name`);
+				const { ro, name } = readLocalClass(read, address);
 				const root = (read.u32(ro) & 2) !== 0;
 				const superclass = resolveSuperclass(read, address, name, failures);
 				if (superclass.name === null && superclass.address === null && !root) failures.push(`Superclass of ${name} requires external binding resolution`);
@@ -1310,10 +1525,12 @@ function init_AppleObjcDispatchFacets() {
 							void cause;
 							failures.push(`Unresolved ivar offset pointer ${hex$1(encodedOffset)}`);
 						}
+						const ivarName = read.string(read.pointer(entry + 8n));
+						if (ivarName.length === 0) throw new TypeError("Objective-C ivar has an empty name");
 						const alignment = read.u32(entry + 24n);
 						result.objc_ivars.push({
 							class_name: name,
-							name: read.string(read.pointer(entry + 8n)),
+							name: ivarName,
 							type_encoding: read.string(read.pointer(entry + 16n)),
 							offset: value,
 							size: read.u32(entry + 28n),
@@ -1398,7 +1615,7 @@ function init_AppleObjcDispatchFacets() {
 				admit: () => budget.admit(),
 				methods,
 				protocols: (list) => protocolReader.list(list),
-				localClassName: (address) => localClassName(read, address)
+				localClassName: (address) => readLocalClass(read, address).name
 			});
 			return {
 				failures,
@@ -1597,6 +1814,7 @@ function init_AppleSwiftVtables() {
 					const positiveWords = read.u32(descriptor + 28n);
 					if (count > 2e4 || tableOffset + count > positiveWords) throw new RangeError("Swift vtable count or offset exceeds declared metadata bounds");
 					const owner = read.string(read.relative(descriptor + 8n));
+					if (owner.length === 0) throw new RangeError("Swift class vtable descriptor class name is empty");
 					for (let index = 0; index < count; index++) {
 						const entry = header + 8n + BigInt(index * 8);
 						if (!read.admit()) {
@@ -1652,13 +1870,19 @@ function init_AppleSwiftVtables() {
 
 //#endregion
 //#region dist/native/AppleDispatchMetadata.js
-var decodeAppleDispatchMetadata, inspectAppleDispatchMetadata;
+var decodeAppleDispatchMetadata, inspectAppleDispatchMetadata, OPERATION$3, appleDispatchMetadataFailure;
 function init_AppleDispatchMetadata() {
 	return (init_AppleDispatchMetadata = __esmMin((() => {
 		init_objcSwiftMetadata();
 		init_binaryTargetTypes();
 		init_analysisErrorCore();
-		init_RegularFile();
+		init_ArtifactFileOperation();
+		init_ArtifactReader();
+		init_analysisErrorBase();
+		init_analysisErrorProjection();
+		init_providerAdapterError();
+		init_providerCleanupError();
+		init_NativeMacOSProviderMetadata();
 		init_BoundedFileBytes();
 		init_evidenceErrors();
 		init_AppleDispatchCoverage();
@@ -1699,7 +1923,10 @@ function init_AppleDispatchMetadata() {
 				while (end < bytes.length && end - start < 4096 && bytes[end] !== 0) end++;
 				if (end === bytes.length || end - start >= 4096) throw new RangeError("Unterminated or oversized metadata string");
 				offset(address, end - start + 1);
-				return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(start, end));
+				return new TextDecoder("utf-8", {
+					fatal: true,
+					ignoreBOM: true
+				}).decode(bytes.subarray(start, end));
 			};
 			const result = objcSwiftMetadataSchema.parse({ db_save_result: null });
 			let records = 0;
@@ -1786,37 +2013,99 @@ function init_AppleDispatchMetadata() {
 			});
 			return objcSwiftMetadataSchema.parse(result);
 		};
-		inspectAppleDispatchMetadata = async (target, maxRecords, signal) => {
+		inspectAppleDispatchMetadata = async (target, maxRecords, resources, signal) => {
 			if (target.kind !== "executable" || !isMachOFormat(target.format)) throw new TypeError("Apple dispatch metadata requires a Mach-O target");
 			const maximumBytes = 64 * 1024 * 1024;
 			const capacityError = () => new AnalysisResourceConstraintError("inspect_native_dispatch_metadata", "memory", "Apple static metadata input exceeds its 64 MiB snapshot budget", { input_bytes: maximumBytes });
-			const handle = await openRegularFile(target.path, {
-				symlinks: "reject",
-				signal
-			});
-			try {
+			const cancelled = () => new AnalysisCancelledError("inspect_native_dispatch_metadata", { cause: signal?.reason });
+			const { bytes, digest } = await withArtifactRegularFile(target.path, resources, signal, async (handle) => {
 				const before = await handle.stat();
 				if (before.size > maximumBytes) throw capacityError();
-				if (signal?.aborted) throw new AnalysisCancelledError("inspect_native_dispatch_metadata");
-				const bytes = await readBoundedFileBytes(handle, maximumBytes, signal);
-				if (bytes === undefined) throw capacityError();
-				const digest = createHash("sha256").update(bytes).digest("hex");
-				if (digest !== target.sha256) throw new EvidenceIntegrityError("Apple metadata target digest changed after session binding");
-				return nativeDispatchMetadataResultSchema.parse({
-					target_sha256: target.sha256,
-					provider: {
-						id: "native-macos",
-						name: "macOS native inspection utilities",
-						version: "apple-metadata-reader-1"
-					},
-					analysis_profile_digest: null,
-					result: decodeAppleDispatchMetadata(bytes, maxRecords, {
-						path: target.path,
-						sha256: digest
-					}, target.architecture)
+				if (signal?.aborted) throw cancelled();
+				const read = await readBoundedFileBytes(handle, maximumBytes, signal).catch((cause) => {
+					if (signal?.aborted === true && cause === signal.reason) throw cancelled();
+					throw cause;
 				});
-			} finally {
-				await handle.close();
+				if (read === undefined) throw capacityError();
+				const sha256 = createHash("sha256").update(read).digest("hex");
+				if (sha256 !== target.sha256) throw new EvidenceIntegrityError("Apple metadata target digest changed after session binding");
+				return {
+					bytes: read,
+					digest: sha256
+				};
+			}, "reject");
+			return nativeDispatchMetadataResultSchema.parse({
+				target_sha256: target.sha256,
+				provider: {
+					id: "native-macos",
+					name: "macOS native inspection utilities",
+					version: "apple-metadata-reader-1"
+				},
+				analysis_profile_digest: null,
+				result: decodeAppleDispatchMetadata(bytes, maxRecords, {
+					path: target.path,
+					sha256: digest
+				}, target.architecture)
+			});
+		};
+		OPERATION$3 = "inspect_native_dispatch_metadata";
+		appleDispatchMetadataFailure = (cause, path) => {
+			if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined) {
+				const physical = cause instanceof ArtifactFileCleanupFailure ? cause.fileCleanupFailure : undefined;
+				const previous = physical?.outcome.kind === "failed" ? appleDispatchMetadataFailure(artifactFilePrimaryFailure(cause), path) : physical?.completionCancellation === undefined ? undefined : new AnalysisCancelledError(OPERATION$3, { cause: physical.completionCancellation.reason });
+				const failure = new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, cause.cleanup.resources, {
+					reason: cause.cleanup.reason,
+					previous_error: previous === undefined ? null : projectAnalysisError(previous)
+				}, {
+					operation: OPERATION$3,
+					cause,
+					cleanupPrimary: previous
+				});
+				bindArtifactFileCleanup(cause, failure);
+				return failure;
+			}
+			if (cause instanceof AnalysisError) return cause;
+			if (cause instanceof ArtifactReaderFailure && cause.reason === "cancelled") return new AnalysisCancelledError(OPERATION$3, { cause: artifactFileCancellationCause(cause) });
+			if (cause instanceof ArtifactReaderFailure && cause.reason === "unavailable") return new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, OPERATION$3, cause.message, { cause });
+			return new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, OPERATION$3, {
+				cause,
+				diagnostics: {
+					target_path: path,
+					reason: cause instanceof Error ? cause.message : String(cause)
+				}
+			});
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/native/NativeUiCleanupError.js
+var NativeUiCleanupError;
+function init_NativeUiCleanupError() {
+	return (init_NativeUiCleanupError = __esmMin((() => {
+		init_AnalysisCleanupLease();
+		init_providerCleanupError();
+		NativeUiCleanupError = class extends ProviderCleanupError {
+			runtimes;
+			constructor(failures, operation, partialObservation) {
+				const runtimes = failures.map(({ runtime }) => runtime);
+				const resources = () => runtimes.filter((runtime) => !runtime.cleanupLease.released).flatMap((runtime) => runtime.resources());
+				super("native-macos", resources(), {
+					reason: "Native UI runtime cleanup remains incomplete",
+					failures: failures.map(({ runtime, cause }) => ({
+						resources: [...runtime.resources()],
+						reason: cause instanceof Error ? cause.message : String(cause)
+					}))
+				}, {
+					operation,
+					cause: new AggregateError(failures.map(({ cause }) => cause), "Native UI runtime cleanup failed"),
+					partialObservation
+				});
+				this.runtimes = runtimes;
+				new AnalysisCleanupLeaseGroup(this, runtimes.map((runtime) => runtime.cleanupLease));
+				this.bindCleanupResourceOwner({ get cleanupResources() {
+					return resources();
+				} });
 			}
 		};
 	})))();
@@ -1843,6 +2132,8 @@ function init_NativeUiOutputBudget() {
 var createNativeUiHelperRuntime;
 function init_NativeUiHelperRuntime() {
 	return (init_NativeUiHelperRuntime = __esmMin((() => {
+		init_ArtifactResourceScope();
+		init_AnalysisCleanupLease();
 		init_snapshotEnvironment();
 		init_DarwinProcessRunTokenReader();
 		init_ExecFileOutput();
@@ -1850,59 +2141,68 @@ function init_NativeUiHelperRuntime() {
 		init_NativeUiOutputBudget();
 		createNativeUiHelperRuntime = (environment) => {
 			const selectedEnvironment = snapshotEnvironment(environment);
+			const deadlineSignal = AbortSignal.timeout(18e4);
+			const operations = new ArtifactResourceScope();
 			let root;
-			let executable;
-			const invoke = async (parameters, signal) => {
-				if (executable === undefined) {
-					root = await mkdtemp(join(tmpdir(), "rea-native-ui-"));
-					const output = join(root, "observer");
-					const main = join(root, "main.swift");
-					await symlink(fileURLToPath(new URL("../../bridge/native/ReaNativeUI.swift", new URL("../native/NativeUiHelperRuntime.js", import.meta.url).href)), main);
-					const compilerTemporary = join(root, "tmp");
-					await mkdir(compilerTemporary);
-					await execFileOutput("/usr/bin/xcrun", [
-						"swiftc",
-						"-module-cache-path",
-						join(root, "modules"),
-						fileURLToPath(new URL("../../bridge/native/NativeUIChildren.swift", new URL("../native/NativeUiHelperRuntime.js", import.meta.url).href)),
-						main,
-						"-o",
-						output
-					], {
-						timeout: 6e4,
-						maxBuffer: 1024 * 1024,
-						stopSignal: SWIFTC_INTERRUPT,
-						env: {
-							...selectedEnvironment,
-							TMPDIR: compilerTemporary
-						},
-						...signal === undefined ? {} : { signal }
+			let preparation;
+			const cleanupLease = new AnalysisCleanupLease(async () => {
+				await operations.close();
+				if (root !== undefined) {
+					await rm(root, {
+						recursive: true,
+						force: true
 					});
-					executable = output;
+					root = undefined;
+					preparation = undefined;
 				}
+			});
+			const prepare = async (signal) => {
+				root = await mkdtemp(join(tmpdir(), "rea-native-ui-"));
+				const output = join(root, "observer");
+				const main = join(root, "main.swift");
+				await symlink(fileURLToPath(new URL("../../bridge/native/ReaNativeUI.swift", new URL("../native/NativeUiHelperRuntime.js", import.meta.url).href)), main);
+				const compilerTemporary = join(root, "tmp");
+				await mkdir(compilerTemporary);
+				await execFileOutput("/usr/bin/xcrun", [
+					"swiftc",
+					"-module-cache-path",
+					join(root, "modules"),
+					fileURLToPath(new URL("../../bridge/native/NativeUIChildren.swift", new URL("../native/NativeUiHelperRuntime.js", import.meta.url).href)),
+					main,
+					"-o",
+					output
+				], {
+					timeout: 6e4,
+					maxBuffer: 1024 * 1024,
+					stopSignal: SWIFTC_INTERRUPT,
+					env: {
+						...selectedEnvironment,
+						TMPDIR: compilerTemporary
+					},
+					signal
+				});
+				return output;
+			};
+			const invoke = (parameters, callerSignal) => operations.run(async () => {
+				const signal = callerSignal === undefined ? deadlineSignal : AbortSignal.any([callerSignal, deadlineSignal]);
+				preparation ??= prepare(signal);
+				const executable = await preparation;
 				const output = await execFileOutput(executable, [JSON.stringify(parameters)], {
 					timeout: 3e4,
 					maxBuffer: NATIVE_UI_HELPER_MAX_BUFFER,
 					stopSignal: "SIGTERM",
 					env: selectedEnvironment,
-					...signal === undefined ? {} : { signal }
+					signal
 				});
 				const parsed = safeParseJson(output.stdout);
 				if (!parsed.ok) throw new Error(`Native helper returned invalid JSON: ${parsed.error}`, { cause: parsed.cause });
 				return parsed.value;
-			};
+			});
 			return {
 				invoke,
-				close: async () => {
-					if (root !== undefined) {
-						await rm(root, {
-							recursive: true,
-							force: true
-						});
-						root = undefined;
-						executable = undefined;
-					}
-				},
+				cleanupLease,
+				signal: deadlineSignal,
+				close: () => cleanupLease.release(),
 				resources: () => root === undefined ? [] : [root]
 			};
 		};
@@ -1911,17 +2211,26 @@ function init_NativeUiHelperRuntime() {
 
 //#endregion
 //#region dist/native/NativeUiObservation.js
-var helper, responseSchema, observeNativeUi, observeWithHelper;
+var helper, passiveInputSchema, responseSchema, observeNativeUi, observeWithHelper, finishNativeUiObservation;
 function init_NativeUiObservation() {
 	return (init_NativeUiObservation = __esmMin((() => {
+		init_ProviderDeadline();
 		init_binaryTargetTypes();
 		init_nativeUiObservation();
 		init_analysisErrorCore();
 		init_providerAdapterError();
+		init_analysisErrorBase();
+		init_analysisErrorCleanup();
+		init_ExecFileOutput();
+		init_NativeUiCleanupError();
 		init_result();
 		init_NativeUiHelperRuntime();
 		init_NativeUiOutputBudget();
 		helper = fileURLToPath(new URL("../../bridge/native/ReaNativeUI.swift", new URL("../native/NativeUiObservation.js", import.meta.url).href));
+		passiveInputSchema = nativeUiObservationInputSchema.transform((input) => ({
+			...input,
+			steps: []
+		}));
 		responseSchema = z.discriminatedUnion("ok", [z.strictObject({
 			ok: z.literal(true),
 			result: nativeUiSnapshotSchema
@@ -1932,28 +2241,43 @@ function init_NativeUiObservation() {
 		})]);
 		observeNativeUi = async (target, operation, parameters, options) => {
 			const runtime = options.runtime ?? createNativeUiHelperRuntime(options.environment);
+			const signal = options.signal === undefined ? runtime.signal : AbortSignal.any([options.signal, runtime.signal]);
+			let result;
 			try {
-				return await observeWithHelper(target, operation, parameters, {
-					...options,
+				result = await observeWithHelper(target, operation, parameters, {
+					signal,
 					invoke: options.invoke ?? runtime.invoke
 				});
-			} finally {
-				if (options.runtime === undefined) await runtime.close();
+			} catch (cause) {
+				result = err(cause instanceof AnalysisError ? cause : new ProviderAdapterError("native-macos", operation, { cause }));
 			}
+			if (options.runtime === undefined) {
+				try {
+					await runtime.close();
+				} catch (cause) {
+					result = finishNativeUiObservation(result, operation, signal);
+					const cleanup = new NativeUiCleanupError([{
+						runtime,
+						cause
+					}], operation, result.ok ? result.value : undefined);
+					return result.ok ? err(cleanup) : err(analysisErrorWithCleanupFailure(result.error, cleanup, operation).bindCleanupDependencies([result.error, cleanup]));
+				}
+			}
+			return finishNativeUiObservation(result, operation, signal);
 		};
 		observeWithHelper = async (target, operation, parameters, options) => {
-			const parsed = (operation === "observe_native_ui" ? nativeUiObservationInputSchema : nativeUiScenarioInputSchema).safeParse(parameters);
+			const parsed = (operation === "observe_native_ui" ? passiveInputSchema : nativeUiScenarioInputSchema).safeParse(parameters);
 			if (!parsed.success) return err(new AnalysisInputError(operation, { cause: parsed.error }));
 			if (target.kind !== "executable" || !isMachOFormat(target.format)) return err(new AnalysisCapabilityUnavailableError("native-macos", operation, "Native UI observation requires an active Mach-O executable or app target"));
 			const input = parsed.data;
 			if (!input.screenshot && !input.accessibility) return err(new AnalysisInputError(operation, { cause: new Error("Enable screenshot or accessibility capture") }));
-			const steps = operation === "capture_native_ui_scenario" ? nativeUiScenarioInputSchema.parse(parameters).steps : [];
-			const signal = options.signal === undefined ? AbortSignal.timeout(18e4) : AbortSignal.any([options.signal, AbortSignal.timeout(18e4)]);
+			const steps = input.steps;
+			const signal = options.signal;
 			const invoke = options.invoke;
 			let launchTime;
 			let outputBytes = 0;
 			const take = async (action) => {
-				if (signal.aborted) return err(new AnalysisCancelledError(operation));
+				if (signal.aborted) return err(new AnalysisCancelledError(operation, { cause: signal.reason }));
 				try {
 					const response = responseSchema.parse(await invoke({
 						pid: input.pid,
@@ -1973,7 +2297,8 @@ function init_NativeUiObservation() {
 					if (outputBytes > 67108864) return err(new AnalysisCapabilityUnavailableError("native-macos", operation, "Scenario captures exceeded the 64 MiB output budget"));
 					return ok(response.result);
 				} catch (cause) {
-					return err(signal.aborted ? new AnalysisCancelledError(operation) : new ProviderAdapterError("native-macos", operation, {
+					if (cause instanceof AnalysisError) return err(cause);
+					return err(cause instanceof ExecFileOutputCancelledError ? new AnalysisCancelledError(operation, { cause: cause.cause }) : new ProviderAdapterError("native-macos", operation, {
 						cause,
 						diagnostics: {
 							helper_path: helper,
@@ -1987,8 +2312,10 @@ function init_NativeUiObservation() {
 			if (!initial.ok) return initial;
 			const results = [];
 			let before = initial.value;
+			let terminalFailure;
 			for (const [index, step] of steps.entries()) {
 				if (signal.aborted) {
+					terminalFailure = new AnalysisCancelledError(operation, { cause: signal.reason });
 					results.push({
 						index,
 						kind: step.kind,
@@ -1999,35 +2326,21 @@ function init_NativeUiObservation() {
 					});
 					break;
 				}
-				if (step.kind === "wait") {
-					try {
-						await new Promise((resolve, reject) => {
-							const abort = () => {
-								clearTimeout(timer);
-								reject(new Error("cancelled"));
-							};
-							const timer = setTimeout(() => {
-								signal.removeEventListener("abort", abort);
-								resolve();
-							}, step.milliseconds);
-							signal.addEventListener("abort", abort, { once: true });
-							if (signal.aborted) abort();
-						});
-					} catch (cause) {
-						void cause;
-						results.push({
-							index,
-							kind: step.kind,
-							before,
-							after: null,
-							outcome: "cancelled",
-							reason: "Scenario cancelled during wait"
-						});
-						break;
-					}
+				if (step.kind === "wait" && await waitForAbortableDelay(step.milliseconds, signal) === "aborted") {
+					terminalFailure = new AnalysisCancelledError(operation, { cause: signal.reason });
+					results.push({
+						index,
+						kind: step.kind,
+						before,
+						after: null,
+						outcome: "cancelled",
+						reason: "Scenario cancelled during wait"
+					});
+					break;
 				}
 				const after = await take(step.kind === "wait" ? undefined : step);
 				if (!after.ok) {
+					terminalFailure = after.error;
 					results.push({
 						index,
 						kind: step.kind,
@@ -2048,7 +2361,7 @@ function init_NativeUiObservation() {
 				});
 				before = after.value;
 			}
-			return ok(nativeUiResultSchema.parse({
+			const report = nativeUiResultSchema.parse({
 				target_sha256: target.sha256,
 				initial: initial.value,
 				steps: results,
@@ -2060,7 +2373,342 @@ function init_NativeUiObservation() {
 					"Scenarios can change app data, cause app network activity and persist changes. The caller explicitly chooses leave-as-is; automatic restoration is unsupported.",
 					"Window matching uses exact PID and window ID for screenshots and unique accessibility geometry. Accessibility paths can change as the UI changes; stale or ambiguous paths fail. Screenshots are scaled to at most 2048 pixels; scenario output is budgeted at 64 MiB and execution is cancelled after 180 seconds."
 				]
-			}));
+			});
+			return terminalFailure === undefined ? finishNativeUiObservation(ok(report), operation, signal) : err(terminalFailure.retainPartialObservation(report));
+		};
+		finishNativeUiObservation = (result, operation, signal) => result.ok && signal?.aborted ? err(new AnalysisCancelledError(operation, {
+			cause: signal.reason,
+			partialObservation: result.value
+		})) : result;
+	})))();
+}
+
+//#endregion
+//#region dist/native/NativeCallTarget.js
+var OPERATION$2, nativeCallTargetFailure, verifyNativeCallTarget;
+function init_NativeCallTarget() {
+	return (init_NativeCallTarget = __esmMin((() => {
+		init_NativeMacOSProviderMetadata();
+		init_analysisErrorCore();
+		init_evidenceErrors();
+		init_providerAdapterError();
+		init_providerCleanupError();
+		init_jsonValue();
+		init_result();
+		init_StableFileHash();
+		init_RegularFile();
+		init_OwnedRegularFile();
+		init_AnalysisCleanupLease();
+		init_ArtifactResourceScope();
+		init_ArtifactFileOperation();
+		OPERATION$2 = "observe_native_calls";
+		nativeCallTargetFailure = (cause, path) => {
+			if (cause instanceof ArtifactResourceRetryFailure && cause.cleanup !== undefined) {
+				const failure = new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, cause.cleanup.resources, {
+					reason: cause.cleanup.reason,
+					phase: "target-digest-retry"
+				}, {
+					operation: OPERATION$2,
+					cause
+				});
+				bindArtifactFileCleanup(cause, failure);
+				return failure;
+			}
+			if (cause instanceof RegularFileOperationCancelled || cause instanceof RegularFileCancelled) return new AnalysisCancelledError(OPERATION$2, {
+				cause: cause.reason,
+				...cause instanceof RegularFileCancelled ? { diagnostics: { completed_hash: jsonValueSchema.parse(cause.outcome.value) } } : {}
+			});
+			const physical = stableFileHashCause(cause);
+			if (physical instanceof RegularFileChangedError) return new EvidenceIntegrityError("Native call observation target changed during digest verification", { cause: physical });
+			return new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, OPERATION$2, {
+				cause: physical,
+				diagnostics: {
+					path,
+					phase: "target-digest",
+					reason: "Unable to verify the selected target digest",
+					detail: physical instanceof Error ? physical.message : String(physical)
+				}
+			});
+		};
+		verifyNativeCallTarget = async (target, resources, signal) => {
+			let cleanupLease;
+			try {
+				const digest = await hashStableFile(target.path, {
+					...signal === undefined ? {} : { signal },
+					retainFailedClose: (owner) => {
+						cleanupLease = new AnalysisCleanupLease(() => owner.close(), [target.path]);
+						resources.retain({
+							kind: "lease",
+							resource: target.path,
+							lease: cleanupLease
+						});
+					}
+				});
+				return digest.sha256 === target.sha256 ? ok(undefined) : err(new EvidenceIntegrityError("Native call observation target digest changed after session binding"));
+			} catch (cause) {
+				if (cause instanceof RegularFileCleanupFailure && cleanupLease !== undefined) {
+					const cancellation = regularFileCancellation(cause);
+					const completed = cause.outcome.kind === "completed" ? { completed_hash: jsonValueSchema.parse(cause.outcome.value) } : undefined;
+					const primary = cause.outcome.kind === "failed" ? nativeCallTargetFailure(cause.outcome.cause, target.path) : cancellation === undefined ? undefined : new AnalysisCancelledError(OPERATION$2, {
+						cause: cancellation.reason,
+						diagnostics: completed
+					});
+					const framed = new ArtifactFileCleanupFailure(cause, cleanupLease);
+					const failure = new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, [target.path], {
+						phase: "target-digest-close",
+						reason: cause.cleanupCause instanceof Error ? cause.cleanupCause.message : String(cause.cleanupCause),
+						...completed
+					}, {
+						operation: OPERATION$2,
+						cause: framed,
+						cleanupPrimary: primary
+					});
+					bindArtifactFileCleanup(framed, failure);
+					return err(failure);
+				}
+				return err(nativeCallTargetFailure(cause, target.path));
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/domain/native/nativeCallPartialObservation.js
+var completed, nativeCallPartialObservationSchema;
+function init_nativeCallPartialObservation() {
+	return (init_nativeCallPartialObservation = __esmMin((() => {
+		init_nativeCallObservation();
+		completed = nativeCallObservationResultSchema.shape;
+		nativeCallPartialObservationSchema = z.strictObject({
+			kind: z.literal("native-call-observation"),
+			target: completed.target.omit({ launch_identity: true }).extend({ launch_identity: completed.target.shape.launch_identity.optional() }),
+			process: completed.process.partial().extend({
+				pid: z.number().int().positive().nullable(),
+				stdout: nativeCapturedOutputSchema.nullable(),
+				stderr: nativeCapturedOutputSchema.nullable(),
+				other_stops: z.array(z.string())
+			}),
+			debugger: completed.debugger.partial().extend({ version: z.string().nullable() }),
+			breakpoints: completed.breakpoints.optional(),
+			events: z.array(nativeCallEventSchema),
+			coverage: completed.coverage.omit({ status: true }).partial().extend({
+				status: z.literal("partial"),
+				reason: z.enum([
+					"cancelled",
+					"timeout",
+					"tracer-failure",
+					"capture-failure",
+					"cleanup-failure"
+				])
+			}),
+			limitations: z.array(z.string())
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/native/NativeCallObservation.js
+var OPERATION$1, NATIVE_CALL_OBSERVATION_LIMITATIONS, observeNativeCalls, nativeCallFacts, projectNativeCalls, projectPartialNativeCalls;
+function init_NativeCallObservation() {
+	return (init_NativeCallObservation = __esmMin((() => {
+		init_analysisErrorCore();
+		init_binaryTargetTypes();
+		init_providerAdapterError();
+		init_nativeCallObservation();
+		init_NativeCallTarget();
+		init_result();
+		init_nativeCallPartialObservation();
+		OPERATION$1 = "observe_native_calls";
+		NATIVE_CALL_OBSERVATION_LIMITATIONS = [
+			"Only entries are observed; return values, floating-point and stack-passed arguments are not captured.",
+			"Registers are the raw integer argument registers at entry. For Objective-C methods the first two hold the receiver and the selector.",
+			"Receiver classes come from LLDB's Objective-C runtime reader without running target code; they are null for class methods and for receivers LLDB cannot classify.",
+			"Calls that never reach a symbol's entry, such as inlined code or objc_direct methods called directly, are not observed.",
+			"The target is launched directly under LLDB, not through LaunchServices; LLDB disables ASLR for it, so load addresses can equal file addresses.",
+			"The observation window is checked about once a second, and recording pauses the process at every entry, which slows it."
+		];
+		observeNativeCalls = async (target, parameters, tracer, resources, signal) => {
+			if (target.kind !== "executable" || !isMachOFormat(target.format)) return err(new AnalysisCapabilityUnavailableError("native-macos", OPERATION$1, "Native call observation launches a Mach-O executable; the active target is not one"));
+			const parsed = nativeCallObservationInputSchema.safeParse(parameters);
+			if (!parsed.success) return err(new AnalysisInputError(OPERATION$1, { cause: parsed.error }));
+			try {
+				return await resources.run(async () => {
+					const selected = await verifyNativeCallTarget(target, resources, signal);
+					if (!selected.ok) return selected;
+					if (signal?.aborted) return err(new AnalysisCancelledError(OPERATION$1, { cause: signal.reason }));
+					try {
+						const traced = await tracer.trace({
+							executable: target.path,
+							architecture: target.architecture,
+							expectedSha256: target.sha256,
+							input: parsed.data
+						}, signal);
+						if (!traced.ok) return traced;
+						return signal?.aborted ? err(new AnalysisCancelledError(OPERATION$1, {
+							cause: signal.reason,
+							partialObservation: projectPartialNativeCalls(target, parsed.data, traced.value, "cancelled")
+						})) : ok(projectNativeCalls(target, parsed.data, traced.value));
+					} catch (cause) {
+						return err(new ProviderAdapterError("native-macos", OPERATION$1, {
+							cause,
+							diagnostics: { phase: "trace-result" }
+						}));
+					}
+				});
+			} catch (cause) {
+				return err(nativeCallTargetFailure(cause, target.path));
+			}
+		};
+		nativeCallFacts = (target, input, trace) => {
+			const { run } = trace;
+			const unresolved = run.breakpoints.filter(({ location_count: count }) => count === 0).map(({ index }) => index);
+			const eventLimit = run.outcome === "event-limit";
+			const resourceLimit = run.outcome === "resource-limit";
+			const breakpointLocationLimit = run.breakpoint_locations_truncated === true;
+			const partial = eventLimit || resourceLimit || breakpointLocationLimit || run.outcome === "duration-elapsed" || run.outcome === "stop-limit" || unresolved.length > 0;
+			return {
+				target: {
+					path: target.path,
+					sha256: target.sha256,
+					architecture: target.architecture,
+					arguments: input.arguments,
+					environment: input.environment,
+					working_directory: input.working_directory ?? null,
+					launch_identity: {
+						loaded_image_sha256: run.target_identity.loaded_image_sha256,
+						file_device: run.target_identity.file_device,
+						file_inode: run.target_identity.file_inode,
+						selected_file_sha256: run.target_identity.selected_file_sha256,
+						module_path: run.target_identity.module_path,
+						module_uuid: run.target_identity.module_uuid,
+						stable: run.target_identity.stable
+					}
+				},
+				debugger: trace.debugger,
+				process: {
+					pid: run.pid,
+					outcome: run.outcome,
+					exit_status: run.exit_status,
+					exit_description: run.exit_description,
+					terminated: run.terminated && trace.terminated,
+					elapsed_ms: run.elapsed_ms,
+					stdout: trace.stdout,
+					stderr: trace.stderr,
+					other_stops: run.other_stops
+				},
+				breakpoints: input.breakpoints.map((request, index) => ({
+					index,
+					request: request.kind === "function" ? {
+						...request,
+						module: request.module ?? null
+					} : {
+						...request,
+						class_name: request.class_name ?? null
+					},
+					location_count: run.breakpoints[index]?.location_count ?? 0,
+					locations: run.breakpoints[index]?.locations ?? []
+				})),
+				events: run.events,
+				coverage: {
+					status: partial ? "partial" : "complete",
+					event_limit_reached: eventLimit,
+					resource_limit_reached: resourceLimit,
+					...breakpointLocationLimit ? { breakpoint_locations_truncated: true } : {},
+					unresolved_breakpoints: unresolved
+				},
+				limitations: [
+					...NATIVE_CALL_OBSERVATION_LIMITATIONS,
+					"The selected pathname digest and LLDB module identity are checked around launch. No immutable executable snapshot is used; concurrent in-place mutation or replacement and restoration cannot be ruled out, so the loaded-image digest remains unknown.",
+					...eventLimit ? [`Observation stopped at max_events (${input.max_events}); later calls were not recorded and the process was killed.`] : [],
+					...resourceLimit ? ["Observation stopped before retaining the next complete event because the estimated 8 MiB trace-payload or 65,536-frame aggregate budget was reached; the process was killed."] : [],
+					...run.outcome === "duration-elapsed" ? [`The process was still running after duration_ms (${input.duration_ms}) and was killed.`] : [],
+					...run.target_identity.stable ? [] : ["LLDB did not provide enough module identity evidence to confirm pathname and module continuity around launch."],
+					...run.outcome === "stop-limit" ? ["Observation stopped after repeated signal or exception stops; the process was killed."] : [],
+					...unresolved.length === 0 ? [] : [`Breakpoints ${unresolved.join(", ")} matched no code in any image loaded while observing; their calls could not be observed.`],
+					...run.breakpoints.some(({ location_count: count, locations }) => locations.length < count) ? ["Breakpoints with many matching locations list only the first 64; location_count gives the total."] : [],
+					...breakpointLocationLimit ? ["Resolved breakpoint locations exceeded the aggregate 8 MiB metadata budget; omitted locations are counted in location_count. This metadata limit does not change the process outcome."] : [],
+					...trace.stdout === null || trace.stderr === null ? ["One or more target output captures were unavailable."] : [],
+					...trace.stdout?.truncated === true || trace.stderr?.truncated === true ? ["Target output beyond 1 MiB per stream is counted but not kept."] : [],
+					...trace.stdout?.complete === false || trace.stderr?.complete === false ? ["Target output draining did not complete; reported byte counts are observed lower bounds, not stream totals."] : [],
+					...run.terminated && trace.terminated ? [] : [`REA could not confirm that process ${run.pid} exited; check for it before relying on host state.`]
+				]
+			};
+		};
+		projectNativeCalls = (target, input, trace) => nativeCallObservationResultSchema.parse(nativeCallFacts(target, input, trace));
+		projectPartialNativeCalls = (target, input, trace, reason) => {
+			const facts = nativeCallFacts(target, input, trace);
+			return nativeCallPartialObservationSchema.parse({
+				...facts,
+				kind: "native-call-observation",
+				coverage: {
+					...facts.coverage,
+					status: "partial",
+					reason
+				}
+			});
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/native/LldbReadbackFiles.js
+var LldbReadbackFiles;
+function init_LldbReadbackFiles() {
+	return (init_LldbReadbackFiles = __esmMin((() => {
+		init_result();
+		init_ArtifactResourceScope();
+		init_ArtifactFileOperation();
+		LldbReadbackFiles = class {
+			#resources = new ArtifactResourceScope();
+			#targetPids = new Map();
+			#failed = new Map();
+			get hasPending() {
+				return this.#resources.hasPending;
+			}
+			get cleanupResources() {
+				return [...new Set([...this.#failed].filter(([lease]) => !lease.released).map(([, failure]) => failure.path))];
+			}
+			get cleanupCause() {
+				const failures = [...this.#failed].filter(([lease]) => !lease.released).map(([, failure]) => failure.cause);
+				return failures.length === 0 ? undefined : new AggregateError(failures, "LLDB readback descriptors remain open or unconfirmed");
+			}
+			/** Preserve a completed value even if final close transfers its owner here. */
+			async read(path, read) {
+				const blocked = [...this.#failed].find(([lease, failure]) => !lease.released && failure.path === path);
+				if (blocked !== undefined) return err(blocked[1].cause);
+				let completed;
+				try {
+					return ok(await withArtifactRegularFile(path, this.#resources, undefined, async (handle) => {
+						const value = await read(handle);
+						completed = { value };
+						return value;
+					}));
+				} catch (cause) {
+					if (cause instanceof ArtifactFileCleanupFailure) this.#failed.set(cause.cleanupLease, {
+						path,
+						cause
+					});
+					return completed === undefined ? err(cause) : ok(completed.value);
+				}
+			}
+			/** The producer publishes one target PID per runtime; retain its parsed fact. */
+			async readTargetPid(path) {
+				const known = this.#targetPids.get(path);
+				if (known !== undefined) return known;
+				const contents = await this.read(path, async (file) => (await file.readFile("utf8")).trim());
+				if (!contents.ok || !/^[1-9]\d*$/u.test(contents.value)) return undefined;
+				const pid = Number(contents.value);
+				if (!Number.isSafeInteger(pid)) return undefined;
+				this.#targetPids.set(path, pid);
+				return pid;
+			}
+			async retryCleanup() {
+				try {
+					await this.#resources.retryCleanup();
+				} finally {
+					for (const lease of this.#failed.keys()) if (lease.released) this.#failed.delete(lease);
+				}
+			}
 		};
 	})))();
 }
@@ -2166,60 +2814,35 @@ function init_LldbRetainedObservations() {
 			};
 		};
 		readPrefix = (handle, requestedBytes) => readBoundedPrefix(requestedBytes, async (buffer, offset, length, position) => (await handle.read(buffer, offset, length, position)).bytesRead);
-		readLldbObservationJournal = async (path) => {
-			let handle;
-			try {
-				handle = await open(path, "r");
-				const { size } = await handle.stat();
-				const length = Math.min(size, LLDB_OBSERVATION_JOURNAL_MAX_BYTES);
-				const { buffer, bytesRead } = await readPrefix(handle, length);
-				const parsed = parseLldbObservationJournal(buffer.subarray(0, bytesRead));
-				const limitations = [...size > 8388608 ? ["The observation journal exceeded 8 MiB; only its bounded prefix was read."] : [], ...bytesRead < length ? ["The observation journal became shorter while being read; the available prefix was parsed."] : []];
-				return {
-					parsed,
-					limitations
-				};
-			} catch (cause) {
-				return {
-					parsed: {
-						events: [],
-						otherStops: [],
-						limitations: []
-					},
-					limitations: [`The observation journal could not be read: ${cause instanceof Error ? cause.message : String(cause)}`]
-				};
-			} finally {
-				await handle?.close().catch(() => undefined);
-			}
-		};
-		readPartialCapture = async (path) => {
-			let handle;
-			try {
-				handle = await open(path, "r");
-				const { size } = await handle.stat();
-				const length = Math.min(size, MAX_CAPTURE_BYTES);
-				const { buffer, bytesRead } = await readPrefix(handle, length);
-				return {
-					capture: {
-						text: buffer.subarray(0, bytesRead).toString("utf8"),
-						bytes: Math.max(size, bytesRead),
-						truncated: true,
-						complete: false
-					},
-					limitations: bytesRead < length ? ["A target output capture became shorter while being read; its retained prefix may be incomplete."] : []
-				};
-			} catch {
-				return null;
-			} finally {
-				await handle?.close().catch(() => undefined);
-			}
-		};
+		readLldbObservationJournal = (path, files) => files.read(path, async (handle) => {
+			const { size } = await handle.stat();
+			const length = Math.min(size, LLDB_OBSERVATION_JOURNAL_MAX_BYTES);
+			const { buffer, bytesRead } = await readPrefix(handle, length);
+			return {
+				parsed: parseLldbObservationJournal(buffer.subarray(0, bytesRead)),
+				limitations: [...size > 8388608 ? ["The observation journal exceeded 8 MiB; only its bounded prefix was read."] : [], ...bytesRead < length ? ["The observation journal became shorter while being read; the available prefix was parsed."] : []]
+			};
+		});
+		readPartialCapture = (path, files) => files.read(path, async (handle) => {
+			const { size } = await handle.stat();
+			const length = Math.min(size, MAX_CAPTURE_BYTES);
+			const { buffer, bytesRead } = await readPrefix(handle, length);
+			return {
+				capture: {
+					text: buffer.subarray(0, bytesRead).toString("utf8"),
+					bytes: Math.max(size, bytesRead),
+					truncated: true,
+					complete: false
+				},
+				limitations: bytesRead < length ? ["A target output capture became shorter while being read; its retained prefix may be incomplete."] : []
+			};
+		});
 	})))();
 }
 
 //#endregion
 //#region dist/native/LldbCallTracer.js
-var OPERATION$1, PROVIDER, LLDB_REQUIREMENT, MAX_OUTPUT_BYTES, DEADLINE_GRACE_MS, DIAGNOSTIC_BYTES, BRIDGE, tracedSchema, tracerOutputSchema, ATTACH_REMEDIATION, LldbCallTracer, quote, tracerFailure, partialNativeObservation, partialObservationFromTrace, lldbRuntimePaths, readTracerOutput, capturedOutput, lldbCleanupResources, runLldb, readTargetPid, ensureTerminated, targetTerminationReason, alive;
+var OPERATION, PROVIDER, LLDB_REQUIREMENT, MAX_OUTPUT_BYTES, DEADLINE_GRACE_MS, DIAGNOSTIC_BYTES, BRIDGE, tracedSchema, tracerOutputSchema, ATTACH_REMEDIATION, LldbCallTracer, quote, tracerFailure, partialNativeObservation, partialObservationFromTrace, lldbRuntimePaths, readTracerOutput, capturedOutput, errorReason, releaseLldbRuntime, bindLldbCleanup, lldbCleanupFailure, lldbCleanupResources, runLldb, ensureTerminated, targetTerminationReason, alive;
 function init_LldbCallTracer() {
 	return (init_LldbCallTracer = __esmMin((() => {
 		init_snapshotEnvironment();
@@ -2237,8 +2860,13 @@ function init_LldbCallTracer() {
 		init_ProviderDeadline();
 		init_PrivateRuntimeRoot();
 		init_CommandRunner();
+		init_NativeCallObservation();
+		init_LldbReadbackFiles();
+		init_AnalysisCleanupLease();
+		init_analysisErrorCleanup();
+		init_analysisErrorBase();
 		init_LldbRetainedObservations();
-		OPERATION$1 = "observe_native_calls";
+		OPERATION = "observe_native_calls";
 		PROVIDER = "native-macos";
 		LLDB_REQUIREMENT = "LLDB from Xcode or the Command Line Tools is not available";
 		MAX_OUTPUT_BYTES = 1024 * 1024;
@@ -2297,9 +2925,10 @@ function init_LldbCallTracer() {
 				"tracer-error"
 			]),
 			error: z.string().nullable(),
-			target_process_created: z.boolean().optional()
+			target_process_created: z.boolean().optional(),
+			target_process_exit_observed: z.boolean().optional()
 		})]);
-		ATTACH_REMEDIATION = "Allow debugging for this user (Developer Tools access: `DevToolsSecurity -enable`, or membership in the _developer group). A hardened-runtime target is debuggable only with the com.apple.security.get-task-allow entitlement; see inspect_signature's debugger-attach facet.";
+		ATTACH_REMEDIATION = "Allow debugging for this user (Developer Tools access: `DevToolsSecurity -enable`, or membership in the _developer group). A hardened-runtime target is debuggable only with the com.apple.security.get-task-allow entitlement; inspect_signature reports hardened_runtime and entitlements.";
 		LldbCallTracer = class {
 			launch;
 			resolveTool;
@@ -2318,15 +2947,27 @@ function init_LldbCallTracer() {
 				const pendingCleanup = await this.#retryPendingCleanup();
 				if (pendingCleanup !== undefined) return err(pendingCleanup);
 				const lldb = await this.resolveTool("lldb", signal);
-				if (!lldb.ok) return err(lldb.error.reason === "cancelled" ? new AnalysisCancelledError(OPERATION$1) : new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION$1, LLDB_REQUIREMENT, { userMessage: LLDB_REQUIREMENT }));
+				if (!lldb.ok) return err(lldb.error.reason === "cancelled" ? new AnalysisCancelledError(OPERATION) : new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION, LLDB_REQUIREMENT, { userMessage: LLDB_REQUIREMENT }));
 				const root = await PrivateRuntimeRoot.create({ prefix: "rea-lldb-" });
 				const paths = lldbRuntimePaths(root.path);
+				const owner = {
+					root,
+					rootLease: new AnalysisCleanupLease(() => root.close(), [root.path]),
+					files: new LldbReadbackFiles(),
+					supervisor: undefined,
+					pidPath: paths.pid,
+					targetIdentity: undefined,
+					targetPid: undefined,
+					processStopped: true,
+					targetStopped: true
+				};
 				let result;
 				try {
-					result = await this.#run(lldb.value, root, request, signal);
+					result = await this.#run(lldb.value, owner, request, signal);
 				} catch (cause) {
 					const partialObservation = await partialNativeObservation({
 						request,
+						files: owner.files,
 						pidPath: paths.pid,
 						stdoutPath: paths.stdoutCapture,
 						stderrPath: paths.stderrCapture,
@@ -2334,44 +2975,51 @@ function init_LldbCallTracer() {
 						version: null,
 						reason: "tracer-failure"
 					});
-					const retained = this.#pendingCleanup;
-					const resources = retained === undefined ? [] : await lldbCleanupResources(retained);
-					result = err(new ProviderAdapterError(PROVIDER, OPERATION$1, {
+					if (!owner.processStopped || !owner.targetStopped || owner.files.hasPending) this.#pendingCleanup = owner;
+					result = err(new ProviderAdapterError(PROVIDER, OPERATION, {
 						cause,
-						diagnostics: { reason: cause instanceof Error ? cause.message : String(cause) },
+						diagnostics: { reason: errorReason(cause) },
 						partialObservation,
-						...retained === undefined ? {} : { cleanup: {
+						...this.#pendingCleanup === owner ? { cleanup: {
 							reason: "LLDB trace failed while owned resources remain",
-							resources
-						} }
+							resources: lldbCleanupResources(owner)
+						} } : {}
 					}));
 				}
-				if (this.#pendingCleanup?.root === root) return result;
+				if (result.ok && signal?.aborted) result = err(new AnalysisCancelledError(OPERATION, {
+					cause: signal.reason,
+					partialObservation: partialObservationFromTrace(request, result.value, "cancelled")
+				}));
+				if (owner.files.hasPending) this.#pendingCleanup = owner;
+				if (this.#pendingCleanup === owner) {
+					if (!result.ok && result.error.cleanupIncomplete) {
+						if (owner.files.hasPending) {
+							const files = lldbCleanupFailure(owner, "LLDB readback descriptor cleanup remains incomplete", owner.files.cleanupCause);
+							result.error.retainSecondaryFailure(files, { readback_cleanup: projectAnalysisError(files) });
+						}
+						return err(bindLldbCleanup(result.error, owner));
+					}
+					const cleanup = lldbCleanupFailure(owner, "LLDB readback descriptor cleanup remains incomplete", owner.files.cleanupCause, result.ok ? partialObservationFromTrace(request, result.value) : undefined);
+					return result.ok ? err(cleanup) : err(analysisErrorWithCleanupFailure(result.error, cleanup, OPERATION).bindCleanupDependencies([result.error, cleanup]));
+				}
+				let rootCleanup;
 				try {
-					await root.close();
+					await releaseLldbRuntime(owner);
+					rootCleanup = ok(undefined);
 				} catch (cause) {
-					this.#pendingCleanup = {
-						root,
-						supervisor: undefined,
-						pidPath: paths.pid,
-						targetIdentity: undefined,
-						processStopped: true,
-						targetStopped: true
-					};
-					const partialObservation = result.ok ? partialObservationFromTrace(request, result.value) : result.error.partialObservation;
-					return err(new ProviderCleanupError(PROVIDER, [root.path], {
-						reason: cause instanceof Error ? cause.message : String(cause),
-						...result.ok ? {} : {
-							execution_failure: projectAnalysisError(result.error).code,
-							primary_failure: result.error.message
-						}
-					}, {
-						operation: OPERATION$1,
-						cause: result.ok ? cause : new AggregateError([result.error, cause], "LLDB trace and runtime cleanup both failed"),
-						...partialObservation === undefined ? {} : { partialObservation }
-					}));
+					rootCleanup = err(cause);
+					this.#pendingCleanup = owner;
 				}
-				return result;
+				if (result.ok && signal?.aborted) result = err(new AnalysisCancelledError(OPERATION, {
+					cause: signal.reason,
+					partialObservation: partialObservationFromTrace(request, result.value, "cancelled")
+				}));
+				if (!rootCleanup.ok) {
+					const cleanup = lldbCleanupFailure(owner, errorReason(rootCleanup.error), rootCleanup.error, result.ok ? partialObservationFromTrace(request, result.value) : undefined);
+					if (!result.ok && result.error.cleanupIncomplete) bindLldbCleanup(result.error, owner);
+					return result.ok ? err(cleanup) : err(analysisErrorWithCleanupFailure(result.error, cleanup, OPERATION).bindCleanupDependencies([result.error, cleanup]));
+				}
+				return result.ok ? result : err(resolvedAnalysisError(bindLldbCleanup(result.error, owner)));
 			}
 			/** Retry retained LLDB cleanup without abandoning its process or runtime owner. */
 			async close() {
@@ -2389,37 +3037,50 @@ function init_LldbCallTracer() {
 			async #retryPendingCleanup() {
 				const owner = this.#pendingCleanup;
 				if (owner === undefined) return undefined;
-				let firstFailure;
+				const failures = [];
+				try {
+					await owner.files.retryCleanup();
+				} catch (cause) {
+					failures.push(cause);
+				}
 				if (!owner.processStopped) {
-					const stopped = await owner.supervisor?.stop();
-					if (stopped?.status === "incomplete") firstFailure = stopped.reason;
+					if (owner.supervisor === undefined) failures.push(new Error("LLDB process cleanup ownership was unavailable"));
 					else {
-						owner.supervisor?.dispose();
-						owner.processStopped = true;
+						try {
+							const stopped = await owner.supervisor.stop();
+							if (stopped.status === "incomplete") failures.push(new Error(stopped.reason));
+							else {
+								owner.supervisor.dispose();
+								owner.processStopped = true;
+							}
+						} catch (cause) {
+							failures.push(cause);
+						}
 					}
 				}
-				if (firstFailure === undefined && !owner.targetStopped) {
-					const targetTermination = await ensureTerminated(owner.pidPath, owner.targetIdentity, true);
-					if (targetTermination !== "terminated") firstFailure = targetTerminationReason(targetTermination);
-					else owner.targetStopped = true;
+				if (owner.processStopped && !owner.targetStopped) {
+					owner.targetPid = await owner.files.readTargetPid(owner.pidPath);
+					try {
+						const targetTermination = await ensureTerminated(owner.targetPid, owner.targetIdentity);
+						if (targetTermination !== "terminated") failures.push(new Error(targetTerminationReason(targetTermination)));
+						else owner.targetStopped = true;
+					} catch (cause) {
+						failures.push(cause);
+					}
 				}
-				if (firstFailure === undefined) {
+				if (failures.length === 0) {
 					try {
-						await owner.root.close();
+						await releaseLldbRuntime(owner);
 						this.#pendingCleanup = undefined;
 						return undefined;
 					} catch (cause) {
-						firstFailure = cause instanceof Error ? cause.message : String(cause);
+						failures.push(cause);
 					}
 				}
-				const resources = await lldbCleanupResources(owner);
-				return new ProviderCleanupError(PROVIDER, resources, {
-					reason: firstFailure ?? "LLDB cleanup remains incomplete",
-					resources
-				}, { operation: OPERATION$1 });
+				return lldbCleanupFailure(owner, failures.map(errorReason).join("; "), new AggregateError(failures, "LLDB cleanup remains incomplete"));
 			}
-			async #run(lldb, root, request, signal) {
-				const directory = root.path;
+			async #run(lldb, retained, request, signal) {
+				const directory = retained.root.path;
 				const paths = lldbRuntimePaths(directory);
 				const { input } = request;
 				await writeFile(paths.config, JSON.stringify({
@@ -2450,6 +3111,9 @@ function init_LldbCallTracer() {
 					identity_ack_path: paths.identityAck,
 					observation_path: paths.observations
 				}), { mode: 384 });
+				retained.processStopped = false;
+				retained.targetStopped = false;
+				this.#pendingCleanup = retained;
 				const exited = await this.launch(lldb.path, [
 					"--batch",
 					"--no-lldbinit",
@@ -2463,31 +3127,30 @@ function init_LldbCallTracer() {
 					pidPath: paths.pid,
 					identityAckPath: paths.identityAck,
 					environment: this.environment,
+					files: retained.files,
 					...signal === undefined ? {} : { signal }
 				});
-				const retained = {
-					root,
-					supervisor: exited.cleanupOwner,
-					pidPath: paths.pid,
-					targetIdentity: exited.targetIdentity,
-					processStopped: exited.cleanupOwner === undefined,
-					targetStopped: !exited.targetLaunched
-				};
-				this.#pendingCleanup = retained;
-				const output = exited.kind === "exited" ? await readTracerOutput(paths.result) : undefined;
-				let targetTermination = exited.targetLaunched ? await ensureTerminated(paths.pid, exited.targetIdentity, true) : "terminated";
-				if (output !== undefined && output.status !== "traced" && output.target_process_created === false && await readTargetPid(paths.pid) === undefined) targetTermination = "terminated";
+				retained.supervisor = exited.cleanupOwner;
+				retained.targetIdentity = exited.targetIdentity;
+				retained.processStopped = exited.cleanupOwner === undefined && exited.cleanupFailure === undefined;
+				retained.targetStopped = !exited.targetLaunched;
+				const output = exited.kind === "exited" ? await readTracerOutput(paths.result, retained.files) : undefined;
+				const bridgeObservedExit = output !== undefined && output.status !== "traced" && output.target_process_exit_observed === true;
+				retained.targetPid = await retained.files.readTargetPid(paths.pid);
+				let targetTermination = exited.targetLaunched && !bridgeObservedExit ? await ensureTerminated(retained.targetPid, exited.targetIdentity) : "terminated";
+				if (output !== undefined && output.status !== "traced" && output.target_process_created === false && retained.targetPid === undefined) targetTermination = "terminated";
 				retained.targetStopped = targetTermination === "terminated";
-				if (retained.processStopped && retained.targetStopped) this.#pendingCleanup = undefined;
+				if (retained.processStopped && retained.targetStopped && !retained.files.hasPending) this.#pendingCleanup = undefined;
 				const terminated = targetTermination === "terminated";
 				const cleanupDetails = [exited.cleanupFailure, ...terminated ? [] : [targetTerminationReason(targetTermination)]].filter((detail) => detail !== undefined);
 				const lifecycleCleanup = cleanupDetails.length === 0 ? undefined : {
 					reason: cleanupDetails.join("; "),
-					resources: await lldbCleanupResources(retained)
+					resources: lldbCleanupResources(retained)
 				};
 				const partialReason = exited.kind === "cancelled" ? "cancelled" : exited.kind === "timeout" ? "timeout" : exited.cleanupFailure !== undefined ? "cleanup-failure" : "tracer-failure";
 				const getPartialObservation = (reason = partialReason) => partialNativeObservation({
 					request,
+					files: retained.files,
 					pidPath: paths.pid,
 					stdoutPath: paths.stdoutCapture,
 					stderrPath: paths.stderrCapture,
@@ -2495,31 +3158,32 @@ function init_LldbCallTracer() {
 					version: output?.status === "traced" ? output.version : null,
 					reason
 				});
-				if (exited.kind === "cancelled") return err(new AnalysisCancelledError(OPERATION$1, {
+				if (exited.kind === "cancelled") return err(new AnalysisCancelledError(OPERATION, {
+					cause: signal?.reason,
 					...lifecycleCleanup === undefined ? {} : { cleanup: lifecycleCleanup },
 					partialObservation: await getPartialObservation()
 				}));
-				if (exited.kind === "timeout") return err(new AnalysisTimeoutError(OPERATION$1, input.duration_ms + DEADLINE_GRACE_MS, {
+				if (exited.kind === "timeout") return err(new AnalysisTimeoutError(OPERATION, input.duration_ms + DEADLINE_GRACE_MS, {
 					...lifecycleCleanup === undefined ? {} : { cleanup: lifecycleCleanup },
 					partialObservation: await getPartialObservation()
 				}));
 				if (output !== undefined && output.status !== "traced") return err(tracerFailure(output, lifecycleCleanup, await getPartialObservation()));
-				if (exited.cleanupFailure !== undefined) return err(new ProviderCleanupError(PROVIDER, await lldbCleanupResources(retained), {
+				if (exited.cleanupFailure !== undefined) return err(new ProviderCleanupError(PROVIDER, lldbCleanupResources(retained), {
 					reason: "LLDB process-group cleanup could not be verified",
 					cleanup_failure: exited.cleanupFailure,
 					...lifecycleCleanup === undefined ? {} : { target_cleanup: lifecycleCleanup }
 				}, {
-					operation: OPERATION$1,
+					operation: OPERATION,
 					partialObservation: await getPartialObservation()
 				}));
-				if (!terminated) return err(new ProviderCleanupError(PROVIDER, await lldbCleanupResources(retained), {
+				if (!terminated) return err(new ProviderCleanupError(PROVIDER, lldbCleanupResources(retained), {
 					reason: "LLDB target process termination could not be verified",
 					...lifecycleCleanup === undefined ? {} : { target_cleanup: lifecycleCleanup }
 				}, {
-					operation: OPERATION$1,
+					operation: OPERATION,
 					partialObservation: await getPartialObservation()
 				}));
-				if (output === undefined) return err(new ProviderAdapterError(PROVIDER, OPERATION$1, {
+				if (output === undefined) return err(new ProviderAdapterError(PROVIDER, OPERATION, {
 					diagnostics: {
 						reason: "LLDB exited without a tracer result",
 						exit_code: exited.exitCode,
@@ -2529,16 +3193,29 @@ function init_LldbCallTracer() {
 					partialObservation: await getPartialObservation(),
 					...lifecycleCleanup === undefined ? {} : { cleanup: lifecycleCleanup }
 				}));
-				const stdout = await capturedOutput(paths.stdoutCapture, output.target_output.stdout_bytes, output.target_output.stdout_truncated, output.target_output.stdout_complete);
-				const stderr = await capturedOutput(paths.stderrCapture, output.target_output.stderr_bytes, output.target_output.stderr_truncated, output.target_output.stderr_complete);
+				const stdout = await capturedOutput(paths.stdoutCapture, output.target_output.stdout_bytes, output.target_output.stdout_truncated, output.target_output.stdout_complete, retained.files);
+				const stderr = await capturedOutput(paths.stderrCapture, output.target_output.stderr_bytes, output.target_output.stderr_truncated, output.target_output.stderr_complete, retained.files);
 				if (!stdout.ok || !stderr.ok) {
-					const partial = await getPartialObservation("capture-failure");
-					return err(new ProviderAdapterError(PROVIDER, OPERATION$1, {
-						partialObservation: partial,
+					return err(new ProviderAdapterError(PROVIDER, OPERATION, {
+						cause: new AggregateError([...stdout.ok ? [] : [stdout.error], ...stderr.ok ? [] : [stderr.error]], "LLDB capture readback failed"),
+						partialObservation: projectPartialNativeCalls({
+							path: request.executable,
+							sha256: request.expectedSha256,
+							architecture: request.architecture
+						}, request.input, {
+							debugger: {
+								...lldb,
+								version: output.version
+							},
+							run: output,
+							stdout: stdout.ok ? stdout.value : null,
+							stderr: stderr.ok ? stderr.value : null,
+							terminated
+						}, "capture-failure"),
 						diagnostics: {
 							reason: "LLDB target output capture could not be read",
-							...stdout.ok ? {} : { stdout_capture_error: stdout.error },
-							...stderr.ok ? {} : { stderr_capture_error: stderr.error },
+							...stdout.ok ? {} : { stdout_capture_error: errorReason(stdout.error) },
+							...stderr.ok ? {} : { stderr_capture_error: errorReason(stderr.error) },
 							...lifecycleCleanup === undefined ? {} : { target_cleanup: lifecycleCleanup }
 						},
 						...lifecycleCleanup === undefined ? {} : { cleanup: lifecycleCleanup }
@@ -2564,29 +3241,29 @@ function init_LldbCallTracer() {
 			};
 			const message = output.error ?? "no LLDB error text";
 			if (output.status === "target-integrity-error") return new EvidenceIntegrityError(message || "The launched native target did not match its session digest", options);
-			if (output.status === "target-identity-unavailable") return new ProviderAdapterError(PROVIDER, OPERATION$1, {
+			if (output.status === "target-identity-unavailable") return new ProviderAdapterError(PROVIDER, OPERATION, {
 				...options,
 				diagnostics: {
 					reason: message,
 					constraint: "target process start identity could not be verified"
 				}
 			});
-			if (output.status === "tracer-error") return new ProviderAdapterError(PROVIDER, OPERATION$1, {
+			if (output.status === "tracer-error") return new ProviderAdapterError(PROVIDER, OPERATION, {
 				...options,
 				diagnostics: { reason: `LLDB bridge failed: ${message}` }
 			});
-			if (output.status === "target-error") return new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION$1, `lldb-target-unloadable: ${message}`, options);
-			return /attach|not allowed|permission|denied|debugserver/iu.test(message) ? new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION$1, `debugger-attach-denied: ${message}`, {
+			if (output.status === "target-error") return new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION, `lldb-target-unloadable: ${message}`, options);
+			return /attach|not allowed|permission|denied|debugserver/iu.test(message) ? new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION, `debugger-attach-denied: ${message}`, {
 				userMessage: ATTACH_REMEDIATION,
 				...options
-			}) : new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION$1, `launch-failed: ${message}`, options);
+			}) : new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION, `launch-failed: ${message}`, options);
 		};
 		partialNativeObservation = async (options) => {
 			const [journal, pid, stdout, stderr] = await Promise.all([
-				readLldbObservationJournal(options.observationPath),
-				readTargetPid(options.pidPath),
-				readPartialCapture(options.stdoutPath),
-				readPartialCapture(options.stderrPath)
+				readLldbObservationJournal(options.observationPath, options.files),
+				options.files.readTargetPid(options.pidPath),
+				readPartialCapture(options.stdoutPath, options.files),
+				readPartialCapture(options.stderrPath, options.files)
 			]);
 			return projectLldbPartialObservation({
 				target: {
@@ -2598,35 +3275,26 @@ function init_LldbCallTracer() {
 					working_directory: options.request.input.working_directory ?? null
 				},
 				pid,
-				stdout: stdout?.capture ?? null,
-				stderr: stderr?.capture ?? null,
+				stdout: stdout.ok ? stdout.value.capture : null,
+				stderr: stderr.ok ? stderr.value.capture : null,
 				version: options.version,
-				journal: journal.parsed,
-				journalLimitations: journal.limitations,
-				limitations: [...stdout?.limitations ?? [], ...stderr?.limitations ?? []],
+				journal: journal.ok ? journal.value.parsed : {
+					events: [],
+					otherStops: [],
+					limitations: []
+				},
+				journalLimitations: journal.ok ? journal.value.limitations : [`The observation journal could not be read: ${errorReason(journal.error)}`],
+				limitations: [...stdout.ok ? stdout.value.limitations : [`The target stdout capture could not be read: ${errorReason(stdout.error)}`], ...stderr.ok ? stderr.value.limitations : [`The target stderr capture could not be read: ${errorReason(stderr.error)}`]],
 				reason: options.reason
 			});
 		};
-		partialObservationFromTrace = (request, trace) => projectLldbPartialObservation({
-			target: {
+		partialObservationFromTrace = (request, trace, reason = "cleanup-failure") => {
+			return projectPartialNativeCalls({
 				path: request.executable,
 				sha256: request.expectedSha256,
-				architecture: request.architecture,
-				arguments: request.input.arguments,
-				environment: request.input.environment,
-				working_directory: request.input.working_directory ?? null
-			},
-			pid: trace.run.pid,
-			stdout: trace.stdout,
-			stderr: trace.stderr,
-			version: trace.run.version,
-			journal: {
-				events: trace.run.events,
-				otherStops: trace.run.other_stops,
-				limitations: []
-			},
-			reason: "cleanup-failure"
-		});
+				architecture: request.architecture
+			}, request.input, trace, reason);
+		};
 		lldbRuntimePaths = (directory) => ({
 			config: join(directory, "config.json"),
 			result: join(directory, "result.json"),
@@ -2638,50 +3306,48 @@ function init_LldbCallTracer() {
 			stderrCapture: join(directory, "stderr.capture"),
 			observations: join(directory, "observations.jsonl")
 		});
-		readTracerOutput = async (path) => {
-			let text;
-			try {
-				text = await readFile(path, "utf8");
-			} catch {
-				return undefined;
-			}
-			const parsed = safeParseJson(text);
+		readTracerOutput = async (path, files) => {
+			const text = await files.read(path, (file) => file.readFile("utf8"));
+			if (!text.ok) return undefined;
+			const parsed = safeParseJson(text.value);
 			if (!parsed.ok) return undefined;
 			const output = tracerOutputSchema.safeParse(parsed.value);
 			return output.success ? output.data : undefined;
 		};
-		capturedOutput = async (path, observedBytes, truncated, complete) => {
-			let handle;
-			try {
-				handle = await open(path, "r");
-				const { size } = await handle.stat();
-				const captureHandle = handle;
-				const { buffer, bytesRead } = await readBoundedPrefix(Math.min(size, MAX_OUTPUT_BYTES), async (target, offset, length, position) => (await captureHandle.read(target, offset, length, position)).bytesRead);
-				const captured = {
-					text: buffer.subarray(0, bytesRead).toString("utf8"),
-					bytes: observedBytes,
-					truncated: truncated || size > MAX_OUTPUT_BYTES,
-					complete: complete && bytesRead >= Math.min(observedBytes, MAX_OUTPUT_BYTES)
-				};
-				await handle.close();
-				handle = undefined;
-				return ok(captured);
-			} catch (cause) {
-				const failure = cause instanceof Error ? cause.message : String(cause);
-				if (handle !== undefined) {
-					try {
-						await handle.close();
-					} catch (closeCause) {
-						return err(`${failure}; closing capture file failed: ${closeCause instanceof Error ? closeCause.message : String(closeCause)}`);
-					}
-				}
-				return err(failure);
+		capturedOutput = (path, observedBytes, truncated, complete, files) => files.read(path, async (handle) => {
+			const { size } = await handle.stat();
+			const { buffer, bytesRead } = await readBoundedPrefix(Math.min(size, MAX_OUTPUT_BYTES), async (target, offset, length, position) => (await handle.read(target, offset, length, position)).bytesRead);
+			return {
+				text: buffer.subarray(0, bytesRead).toString("utf8"),
+				bytes: observedBytes,
+				truncated: truncated || size > MAX_OUTPUT_BYTES,
+				complete: complete && bytesRead >= Math.min(observedBytes, MAX_OUTPUT_BYTES)
+			};
+		});
+		errorReason = (cause) => cause instanceof Error ? cause.message : String(cause);
+		releaseLldbRuntime = async (owner) => {
+			if (!owner.processStopped || !owner.targetStopped || owner.files.hasPending) throw new Error("LLDB runtime still owns unresolved child resources");
+			await owner.rootLease.release();
+		};
+		bindLldbCleanup = (failure, owner) => {
+			if (failure.cleanupIncomplete) {
+				owner.rootLease.bindCleanupError(failure);
+				failure.bindCleanupResourceOwner({ get cleanupResources() {
+					return lldbCleanupResources(owner);
+				} });
 			}
+			return failure;
 		};
-		lldbCleanupResources = async (owner) => [
+		lldbCleanupFailure = (owner, reason, cause, partialObservation) => bindLldbCleanup(new ProviderCleanupError(PROVIDER, lldbCleanupResources(owner), { reason }, {
+			operation: OPERATION,
+			cause,
+			partialObservation
+		}), owner);
+		lldbCleanupResources = (owner) => [
 			...owner.processStopped ? [] : ["lldb-process-group"],
-			...owner.targetStopped ? [] : [`native-target:${String(await readTargetPid(owner.pidPath) ?? "unknown")}`],
-			owner.root.path
+			...owner.targetStopped ? [] : [`native-target:${String(owner.targetPid ?? "unknown")}`],
+			...owner.files.cleanupResources,
+			...owner.rootLease.released ? [] : [owner.root.path]
 		];
 		runLldb = async (executable, arguments_, options) => {
 			if (options.signal?.aborted === true) return {
@@ -2721,7 +3387,7 @@ function init_LldbCallTracer() {
 				}, { maxDiagnosticBytes: DIAGNOSTIC_BYTES });
 				let identityAckWritten = false;
 				while (!await supervisor.waitForOutputClose(20)) {
-					const pid = await readTargetPid(options.pidPath);
+					const pid = await options.files.readTargetPid(options.pidPath);
 					if (pid !== undefined && !identityAckWritten) {
 						let observation;
 						try {
@@ -2756,20 +3422,8 @@ function init_LldbCallTracer() {
 				deadline.dispose();
 			}
 		};
-		readTargetPid = async (pidPath) => {
-			try {
-				const contents = (await readFile(pidPath, "utf8")).trim();
-				if (!/^[1-9]\d*$/u.test(contents)) return undefined;
-				const pid = Number(contents);
-				return Number.isSafeInteger(pid) ? pid : undefined;
-			} catch {
-				return undefined;
-			}
-		};
-		ensureTerminated = async (pidPath, identity, missingPidIsUnknown) => {
-			const pid = await readTargetPid(pidPath);
-			if (pid === undefined) return missingPidIsUnknown ? "identity-unavailable" : "terminated";
-			if (!Number.isSafeInteger(pid) || pid <= 0) return "identity-unavailable";
+		ensureTerminated = async (pid, identity) => {
+			if (pid === undefined) return "identity-unavailable";
 			let signalDisposition;
 			for (let attempt = 0; attempt < 20; attempt++) {
 				if (!alive(pid)) return "terminated";
@@ -2806,150 +3460,12 @@ function init_LldbCallTracer() {
 	})))();
 }
 
-//#endregion
-//#region dist/native/NativeCallObservation.js
-var OPERATION, NATIVE_CALL_OBSERVATION_LIMITATIONS, observeNativeCalls, isAbortError, projectNativeCalls, fileSha256;
-function init_NativeCallObservation() {
-	return (init_NativeCallObservation = __esmMin((() => {
-		init_analysisErrorCore();
-		init_binaryTargetTypes();
-		init_evidenceErrors();
-		init_providerAdapterError();
-		init_nativeCallObservation();
-		init_result();
-		OPERATION = "observe_native_calls";
-		NATIVE_CALL_OBSERVATION_LIMITATIONS = [
-			"Only entries are observed; return values, floating-point and stack-passed arguments are not captured.",
-			"Registers are the raw integer argument registers at entry. For Objective-C methods the first two hold the receiver and the selector.",
-			"Receiver classes come from LLDB's Objective-C runtime reader without running target code; they are null for class methods and for receivers LLDB cannot classify.",
-			"Calls that never reach a symbol's entry, such as inlined code or objc_direct methods called directly, are not observed.",
-			"The target is launched directly under LLDB, not through LaunchServices; LLDB disables ASLR for it, so load addresses can equal file addresses.",
-			"The observation window is checked about once a second, and recording pauses the process at every entry, which slows it."
-		];
-		observeNativeCalls = async (target, parameters, tracer, signal, readTargetDigest = fileSha256) => {
-			if (target.kind !== "executable" || !isMachOFormat(target.format)) return err(new AnalysisCapabilityUnavailableError("native-macos", OPERATION, "Native call observation launches a Mach-O executable; the active target is not one"));
-			const parsed = nativeCallObservationInputSchema.safeParse(parameters);
-			if (!parsed.success) return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
-			let digest;
-			try {
-				digest = await readTargetDigest(target.path, signal);
-			} catch (cause) {
-				if (signal?.aborted === true || isAbortError(cause)) return err(new AnalysisCancelledError(OPERATION));
-				return err(new ProviderAdapterError("native-macos", OPERATION, { diagnostics: {
-					reason: "Unable to verify the selected target digest",
-					detail: cause instanceof Error ? cause.message : String(cause)
-				} }));
-			}
-			if (digest !== target.sha256) return err(new EvidenceIntegrityError("Native call observation target digest changed after session binding"));
-			if (signal?.aborted === true) return err(new AnalysisCancelledError(OPERATION));
-			const traced = await tracer.trace({
-				executable: target.path,
-				architecture: target.architecture,
-				expectedSha256: target.sha256,
-				input: parsed.data
-			}, signal);
-			if (!traced.ok) return traced;
-			return ok(projectNativeCalls(target, parsed.data, traced.value));
-		};
-		isAbortError = (cause) => cause instanceof Error && cause.name === "AbortError";
-		projectNativeCalls = (target, input, trace) => {
-			const { run } = trace;
-			const unresolved = run.breakpoints.filter(({ location_count: count }) => count === 0).map(({ index }) => index);
-			const eventLimit = run.outcome === "event-limit";
-			const resourceLimit = run.outcome === "resource-limit";
-			const breakpointLocationLimit = run.breakpoint_locations_truncated === true;
-			const partial = eventLimit || resourceLimit || breakpointLocationLimit || run.outcome === "duration-elapsed" || run.outcome === "stop-limit" || unresolved.length > 0;
-			return nativeCallObservationResultSchema.parse({
-				target: {
-					path: target.path,
-					sha256: target.sha256,
-					architecture: target.architecture,
-					arguments: input.arguments,
-					environment: input.environment,
-					working_directory: input.working_directory ?? null,
-					launch_identity: {
-						loaded_image_sha256: run.target_identity.loaded_image_sha256,
-						file_device: run.target_identity.file_device,
-						file_inode: run.target_identity.file_inode,
-						selected_file_sha256: run.target_identity.selected_file_sha256,
-						module_path: run.target_identity.module_path,
-						module_uuid: run.target_identity.module_uuid,
-						stable: run.target_identity.stable
-					}
-				},
-				debugger: trace.debugger,
-				process: {
-					pid: run.pid,
-					outcome: run.outcome,
-					exit_status: run.exit_status,
-					exit_description: run.exit_description,
-					terminated: run.terminated && trace.terminated,
-					elapsed_ms: run.elapsed_ms,
-					stdout: trace.stdout,
-					stderr: trace.stderr,
-					other_stops: run.other_stops
-				},
-				breakpoints: input.breakpoints.map((request, index) => ({
-					index,
-					request: request.kind === "function" ? {
-						...request,
-						module: request.module ?? null
-					} : {
-						...request,
-						class_name: request.class_name ?? null
-					},
-					location_count: run.breakpoints[index]?.location_count ?? 0,
-					locations: run.breakpoints[index]?.locations ?? []
-				})),
-				events: run.events,
-				coverage: {
-					status: partial ? "partial" : "complete",
-					event_limit_reached: eventLimit,
-					resource_limit_reached: resourceLimit,
-					...breakpointLocationLimit ? { breakpoint_locations_truncated: true } : {},
-					unresolved_breakpoints: unresolved
-				},
-				limitations: [
-					...NATIVE_CALL_OBSERVATION_LIMITATIONS,
-					"The selected pathname digest and LLDB module identity are checked around launch. No immutable executable snapshot is used; concurrent in-place mutation or replacement and restoration cannot be ruled out, so the loaded-image digest remains unknown.",
-					...eventLimit ? [`Observation stopped at max_events (${input.max_events}); later calls were not recorded and the process was killed.`] : [],
-					...resourceLimit ? ["Observation stopped before retaining the next complete event because the estimated 8 MiB trace-payload or 65,536-frame aggregate budget was reached; the process was killed."] : [],
-					...run.outcome === "duration-elapsed" ? [`The process was still running after duration_ms (${input.duration_ms}) and was killed.`] : [],
-					...run.target_identity.stable ? [] : ["LLDB did not provide enough module identity evidence to confirm pathname and module continuity around launch."],
-					...run.outcome === "stop-limit" ? ["Observation stopped after repeated signal or exception stops; the process was killed."] : [],
-					...unresolved.length === 0 ? [] : [`Breakpoints ${unresolved.join(", ")} matched no code in any image loaded while observing; their calls could not be observed.`],
-					...run.breakpoints.some(({ location_count: count, locations }) => locations.length < count) ? ["Breakpoints with many matching locations list only the first 64; location_count gives the total."] : [],
-					...breakpointLocationLimit ? ["Resolved breakpoint locations exceeded the aggregate 8 MiB metadata budget; omitted locations are counted in location_count. This metadata limit does not change the process outcome."] : [],
-					...trace.stdout.truncated || trace.stderr.truncated ? ["Target output beyond 1 MiB per stream is counted but not kept."] : [],
-					...!trace.stdout.complete || !trace.stderr.complete ? ["Target output draining did not complete; reported byte counts are observed lower bounds, not stream totals."] : [],
-					...run.terminated && trace.terminated ? [] : [`REA could not confirm that process ${run.pid} exited; check for it before relying on host state.`]
-				]
-			});
-		};
-		fileSha256 = async (path, signal) => {
-			const handle = await open(path, "r");
-			try {
-				const hash = createHash("sha256");
-				const buffer = new Uint8Array(1024 * 1024);
-				for (;;) {
-					signal?.throwIfAborted();
-					const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
-					if (bytesRead === 0) break;
-					hash.update(buffer.subarray(0, bytesRead));
-				}
-				return hash.digest("hex");
-			} finally {
-				await handle.close();
-			}
-		};
-	})))();
-}
-
 //#endregion
 //#region dist/native/SignatureTargetBinding.js
-var identity, changedTarget, signatureReadFailure, withSignatureTarget, combineCleanupFailure, snapshotFailure, snapshotIO, copySignatureBytes, bindSignatureTarget, verifySignatureTarget;
+var identity, changedTarget, signatureReadFailure, withSignatureTarget, combineCleanupFailure, signatureCleanupFailure, snapshotFailure, snapshotIO, copySignatureBytes, bindSignatureTarget, verifySignatureTarget;
 function init_SignatureTargetBinding() {
 	return (init_SignatureTargetBinding = __esmMin((() => {
+		init_RegularFile();
 		init_analysisErrorBase();
 		init_analysisErrorCore();
 		init_providerAdapterError();
@@ -2960,6 +3476,8 @@ function init_SignatureTargetBinding() {
 		init_ArtifactResourceScope();
 		init_PrivateRuntimeRoot();
 		init_ArtifactReader();
+		init_AnalysisCleanupLease();
+		init_ArtifactFileOperation();
 		init_NativeMacOSProviderMetadata();
 		identity = (stat) => [
 			stat.dev,
@@ -2970,6 +3488,7 @@ function init_SignatureTargetBinding() {
 		].join(":");
 		changedTarget = (target, reason) => err(new AnalysisArtifactChangedError("inspect_signature", target.path, reason));
 		signatureReadFailure = (target, cause) => {
+			if (cause instanceof RegularFileOperationCancelled) return new AnalysisCancelledError("inspect_signature", { cause: cause.reason });
 			if (cause instanceof AnalysisError) return cause;
 			const code = cause instanceof Error && "code" in cause ? cause.code : undefined;
 			if (code === "EACCES" || code === "EPERM") return new AnalysisAccessDeniedError("inspect_signature", target.path, code, { cause });
@@ -2989,14 +3508,14 @@ function init_SignatureTargetBinding() {
 				return await resources.run(async () => {
 					let root;
 					try {
-						signal?.throwIfAborted();
+						assertRegularFileActive(signal);
 						root = await createRoot();
 					} catch (cause) {
-						return err(signal?.aborted ? new AnalysisCancelledError("inspect_signature") : snapshotFailure(target, "create", cause));
+						return err(cause instanceof RegularFileOperationCancelled ? signatureReadFailure(target, cause) : snapshotFailure(target, "create", cause));
 					}
 					const owner = {
-						kind: "private-runtime-root",
-						root,
+						kind: "lease",
+						lease: new AnalysisCleanupLease(() => root.close(), [root.path]),
 						resource: root.path
 					};
 					let result;
@@ -3007,25 +3526,33 @@ function init_SignatureTargetBinding() {
 							try {
 								result = await inspect(binding.value);
 							} catch (cause) {
-								result = err(cause instanceof AnalysisError ? cause : new AnalysisOutputError("inspect_signature", "Native output parsing failed", { cause }));
+								result = err(new AnalysisOutputError("inspect_signature", "Native output parsing failed", { cause }));
 							}
 						}
 					} catch (cause) {
-						result = err(cause instanceof AnalysisError ? cause : signatureReadFailure(target, cause));
+						result = err(signatureReadFailure(target, cause));
 					}
 					const cleanup = await resources.release(owner);
-					if (cleanup.kind === "failed") return combineCleanupFailure(target, result, [root.path], cleanup.cause, "cleanup");
+					if (result.ok && signal?.aborted) result = err(new AnalysisCancelledError("inspect_signature", {
+						cause: signal.reason,
+						partialObservation: result.value
+					}));
+					if (cleanup.kind === "failed") {
+						const failure = signatureCleanupFailure(target, [root.path], cleanup.cause, "cleanup");
+						new AnalysisCleanupLeaseGroup(failure, [owner.lease]);
+						return combineCleanupFailure(result, failure);
+					}
 					return result;
 				});
 			} catch (cause) {
-				if (cause instanceof AnalysisError) return err(cause);
 				const retained = cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined ? cause.cleanup : undefined;
-				if (retained !== undefined) return combineCleanupFailure(target, err(signal?.aborted ? new AnalysisCancelledError("inspect_signature") : signatureReadFailure(target, cause)), retained.resources, cause, "retry");
-				return err(signal?.aborted ? new AnalysisCancelledError("inspect_signature") : signatureReadFailure(target, cause));
+				if (retained !== undefined) return combineCleanupFailure(err(signatureReadFailure(target, cause)), signatureCleanupFailure(target, retained.resources, cause, "retry"));
+				return err(signatureReadFailure(target, cause));
 			}
 		};
-		combineCleanupFailure = (target, primary, resources, cause, phase) => {
-			const cleanup = new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, resources, {
+		combineCleanupFailure = (primary, cleanup) => primary.ok ? err(cleanup) : err(analysisErrorWithCleanupFailure(primary.error, cleanup, "inspect_signature").bindCleanupDependencies([primary.error, cleanup]));
+		signatureCleanupFailure = (target, resources, cause, phase) => {
+			const failure = new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, resources, {
 				reason: cause instanceof Error ? cause.message : String(cause),
 				phase: `signature-snapshot-${phase}`,
 				path: target.path
@@ -3033,7 +3560,8 @@ function init_SignatureTargetBinding() {
 				operation: "inspect_signature",
 				cause
 			});
-			return primary.ok ? err(cleanup) : err(analysisErrorWithCleanupFailure(primary.error, cleanup, "inspect_signature"));
+			bindArtifactFileCleanup(cause, failure);
+			return failure;
 		};
 		snapshotFailure = (target, phase, cause) => new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_signature", {
 			cause,
@@ -3057,9 +3585,9 @@ function init_SignatureTargetBinding() {
 			const chunk = Buffer.alloc(64 * 1024);
 			let position = 0;
 			while (position < size) {
-				signal?.throwIfAborted();
+				assertRegularFileActive(signal);
 				const { bytesRead } = await source.file.read(chunk, 0, Math.min(chunk.length, size - position), position);
-				signal?.throwIfAborted();
+				assertRegularFileActive(signal);
 				if (bytesRead === 0) throw new AnalysisArtifactChangedError("inspect_signature", target.path, `Signature target was truncated while hashing: ${target.path}`);
 				const bytes = chunk.subarray(0, bytesRead);
 				hash.update(bytes);
@@ -3073,17 +3601,27 @@ function init_SignatureTargetBinding() {
 			let snapshotOwner;
 			const perform = async () => {
 				try {
-					signal?.throwIfAborted();
+					assertRegularFileActive(signal);
 					const before = await lstat(target.path, { bigint: true });
-					signal?.throwIfAborted();
+					assertRegularFileActive(signal);
 					if (!before.isFile() || before.isSymbolicLink()) return changedTarget(target, `Signature target is no longer a regular file: ${target.path}`);
 					const file = await open(target.path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-					sourceOwner = new OwnedFileHandle(file);
+					const sourceHandle = new OwnedFileHandle(file);
+					sourceOwner = {
+						kind: "lease",
+						resource: target.path,
+						lease: new AnalysisCleanupLease(() => sourceHandle.close(), [target.path])
+					};
 					const opened = await file.stat({ bigint: true });
-					signal?.throwIfAborted();
+					assertRegularFileActive(signal);
 					if (identity(opened) !== identity(before)) return changedTarget(target, `Signature target changed before open: ${target.path}`);
 					const snapshot = await snapshotIO(target, "create-file", () => open(snapshotPath, "wx", 384));
-					snapshotOwner = new OwnedFileHandle(snapshot);
+					const snapshotHandle = new OwnedFileHandle(snapshot);
+					snapshotOwner = {
+						kind: "lease",
+						resource: snapshotPath,
+						lease: new AnalysisCleanupLease(() => snapshotHandle.close(), [snapshotPath])
+					};
 					const observed = await copySignatureBytes(target, {
 						file,
 						stat: opened
@@ -3091,7 +3629,7 @@ function init_SignatureTargetBinding() {
 					if (observed !== target.sha256) return changedTarget(target, `Signature target digest changed: ${target.path}; expected ${target.sha256}, observed ${observed}`);
 					const after = await file.stat({ bigint: true });
 					const current = await lstat(target.path, { bigint: true });
-					signal?.throwIfAborted();
+					assertRegularFileActive(signal);
 					if (identity(after) !== identity(opened) || identity(current) !== identity(opened)) return changedTarget(target, `Signature target changed while establishing its version: ${target.path}`);
 					await snapshotIO(target, "seal", () => snapshot.chmod(256));
 					return ok({
@@ -3099,37 +3637,42 @@ function init_SignatureTargetBinding() {
 						snapshotPath
 					});
 				} catch (cause) {
-					return err(signal?.aborted ? new AnalysisCancelledError("inspect_signature") : signatureReadFailure(target, cause));
+					return err(signatureReadFailure(target, cause));
 				}
 			};
 			let result = await perform();
 			const cleanupFailures = [];
-			for (const [owner, path] of [[snapshotOwner, snapshotPath], [sourceOwner, target.path]]) {
+			for (const owner of [snapshotOwner, sourceOwner]) {
 				if (owner === undefined) continue;
-				const cleanup = await resources.release({
-					kind: "file-handle",
-					handle: owner,
-					resource: path
-				});
+				const cleanup = await resources.release(owner);
 				if (cleanup.kind === "failed") cleanupFailures.push({
-					path,
+					owner,
 					cause: cleanup.cause
 				});
 			}
+			if (result.ok && signal?.aborted) result = err(new AnalysisCancelledError("inspect_signature", {
+				cause: signal.reason,
+				diagnostics: { snapshot_binding: {
+					identity: result.value.identity,
+					snapshot_path: result.value.snapshotPath
+				} }
+			}));
 			if (cleanupFailures.length > 0) {
 				const cause = new AggregateError(cleanupFailures.map(({ cause: failure }) => failure), "Signature snapshot file handles could not be closed");
-				result = combineCleanupFailure(target, result, cleanupFailures.map(({ path }) => path), cause, "close");
+				const cleanup = signatureCleanupFailure(target, cleanupFailures.map(({ owner }) => owner.resource), cause, "close");
+				new AnalysisCleanupLeaseGroup(cleanup, cleanupFailures.map(({ owner }) => owner.lease));
+				result = combineCleanupFailure(result, cleanup);
 			}
 			return result;
 		};
 		verifySignatureTarget = async (target, binding, signal) => {
 			try {
-				signal?.throwIfAborted();
+				assertRegularFileActive(signal);
 				const current = await lstat(target.path, { bigint: true });
-				signal?.throwIfAborted();
+				assertRegularFileActive(signal);
 				return current.isFile() && identity(current) === binding.identity ? ok(undefined) : changedTarget(target, `Signature target changed during inspection: ${target.path}`);
 			} catch (cause) {
-				return err(signal?.aborted ? new AnalysisCancelledError("inspect_signature") : signatureReadFailure(target, cause));
+				return err(signatureReadFailure(target, cause));
 			}
 		};
 	})))();
@@ -3218,19 +3761,12 @@ function init_codesign() {
 
 //#endregion
 //#region dist/native/parsers/demangle.js
-var resultSchema, parseDemangledSymbols;
+var linkageName, undecodedSpelling, parseDemangledSymbols;
 function init_demangle() {
 	return (init_demangle = __esmMin((() => {
 		init_swiftSymbolClassification();
-		resultSchema = z.object({
-			input: z.string(),
-			output: z.string(),
-			status: z.enum([
-				"demangled",
-				"unchanged",
-				"invalid"
-			])
-		});
+		linkageName = (input) => input.startsWith("__") ? input.slice(1) : input;
+		undecodedSpelling = (input) => /^[Sse]/u.test(input) ? `$${input}` : linkageName(input);
 		parseDemangledSymbols = (inputs, output) => {
 			if (inputs.length === 0) {
 				if (output === "" || output === "\n") return [];
@@ -3241,11 +3777,12 @@ function init_demangle() {
 			return inputs.map((input, index) => {
 				const value = lines[index];
 				if (value === undefined) throw new TypeError("swift-demangle omitted an output line");
-				return resultSchema.parse({
+				const decoded = value !== input && value !== undecodedSpelling(input);
+				return {
 					input,
 					output: value,
-					status: value === input ? isSwiftMangledSymbolName(input) ? "invalid" : "unchanged" : "demangled"
-				});
+					status: decoded ? "demangled" : isSwiftMangledSymbolName(linkageName(input)) ? "invalid" : "unchanged"
+				};
 			});
 		};
 	})))();
@@ -3253,18 +3790,20 @@ function init_demangle() {
 
 //#endregion
 //#region dist/native/parsers/plist.js
-var plistObject, INTEGRAL_LITERAL, decodePlistJson, plistJsonNeedsNumberTypes, parsePlistJson, parsePlistXml, xmlNumberLiterals, prototypeKeyLimitations, numberLimitations, mapJsonNumbers, projectPlistBundle;
+var plistObject, INTEGRAL_LITERAL, decodePlistJson, plistJsonNeedsNumberTypes, parsePlistJson, parsePlistXml, prototypeKeyLimitations, negativeZeroLimitations, numberLimitations, mapJsonNumbers, projectPlistBundle;
 function init_plist() {
 	return (init_plist = __esmMin((() => {
 		init_analysisErrorCore();
 		init_plistValue();
 		init_propertyListKeys();
 		init_result();
+		init_plistNumbers();
 		plistObject = z.record(z.string(), z.unknown());
 		INTEGRAL_LITERAL = /^-?\d+$/u;
-		decodePlistJson = (output, unsafe) => {
+		decodePlistJson = (output, unsafe, negativeZero = (item) => item) => {
 			const text = output.replace(/^\uFEFF/u, "");
 			return JSON.parse(text, (_key, item, context) => {
+				if (typeof item === "number" && Object.is(item, -0)) return negativeZero(item);
 				const source = context?.source;
 				return typeof item !== "number" || Number.isSafeInteger(item) || source === undefined || !INTEGRAL_LITERAL.test(source) ? item : unsafe(item, source);
 			});
@@ -3280,13 +3819,18 @@ function init_plist() {
 			return found;
 		};
 		parsePlistJson = (output, xmlConversion) => {
-			const literals = xmlConversion === undefined ? undefined : xmlNumberLiterals(xmlConversion);
+			let literals;
 			let exactIntegerCount = 0;
 			let ambiguousNumberCount = 0;
+			let negativeZeroRealCount = 0;
+			const signedZero = () => {
+				negativeZeroRealCount += 1;
+				return negativeZeroReal();
+			};
 			const classify = (item, digits) => {
 				const exact = BigInt(digits).toString();
-				const integer = literals?.integers.get(item)?.has(exact) === true;
-				const real = literals?.reals.has(item) === true;
+				const integer = literals?.incomplete === false && literals.integers.get(item)?.has(exact) === true;
+				const real = literals?.incomplete === false && literals.reals.has(item);
 				if (integer && !real) {
 					exactIntegerCount += 1;
 					return {
@@ -3300,7 +3844,8 @@ function init_plist() {
 			};
 			let decoded;
 			try {
-				decoded = omitPrototypeKeys(decodePlistJson(output, classify));
+				literals = xmlConversion === undefined ? undefined : parseXmlPropertyList(xmlConversion).numberLiterals;
+				decoded = omitPrototypeKeys(decodePlistJson(output, classify, signedZero));
 			} catch (cause) {
 				return err(new AnalysisOutputError("inspect_plist", cause instanceof Error ? cause.message : String(cause), { cause }));
 			}
@@ -3308,27 +3853,33 @@ function init_plist() {
 			return ok({
 				value,
 				bundle: projectPlistBundle(value),
-				limitations: [...numberLimitations(exactIntegerCount, ambiguousNumberCount), ...prototypeKeyLimitations(decoded.omittedPrototypeKeys)]
+				limitations: [
+					...negativeZeroLimitations(negativeZeroRealCount),
+					...literals?.incomplete === true ? [incompletePlistNumberLimitation] : [],
+					...numberLimitations(exactIntegerCount, ambiguousNumberCount),
+					...prototypeKeyLimitations(decoded.omittedPrototypeKeys)
+				]
 			});
 		};
 		parsePlistXml = (output) => {
 			let projected;
 			let omittedPrototypeKeys;
+			let literals;
 			try {
 				const decoded = parseXmlPropertyList(output);
 				omittedPrototypeKeys = decoded.omittedPrototypeKeys;
+				literals = decoded.numberLiterals;
 				projected = projectPlistValue(decoded.value);
 			} catch (cause) {
 				return err(new AnalysisOutputError("inspect_plist", "plutil XML conversion was not a readable plist", { cause }));
 			}
-			const literals = xmlNumberLiterals(output);
 			let exactIntegerCount = 0;
 			let ambiguousNumberCount = 0;
 			const value = mapJsonNumbers(projected.value, (item) => {
 				const decimals = literals.integers.get(item);
 				if (decimals === undefined) return item;
 				const [decimal] = decimals;
-				if (decimals.size !== 1 || decimal === undefined || literals.reals.has(item)) {
+				if (literals.incomplete || decimals.size !== 1 || decimal === undefined || literals.reals.has(item)) {
 					ambiguousNumberCount += 1;
 					return item;
 				}
@@ -3343,26 +3894,18 @@ function init_plist() {
 				bundle: projectPlistBundle(value),
 				limitations: [
 					"plutil cannot express this plist as JSON, so it was decoded from plutil's XML conversion; data and date values are typed objects such as { \"$plist_type\": \"data\", \"base64\": ... }.",
-					...projected.unknownRealCount === 0 ? [] : [`${String(projected.unknownRealCount)} non-finite real value(s) are reported as { "$plist_type": "real", "value": null } because the XML decoder does not distinguish NaN from infinity.`],
+					...projected.nonFiniteRealCount === 0 ? [] : [nonFiniteRealLimitation(projected.nonFiniteRealCount)],
+					...projected.unknownRealCount === 0 ? [] : [unknownRealLimitation(projected.unknownRealCount)],
+					...negativeZeroLimitations(projected.negativeZeroRealCount),
+					...projected.unknownDateCount === 0 ? [] : [unknownDateLimitation(projected.unknownDateCount)],
+					...literals.incomplete ? [incompletePlistNumberLimitation] : [],
 					...numberLimitations(exactIntegerCount, ambiguousNumberCount),
 					...prototypeKeyLimitations(omittedPrototypeKeys)
 				]
 			});
 		};
-		xmlNumberLiterals = (xml) => {
-			const integers = new Map();
-			for (const [, decimal = ""] of xml.matchAll(/<integer>\s*([+-]?\d+)\s*<\/integer>/gu)) {
-				const rounded = Number(decimal);
-				if (Number.isSafeInteger(rounded)) continue;
-				integers.set(rounded, (integers.get(rounded) ?? new Set()).add(BigInt(decimal).toString()));
-			}
-			const reals = new Set([...xml.matchAll(/<real>([^<]*)<\/real>/gu)].map(([, text = ""]) => Number.parseFloat(text)));
-			return {
-				integers,
-				reals
-			};
-		};
 		prototypeKeyLimitations = (count) => count === 0 ? [] : [omittedPrototypeKeysLimitation(count)];
+		negativeZeroLimitations = (count) => count === 0 ? [] : [negativeZeroRealLimitation(count)];
 		numberLimitations = (exactIntegerCount, ambiguousNumberCount) => [...exactIntegerCount === 0 ? [] : [`${String(exactIntegerCount)} integer value(s) exceed the exact range of a JSON number and are reported as { "$plist_type": "integer", "decimal": "<exact digits>" }.`], ...ambiguousNumberCount === 0 ? [] : [`${String(ambiguousNumberCount)} number(s) beyond the exact range of a JSON number are reported as decoded because the XML literal they came from, a rounded <integer> or a <real>, cannot be identified.`]];
 		mapJsonNumbers = (value, map) => {
 			if (typeof value === "number") return map(value);
@@ -3507,7 +4050,7 @@ function init_echoedPath() {
 
 //#endregion
 //#region dist/native/parsers/otool.js
-var DYLIB_COMMANDS, DYLIB_FIELDS, DYLIB_ENCODING_FIELDS, EMPTY_VALUE_FIELDS, BUILD_PLATFORM_NAMES, BUILD_TOOL_NAMES, buildCodeName, normalizeLineEndings, parseOtoolLoadCommands, WORD_SIZES, cpuEndian, parseHeader, headerValue, validateLoadCommandFraming, createLoadCommandState, parseLoadCommand, validateDylibCommandLines, scalarFields, collectUuid, collectEntrypoint, collectBuild, collectDependency, collectSegment, parseFields, parseField, requireUniqueField, parseSegment, parseSections, parseBuildTools, permissions, NUMERIC_PATTERN, numeric, nonEmptyName, stringField, numberField, hexField, stripOffsetSuffix, sectionAlignment;
+var DYLIB_COMMANDS, DYLIB_FIELDS, DYLIB_ENCODING_FIELDS, EMPTY_VALUE_FIELDS, BUILD_PLATFORM_NAMES, BUILD_TOOL_NAMES, buildCodeName, normalizeLineEndings, parseOtoolLoadCommands, WORD_SIZES, cpuEndian, parseHeader, headerValue, validateLoadCommandFraming, createLoadCommandState, parseLoadCommand, validateDylibCommandLines, validateLinkerOptionLines, scalarFields, collectUuid, collectEntrypoint, collectBuild, collectDependency, collectSegment, parseFields, TEXT_FIELDS, parseField, requireUniqueField, parseSegment, parseSections, parseBuildTools, permissions, NUMERIC_PATTERN, numeric, machoName, stringField, numberField, hexField, stripOffsetSuffix, sectionAlignment;
 function init_otool() {
 	return (init_otool = __esmMin((() => {
 		DYLIB_COMMANDS = new Set([
@@ -3669,6 +4212,7 @@ function init_otool() {
 			if (kind === null) throw new TypeError("otool load command is missing cmd");
 			for (const key of scalarFields(kind)) requireUniqueField(parsed, key);
 			if (DYLIB_COMMANDS.has(kind)) validateDylibCommandLines(parsed);
+			if (kind === "LC_LINKER_OPTION") validateLinkerOptionLines(parsed);
 			state.commands.push({
 				index,
 				kind,
@@ -3681,7 +4225,7 @@ function init_otool() {
 			collectSegment(kind, block, fields, state);
 		};
 		validateDylibCommandLines = (parsed) => {
-			const encodingFields = DYLIB_ENCODING_FIELDS.filter((key) => Object.hasOwn(parsed.values, key));
+			const encodingFields = DYLIB_ENCODING_FIELDS.filter((key) => parsed.rows.some((field) => field?.[0] === key));
 			if (encodingFields.length !== 1) throw new TypeError("otool dylib command must contain timestamp or options");
 			for (const key of encodingFields) requireUniqueField(parsed, key);
 			const allowed = new Set([...DYLIB_FIELDS, ...DYLIB_ENCODING_FIELDS]);
@@ -3690,9 +4234,15 @@ function init_otool() {
 				if (key === undefined || !allowed.has(key)) throw new TypeError("otool dylib command contains ambiguous multiline text");
 			}
 		};
+		validateLinkerOptionLines = (parsed) => {
+			const count = numberField(parsed.values, "count");
+			const labels = parsed.rows.map((field) => field?.[0]).filter((key) => key !== "cmd" && key !== "cmdsize" && key !== "count");
+			if (count === null || labels.length !== count || labels.some((key, index) => key !== `string #${String(index + 1)}`)) throw new TypeError("otool linker-option strings do not match count");
+		};
 		scalarFields = (kind) => {
 			const common = ["cmd", "cmdsize"];
 			if (DYLIB_COMMANDS.has(kind)) return DYLIB_FIELDS;
+			if (kind === "LC_LINKER_OPTION") return [...common, "count"];
 			if (kind === "LC_LOAD_DYLINKER" || kind === "LC_ID_DYLINKER") return [...common, "name"];
 			if (kind === "LC_UUID") return [...common, "uuid"];
 			if (kind === "LC_MAIN") return [...common, "entryoff"];
@@ -3750,7 +4300,7 @@ function init_otool() {
 			});
 		};
 		collectDependency = (kind, fields, state) => {
-			if (!DYLIB_COMMANDS.has(kind)) return;
+			if (!DYLIB_COMMANDS.has(kind) || kind === "LC_ID_DYLIB") return;
 			state.dependencies.push({
 				path: stripOffsetSuffix(stringField(fields, "name")),
 				kind,
@@ -3765,22 +4315,29 @@ function init_otool() {
 			state.segments.push(segment);
 		};
 		parseFields = (block) => {
-			const fields = {};
 			const rows = [];
-			for (const rawLine of block.split(/\r?\n/u).slice(1)) {
-				if (rawLine.trim().length === 0) continue;
-				const field = parseField(rawLine);
-				rows.push(field);
+			for (const rawLine of block.split(/\r?\n/u).slice(1)) if (rawLine.trim().length > 0) rows.push(parseField(rawLine));
+			const occurrences = new Map();
+			for (const field of rows) if (field !== undefined) occurrences.set(field[0], (occurrences.get(field[0]) ?? 0) + 1);
+			const fields = {};
+			const ordinals = new Map();
+			for (const field of rows) {
 				if (field === undefined) continue;
 				const [key, value] = field;
-				fields[key] = key === "segname" || key === "sectname" ? value : numeric(value) ?? value;
+				const ordinal = (ordinals.get(key) ?? 0) + 1;
+				ordinals.set(key, ordinal);
+				const label = (occurrences.get(key) ?? 0) > 1 ? `${key} #${String(ordinal)}` : key;
+				fields[label] = TEXT_FIELDS.test(key) ? value : numeric(value) ?? value;
 			}
 			return {
 				values: fields,
 				rows
 			};
 		};
+		TEXT_FIELDS = /^(?:segname|sectname|string #\d+)$/u;
 		parseField = (rawLine) => {
+			const option = /^\s*(string #[1-9]\d*)(?: (.*))?$/u.exec(rawLine);
+			if (option?.[1] !== undefined) return [option[1], option[2] ?? ""];
 			const line = rawLine.trim();
 			const match = /^((?:time stamp)|\S+(?:\s+version)?)(?:\s+(.+))?$/u.exec(line);
 			return match?.[1] === undefined ? undefined : [match[1], match[2]?.trim() ?? ""];
@@ -3792,7 +4349,7 @@ function init_otool() {
 			if (field[1] === "" && !EMPTY_VALUE_FIELDS.has(key)) throw new TypeError(`otool field ${key} has no value`);
 		};
 		parseSegment = (block, fields) => ({
-			name: nonEmptyName(stringField(fields, "segname")),
+			name: machoName(fields, "segname"),
 			vm_address: hexField(fields, "vmaddr"),
 			vm_size: numberField(fields, "vmsize"),
 			file_offset: numberField(fields, "fileoff"),
@@ -3814,8 +4371,8 @@ function init_otool() {
 				"flags"
 			]) requireUniqueField(parsed, key);
 			return {
-				segment: nonEmptyName(stringField(fields, "segname")),
-				name: nonEmptyName(stringField(fields, "sectname")),
+				segment: machoName(fields, "segname"),
+				name: machoName(fields, "sectname"),
 				address: hexField(fields, "addr"),
 				size: numberField(fields, "size"),
 				file_offset: numberField(fields, "offset"),
@@ -3869,7 +4426,11 @@ function init_otool() {
 			const parsed = Number.parseInt(value, value.startsWith("0x") ? 16 : 10);
 			return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
 		};
-		nonEmptyName = (name) => name === null || name.length === 0 ? "unknown" : name;
+		machoName = (fields, key) => {
+			const name = stringField(fields, key);
+			if (name === null) throw new TypeError(`otool field ${key} is missing`);
+			return name;
+		};
 		stringField = (fields, name) => {
 			const value = fields[name];
 			return typeof value === "string" ? value : value === undefined || value === null ? null : String(value);
@@ -3952,16 +4513,16 @@ function init_machoUuid() {
 		};
 		selectDwarfdumpRow = (rows, selectedArchitecture) => {
 			if (rows.length === 0) return { kind: "absent" };
-			const selectedRows = selectedArchitecture === null ? rows : rows.filter(({ architecture }) => architecture === selectedArchitecture);
+			const selectedRows = selectedArchitecture === null ? rows : rows.filter(({ architecture }) => architecture === selectedArchitecture.dwarfdumpName);
 			const validRows = selectedRows.filter(({ value }) => MACHO_UUID.test(value));
 			const distinctValid = new Set(validRows.map(({ value }) => value.toLowerCase()));
 			if (distinctValid.size > 1) return {
 				kind: "conflict",
-				reason: `dwarfdump --uuid returned conflicting UUIDs for selected architecture ${selectedArchitecture ?? "unknown"}`
+				reason: `dwarfdump --uuid returned conflicting UUIDs for selected architecture ${selectedArchitecture?.name ?? "unknown"}`
 			};
 			if (selectedRows.length !== 1) return {
 				kind: "invalid",
-				reason: selectedRows.length > 1 ? `dwarfdump --uuid returned multiple rows for selected architecture ${selectedArchitecture}` : `dwarfdump --uuid returned no row for selected architecture ${selectedArchitecture}`
+				reason: selectedRows.length > 1 ? `dwarfdump --uuid returned multiple rows for selected architecture ${selectedArchitecture?.name ?? "unknown"}` : `dwarfdump --uuid returned no row for selected architecture ${selectedArchitecture?.name ?? "unknown"}`
 			};
 			const [row] = selectedRows;
 			if (row === undefined) return { kind: "absent" };
@@ -4031,7 +4592,7 @@ function init_machoUuid() {
 
 //#endregion
 //#region dist/native/NativeMachoInspection.js
-var DISCOVERY_COMMANDS, SYMBOL_TABLE_EXPORTS, DYLD_INFO_EXPORTS, REQUIRED_SLICE_COMMANDS, OPTIONAL_VTOOL_COMMAND, VTOOL_UNAVAILABLE_LIMITATION, inspectNativeMacho, normalizeMacho, sliceOutput, captureLookup, namesEveryExport, parseNmExports, covered, uniqueSymbols, fileOffsetLocations, architectureLocations, selectedArchitectureArguments, selectArchitecture;
+var DISCOVERY_COMMANDS, SYMBOL_TABLE_EXPORTS, DYLD_INFO_EXPORTS, REQUIRED_SLICE_COMMANDS, OPTIONAL_VTOOL_COMMAND, VTOOL_UNAVAILABLE_LIMITATION, inspectNativeMacho, normalizeMacho, sliceOutput, captureLookup, namesEveryExport, parseNmExports, covered, uniqueSymbols, fileOffsetLocations, architectureLocations, toolArchitectureName, selectedArchitectureArguments, selectArchitecture;
 function init_NativeMachoInspection() {
 	return (init_NativeMachoInspection = __esmMin((() => {
 		init_analysisErrorCore();
@@ -4075,13 +4636,15 @@ function init_NativeMachoInspection() {
 				...selectedArchitectureArguments(tool, selectedArchitecture),
 				context.target.path
 			], context.signal);
-			const [required, optional] = await Promise.all([Promise.all(REQUIRED_SLICE_COMMANDS.map(runSliceCommand)), runSliceCommand(OPTIONAL_VTOOL_COMMAND)]);
+			const vtoolSelectsSlice = selectedArchitecture === null || !toolArchitectureName("vtool", selectedArchitecture).includes(".");
+			const [required, optional] = await Promise.all([Promise.all(REQUIRED_SLICE_COMMANDS.map(runSliceCommand)), vtoolSelectsSlice ? runSliceCommand(OPTIONAL_VTOOL_COMMAND) : null]);
 			for (const captured of required) {
 				if (!captured.ok) return err(captured.error);
 				captures.push(captured.value);
 			}
 			const limitations = [];
-			if (optional.ok) captures.push(optional.value);
+			if (optional === null) limitations.push(`vtool cannot select the ${selectedArchitecture} slice; build metadata is normalized from otool only.`);
+			else if (optional.ok) captures.push(optional.value);
 			else if (optional.error._tag === "AnalysisCapabilityUnavailableError") limitations.push(VTOOL_UNAVAILABLE_LIMITATION);
 			else return err(optional.error);
 			const nmIndex = captures.findIndex(({ tool }) => tool === "nm");
@@ -4135,7 +4698,10 @@ function init_NativeMachoInspection() {
 			const dyldExports = parseDyldSymbols(sliceOutput(byTool("dyld_info", 1)), "exports", imageBase, new Set(nmExports.map(({ name }) => name)));
 			const exports = uniqueSymbols([...dyldExports, ...nmExports]);
 			const dwarfdump = byTool("dwarfdump");
-			const uuid = reconcileMachoUuid(load.commands, dwarfdump.stdout, artifactPath, selectedArchitecture.name);
+			const uuid = reconcileMachoUuid(load.commands, dwarfdump.stdout, artifactPath, selectedArchitecture.name === null ? null : {
+				name: selectedArchitecture.name,
+				dwarfdumpName: toolArchitectureName("dwarfdump", selectedArchitecture.name)
+			});
 			const provenance = captures.map(toInvocation);
 			const threadEntrypoint = load.entrypoints.length === 0 && load.commands.some((command) => command.kind === "LC_UNIXTHREAD" || command.kind === "LC_THREAD");
 			const threadEntrypointLimitation = "Thread-state entrypoints (LC_UNIXTHREAD/LC_THREAD) are retained as raw load commands; file offsets are not derived.";
@@ -4236,10 +4802,10 @@ function init_NativeMachoInspection() {
 			}
 			return locations;
 		};
+		toolArchitectureName = (tool, architecture) => tool === "dyld_info" ? architecture : architecture.replace(/\.v\d+$/u, "");
 		selectedArchitectureArguments = (tool, architecture) => {
 			if (architecture === null) return [];
-			const baseArchitecture = architecture.split(".")[0] ?? architecture;
-			const toolArchitecture = tool === "dyld_info" ? architecture : baseArchitecture;
+			const toolArchitecture = toolArchitectureName(tool, architecture);
 			return tool === "dwarfdump" ? [`--arch=${toolArchitecture}`] : ["-arch", toolArchitecture];
 		};
 		selectArchitecture = (target, available) => {
@@ -4261,26 +4827,31 @@ function init_NativeMachoInspection() {
 
 //#endregion
 //#region dist/native/NativeMacOSProvider.js
-var NativeMacOSProvider, NativeMacOSClient, nativeCommandCleanupFailure, isNativeOperation, translateCommandFailure, translateCodeSignExitFailure, commandOutput, isNonzeroUnsignedObservation, canonicalPath, codeSignCaptureFailure, codeSignArchitectures, invocation, parseEntitlements, unreadablePlist, plutilDiagnostic, requireRegularPlist, resolvePlistPath;
+var NativeMacOSProvider, NativeMacOSClient, nativeCommandCleanupFailure, closeNativeFileScope, nativeOutputFailure, isNativeOperation, translateCommandFailure, translateCodeSignExitFailure, commandOutput, isNonzeroUnsignedObservation, canonicalPath, codeSignCaptureFailure, codeSignArchitectures, invocation, parseEntitlements, plutilDiagnostic;
 function init_NativeMacOSProvider() {
 	return (init_NativeMacOSProvider = __esmMin((() => {
+		init_NativePlistSource();
+		init_ArtifactFileOperation();
 		init_snapshotEnvironment();
 		init_NativeMacOSProviderMetadata();
 		init_AppleDispatchMetadata();
 		init_NativeUiObservation();
+		init_NativeUiCleanupError();
 		init_LldbCallTracer();
 		init_NativeCallObservation();
 		init_AnalysisProvider();
 		init_nativeToolContracts();
 		init_binaryTargetTypes();
+		init_objcSwiftMetadata();
 		init_toolContracts();
 		init_inputIssueProjection();
 		init_analysisErrorCore();
-		init_configurationErrors();
 		init_providerAdapterError();
 		init_providerCleanupError();
 		init_analysisErrorBase();
 		init_jsonValue();
+		init_plistValue();
+		init_plistNumbers();
 		init_propertyListKeys();
 		init_nativeInspection();
 		init_result();
@@ -4327,6 +4898,9 @@ function init_NativeMacOSProvider() {
 			#pendingNativeUiRuntimes = new Set();
 			#pendingCommands = new Set();
 			#signatureResources = new ArtifactResourceScope();
+			#plistResources = new ArtifactResourceScope();
+			#callResources = new ArtifactResourceScope();
+			#dispatchResources = new ArtifactResourceScope();
 			#nativeUiTail = Promise.resolve();
 			#closed = false;
 			constructor(target, runner, tracer, environment, privateRuntimeRootFactory) {
@@ -4338,14 +4912,14 @@ function init_NativeMacOSProvider() {
 			}
 			async execute(operation, parameters, options) {
 				if (this.#closed) return err(new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, operation, "Native provider client is closed"));
-				if (options?.signal?.aborted === true) return err(new AnalysisCancelledError(operation));
+				if (options?.signal?.aborted === true) return err(new AnalysisCancelledError(operation, { cause: options.signal.reason }));
 				if (operation === "health") return ok(createAnalysisExecution(null, NATIVE_MACOS_PROVIDER_IDENTITY));
 				if (operation === "inspect_native_dispatch_metadata") {
 					const input = toolContract(operation).inputSchema.safeParse(parameters);
 					if (!input.success) return err(analysisInputErrorFromIssues(operation, input.error.issues, parameters, { cause: input.error }));
-					if (this.target.kind !== "executable" || !isMachOFormat(this.target.format)) return err(new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, operation, "Binary Apple metadata requires Mach-O; other providers can report symbol-only metadata"));
+					if (!isAppleDispatchMetadataTarget(this.target)) return err(new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, operation, "Binary Apple metadata requires Mach-O; other providers can report symbol-only metadata"));
 					try {
-						const result = await inspectAppleDispatchMetadata(this.target, input.data.max_records, options?.signal);
+						const result = await this.#dispatchResources.run(() => inspectAppleDispatchMetadata(this.target, input.data.max_records, this.#dispatchResources, options?.signal));
 						return ok(createAnalysisExecution(result, result.provider, {
 							locations: [{
 								kind: "artifact-path",
@@ -4354,19 +4928,12 @@ function init_NativeMacOSProvider() {
 							limitations: result.result.coverage.flatMap(({ reason }) => reason === null ? [] : [reason])
 						}));
 					} catch (cause) {
-						if (cause instanceof AnalysisError) return err(cause);
-						return err(options?.signal?.aborted ? new AnalysisCancelledError(operation) : new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, operation, {
-							cause,
-							diagnostics: {
-								target_path: this.target.path,
-								reason: cause instanceof Error ? cause.message : String(cause)
-							}
-						}));
+						return err(appleDispatchMetadataFailure(cause, this.target.path));
 					}
 				}
 				if (!isNativeOperation(operation)) return err(new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, operation, "Operation is not implemented by native macOS tools."));
 				if (operation === "observe_native_calls") {
-					const result = await observeNativeCalls(this.target, parameters, this.tracer, options?.signal);
+					const result = await observeNativeCalls(this.target, parameters, this.tracer, this.#callResources, options?.signal);
 					return result.ok ? ok(createAnalysisExecution(result.value, NATIVE_MACOS_PROVIDER_IDENTITY, {
 						limitations: result.value.limitations,
 						locations: [{
@@ -4383,33 +4950,30 @@ function init_NativeMacOSProvider() {
 					return observation.ok ? ok(createAnalysisExecution(observation.value.result, NATIVE_MACOS_PROVIDER_IDENTITY, {
 						limitations: observation.value.limitations,
 						locations: observation.value.locations
-					})) : observation;
+					})) : err(resolvedAnalysisError(observation.error));
 				} catch (cause) {
-					return err(new AnalysisOutputError(operation, "Native output parsing failed", { cause }));
+					return err(nativeOutputFailure(operation, cause));
 				}
 			}
 			async close() {
 				this.#closed = true;
 				await Promise.allSettled(this.#pendingCommands);
 				const uiCleanupFailures = await this.#serializeNativeUi(() => this.#retryNativeUiCleanup());
-				let signatureCleanup;
-				try {
-					await this.#signatureResources.close();
-				} catch (cause) {
-					const observation = ArtifactReaderFailure.cleanupObservation(cause, "signature-snapshot");
-					signatureCleanup = new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, observation.resources, { reason: observation.reason }, {
-						operation: "close_binary",
-						cause
-					});
-				}
+				const signatureCleanup = await closeNativeFileScope(this.#signatureResources, "signature-snapshot");
+				const plistCleanup = await closeNativeFileScope(this.#plistResources, "plist-file");
+				const callCleanup = await closeNativeFileScope(this.#callResources, "native-call-target");
+				const dispatchCleanup = await closeNativeFileScope(this.#dispatchResources, "native-dispatch-metadata-target");
 				const commandCleanup = await this.#retryNativeCommandCleanup();
 				let result = await this.tracer.close();
 				const cleanupErrors = [
 					...uiCleanupFailures.length === 0 ? [] : [this.#nativeUiCleanupFailure(uiCleanupFailures, "close_binary")],
 					...commandCleanup === undefined ? [] : [commandCleanup],
-					...signatureCleanup === undefined ? [] : [signatureCleanup]
+					...signatureCleanup === undefined ? [] : [signatureCleanup],
+					...plistCleanup === undefined ? [] : [plistCleanup],
+					...callCleanup === undefined ? [] : [callCleanup],
+					...dispatchCleanup === undefined ? [] : [dispatchCleanup]
 				];
-				for (const cleanupError of cleanupErrors) result = result.ok ? err(cleanupError) : err(analysisErrorWithCleanupFailure(result.error, cleanupError));
+				for (const cleanupError of cleanupErrors) result = result.ok ? err(cleanupError) : err(analysisErrorWithCleanupFailure(result.error, cleanupError).bindCleanupDependencies([result.error, cleanupError]));
 				return result;
 			}
 			#observeNativeUi(operation, parameters, signal) {
@@ -4418,12 +4982,13 @@ function init_NativeMacOSProvider() {
 					const earlierCleanupFailures = await this.#retryNativeUiCleanup();
 					if (earlierCleanupFailures.length > 0) return err(this.#nativeUiCleanupFailure(earlierCleanupFailures, operation));
 					const runtime = createNativeUiHelperRuntime(this.environment);
+					const observationSignal = signal === undefined ? runtime.signal : AbortSignal.any([signal, runtime.signal]);
 					this.#pendingNativeUiRuntimes.add(runtime);
 					let result;
 					try {
 						result = await observeNativeUi(this.target, operation, parameters, {
 							environment: this.environment,
-							signal,
+							signal: observationSignal,
 							runtime
 						});
 					} catch (cause) {
@@ -4433,12 +4998,14 @@ function init_NativeMacOSProvider() {
 						await runtime.close();
 						this.#pendingNativeUiRuntimes.delete(runtime);
 					} catch (cause) {
+						result = finishNativeUiObservation(result, operation, observationSignal);
 						const cleanup = this.#nativeUiCleanupFailure([{
 							runtime,
 							cause
 						}], operation, result.ok ? result.value : undefined);
-						return err(result.ok ? cleanup : analysisErrorWithCleanupFailure(result.error, cleanup, operation));
+						return err(result.ok ? cleanup : analysisErrorWithCleanupFailure(result.error, cleanup, operation).bindCleanupDependencies([result.error, cleanup]));
 					}
+					result = finishNativeUiObservation(result, operation, observationSignal);
 					return result.ok ? ok(createAnalysisExecution(result.value, NATIVE_MACOS_PROVIDER_IDENTITY, { limitations: result.value.limitations })) : result;
 				});
 			}
@@ -4472,18 +5039,7 @@ function init_NativeMacOSProvider() {
 				}
 			}
 			#nativeUiCleanupFailure(failures, operation, partialObservation) {
-				const resources = failures.flatMap(({ runtime }) => runtime.resources());
-				return new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, resources.length === 0 ? ["native-ui-runtime"] : resources, {
-					reason: "Native UI runtime cleanup remains incomplete",
-					failures: failures.map(({ runtime, cause }) => ({
-						resources: [...runtime.resources()],
-						reason: cause instanceof Error ? cause.message : String(cause)
-					}))
-				}, {
-					operation,
-					cause: new AggregateError(failures.map(({ cause }) => cause), "Native UI runtime cleanup failed"),
-					...partialObservation === undefined ? {} : { partialObservation }
-				});
+				return new NativeUiCleanupError(failures, operation, partialObservation);
 			}
 			#dispatch(operation, parameters, signal) {
 				switch (operation) {
@@ -4542,7 +5098,12 @@ function init_NativeMacOSProvider() {
 			}
 			async #inspectSignature(signal) {
 				if (this.target.kind !== "executable" || !isMachOFormat(this.target.format)) return err(new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_signature", "Active artifact is not Mach-O; its container-level signature layer is not evaluated by codesign."));
-				return withSignatureTarget(this.target, this.#signatureResources, (binding) => this.#inspectBoundSignature(binding, signal), signal, this.privateRuntimeRootFactory);
+				const inspected = await withSignatureTarget(this.target, this.#signatureResources, (binding) => this.#inspectBoundSignature(binding, signal), signal, this.privateRuntimeRootFactory);
+				return inspected.ok ? ok({
+					result: inspected.value,
+					limitations: inspected.value.limitations,
+					locations: []
+				}) : inspected;
 			}
 			async #inspectBoundSignature(binding, signal) {
 				const display = await this.#captureSignature(binding, ["-d", "--verbose=4"], signal);
@@ -4572,6 +5133,7 @@ function init_NativeMacOSProvider() {
 				];
 				const limitations = [
 					...parsed.limitations,
+					...entitlementValue.limitations.map((note) => `Entitlements: ${note}`),
 					"Inspected a digest-verified Mach-O byte snapshot; filesystem-bound signing context and trust validation are not examined.",
 					...entitlementValue.omittedPrototypeKeys === 0 ? [] : [`Entitlements: ${omittedPrototypeKeysLimitation(entitlementValue.omittedPrototypeKeys)}`]
 				];
@@ -4595,11 +5157,7 @@ function init_NativeMacOSProvider() {
 					provenance,
 					limitations
 				});
-				return ok({
-					result: jsonValueSchema.parse(result),
-					limitations: result.limitations,
-					locations: []
-				});
+				return ok(result);
 			}
 			async #inspectMixedSignatureSlices(binding, format, aggregateExits, signal) {
 				const captures = [];
@@ -4652,61 +5210,101 @@ function init_NativeMacOSProvider() {
 			async #inspectPlist(parameters, signal) {
 				const requested = parameters.path;
 				if (requested !== undefined && typeof requested !== "string") return err(new AnalysisOutputError("inspect_plist", "path was not a string"));
-				const plist = await resolvePlistPath(this.target, requested);
-				if (!plist.ok) return plist;
-				const selected = await requireRegularPlist(plist.value, requested);
-				if (!selected.ok) return selected;
-				const classified = await this.#run("inspect_plist", "file", ["-b", plist.value], { signal });
-				if (!classified.ok) return classified;
-				const json = await this.#run("inspect_plist", "plutil", [
-					"-convert",
-					"json",
-					"-o",
-					"-",
-					"--",
-					plist.value
-				], {
-					signal,
-					acceptNonZero: true
-				});
-				if (!json.ok) return json;
-				const jsonDecoded = json.value.exitCode === 0;
-				const xml = jsonDecoded && !plistJsonNeedsNumberTypes(json.value.stdout) ? undefined : await this.#run("inspect_plist", "plutil", [
-					"-convert",
-					"xml1",
-					"-o",
-					"-",
-					"--",
-					plist.value
-				], {
-					signal,
-					acceptNonZero: !jsonDecoded
-				});
-				if (xml !== undefined && !xml.ok) return xml;
-				if (xml !== undefined && xml.value.exitCode !== 0) return err(unreadablePlist(plist.value, requested, `plutil could not decode it as a property list (${plutilDiagnostic(xml.value.stderr, plist.value)})`));
-				const parsed = xml === undefined ? parsePlistJson(json.value.stdout) : jsonDecoded ? parsePlistJson(json.value.stdout, xml.value.stdout) : parsePlistXml(xml.value.stdout);
-				if (!parsed.ok) return parsed;
-				const provenance = [
-					classified.value,
-					json.value,
-					...xml === undefined ? [] : [xml.value]
-				].map((item) => invocation(item, plist.value, "$PLIST"));
-				const result = inspectPlistSchema.parse({
-					format: /binary property list/iu.test(classified.value.stdout) ? "binary" : /XML|text/iu.test(classified.value.stdout) ? "xml" : "unknown",
-					value: parsed.value.value,
-					bundle: parsed.value.bundle,
-					source_path: plist.value,
-					provenance,
-					limitations: parsed.value.limitations
-				});
-				return ok({
-					result: jsonValueSchema.parse(result),
-					limitations: parsed.value.limitations,
-					locations: [{
-						kind: "artifact-path",
-						path: plist.value
-					}]
-				});
+				try {
+					return await this.#plistResources.run(async () => {
+						try {
+							const plist = await resolveNativePlistSelection(this.target, requested);
+							if (!plist.ok) return plist;
+							const fileInput = {
+								selection: plist.value,
+								resources: this.#plistResources,
+								signal
+							};
+							const selected = await requireRegularPlist(fileInput);
+							if (!selected.ok) return selected;
+							const classified = await this.#run("inspect_plist", "file", ["-b", plist.value.path], { signal });
+							if (!classified.ok) return classified;
+							const json = await this.#run("inspect_plist", "plutil", [
+								"-convert",
+								"json",
+								"-o",
+								"-",
+								"--",
+								plist.value.path
+							], {
+								signal,
+								acceptNonZero: true
+							});
+							if (!json.ok) return json;
+							const jsonDecoded = json.value.exitCode === 0;
+							const xml = jsonDecoded && !plistJsonNeedsNumberTypes(json.value.stdout) ? undefined : await this.#run("inspect_plist", "plutil", [
+								"-convert",
+								"xml1",
+								"-o",
+								"-",
+								"--",
+								plist.value.path
+							], {
+								signal,
+								acceptNonZero: !jsonDecoded
+							});
+							if (xml !== undefined && !xml.ok) return xml;
+							if (xml !== undefined && xml.value.exitCode !== 0) {
+								const capture = failureCapture(xml.value, false);
+								return err(unreadablePlist(plist.value, `plutil could not decode it as a property list (${plutilDiagnostic(capture, plist.value.path)})`, { capturedOutput: {
+									stdout: capture.stdout,
+									stderr: capture.stderr,
+									truncated: capture.truncated,
+									stdout_bytes: capture.stdoutBytes,
+									stderr_bytes: capture.stderrBytes,
+									exit_code: capture.exitCode,
+									signal: capture.signal
+								} }));
+							}
+							const parsed = xml === undefined ? parsePlistJson(json.value.stdout) : jsonDecoded ? parsePlistJson(json.value.stdout, xml.value.stdout) : parsePlistXml(xml.value.stdout);
+							if (!parsed.ok) return parsed;
+							const provenance = [
+								classified.value,
+								json.value,
+								...xml === undefined ? [] : [xml.value]
+							].map((item) => invocation(item, plist.value.path, "$PLIST"));
+							const converted = xml?.value ?? json.value;
+							const format = await plistSourceFormat(classified.value.stdout, {
+								...fileInput,
+								capturedOutput: {
+									stdout: converted.stdout,
+									stderr: converted.stderr,
+									truncated: false,
+									stdout_bytes: converted.stdoutBytes,
+									stderr_bytes: converted.stderrBytes,
+									exit_code: converted.exitCode,
+									signal: converted.signal
+								}
+							});
+							if (!format.ok) return format;
+							const result = inspectPlistSchema.parse({
+								format: format.value,
+								value: parsed.value.value,
+								bundle: parsed.value.bundle,
+								source_path: plist.value.path,
+								provenance,
+								limitations: parsed.value.limitations
+							});
+							return ok({
+								result: jsonValueSchema.parse(result),
+								limitations: parsed.value.limitations,
+								locations: [{
+									kind: "artifact-path",
+									path: plist.value.path
+								}]
+							});
+						} catch (cause) {
+							return err(nativeOutputFailure("inspect_plist", cause));
+						}
+					});
+				} catch (cause) {
+					return err(nativePlistFailure(cause, undefined));
+				}
 			}
 			async #inspectMacho(signal) {
 				if (!isMachOFormat(this.target.format)) return err(new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_macho", "Active artifact is not Mach-O."));
@@ -4741,8 +5339,56 @@ function init_NativeMacOSProvider() {
 				resources: [...resources]
 			}))
 		});
+		closeNativeFileScope = async (scope, resource) => {
+			try {
+				await scope.close();
+				return undefined;
+			} catch (cause) {
+				const observation = ArtifactReaderFailure.cleanupObservation(cause, resource);
+				const failure = new ProviderCleanupError(NATIVE_MACOS_PROVIDER_IDENTITY.id, observation.resources, { reason: observation.reason }, {
+					operation: "close_binary",
+					cause
+				});
+				bindArtifactFileCleanup(cause, failure);
+				return failure;
+			}
+		};
+		nativeOutputFailure = (operation, cause) => new AnalysisOutputError(operation, "Native output parsing failed", { cause });
 		isNativeOperation = (operation) => NATIVE_TOOL_CONTRACTS.some(({ name }) => name === operation);
 		translateCommandFailure = (operation, failure) => {
+			const preparation = failure.preparationFailure;
+			if (preparation !== undefined) {
+				const marker = preparation.cleanupFailure;
+				const compiler = preparation.compilerOutcome;
+				const options = {
+					cause: failure,
+					...preparation.capturedOutput === undefined ? {} : { capturedOutput: preparation.capturedOutput },
+					...marker === undefined ? {} : { cleanup: {
+						reason: marker.message,
+						resources: marker.cleanupResources
+					} },
+					diagnostics: {
+						phase: "process-preparation",
+						tool: failure.tool,
+						reason: failure.reason,
+						detail: preparation.message,
+						...compiler === undefined ? {} : { compiler_outcome: {
+							outcome: compiler.outcome,
+							code: compiler.code,
+							signal: compiler.signal,
+							...compiler.timeoutMs === undefined ? {} : { timeout_ms: compiler.timeoutMs }
+						} }
+					}
+				};
+				const error = preparation.cancellation === undefined ? new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, operation, options) : failure.reason === "timeout" ? new AnalysisTimeoutError(operation, NATIVE_COMMAND_TIMEOUT_MS, {
+					...options,
+					cause: preparation.cancellation.reason
+				}) : new AnalysisCancelledError(operation, {
+					...options,
+					cause: preparation.cancellation.reason
+				});
+				return marker === undefined ? error : error.bindCleanupDependencies([marker]);
+			}
 			const capturedOutput = failure.capture === null ? undefined : {
 				stdout: failure.capture.stdout,
 				stderr: failure.capture.stderr,
@@ -4822,50 +5468,31 @@ function init_NativeMacOSProvider() {
 			const end = output.lastIndexOf("</plist>");
 			if (start < 0 || end < start) return {
 				value: null,
-				omittedPrototypeKeys: 0
+				omittedPrototypeKeys: 0,
+				limitations: []
 			};
-			const { value, omittedPrototypeKeys } = parseXmlPropertyList(output.slice(start, end + "</plist>".length));
+			const decoded = parseXmlPropertyList(output.slice(start, end + "</plist>".length));
+			const projected = projectPlistValue(decoded.value);
+			const numbers = createPlistNumberProjection(decoded.numberLiterals);
+			const value = numbers.project(projected.value);
 			return {
-				value: jsonValueSchema.parse(value),
-				omittedPrototypeKeys
+				value,
+				omittedPrototypeKeys: decoded.omittedPrototypeKeys,
+				limitations: [
+					...numbers.limitations(),
+					...projected.nonFiniteRealCount === 0 ? [] : [nonFiniteRealLimitation(projected.nonFiniteRealCount)],
+					...projected.unknownRealCount === 0 ? [] : [unknownRealLimitation(projected.unknownRealCount)],
+					...projected.negativeZeroRealCount === 0 ? [] : [negativeZeroRealLimitation(projected.negativeZeroRealCount)],
+					...projected.unknownDateCount === 0 ? [] : [unknownDateLimitation(projected.unknownDateCount)]
+				]
 			};
 		};
-		unreadablePlist = (path, requested, reason) => {
-			const sentence = reason.endsWith(".") ? reason : `${reason}.`;
-			const missingDefault = `The target has no readable Contents/Info.plist at ${path}: ${sentence} Select another plist in the target with the path input (CLI: --relative-path).`;
-			return requested === undefined ? new AnalysisCapabilityUnavailableError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_plist", missingDefault, { userMessage: missingDefault }) : new AnalysisInputError("inspect_plist", undefined, [{
-				path: ["path"],
-				reason: "invalid_value",
-				message: `Cannot inspect ${path}: ${sentence}`
-			}]);
-		};
-		plutilDiagnostic = (stderr, path) => {
-			const text = stderr.trim();
-			return text.startsWith(`${path}: `) ? text.slice(path.length + 2) : text;
-		};
-		requireRegularPlist = async (path, requested) => {
-			try {
-				if (!(await stat(path)).isFile()) return err(unreadablePlist(path, requested, "it is not a regular file"));
-				await (await open(path, "r")).close();
-				return ok(null);
-			} catch (cause) {
-				const code = cause instanceof Error && "code" in cause ? cause.code : undefined;
-				if (code === "ENOENT" || code === "ENOTDIR") return err(unreadablePlist(path, requested, "no file exists there"));
-				if (code === "EACCES" || code === "EPERM") return err(new BinaryTargetError(path, `permission denied while reading plist (${code})`, { cause }));
-				return err(new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_plist", { cause }));
-			}
-		};
-		resolvePlistPath = async (target, requested) => {
-			try {
-				const source = target.sourcePath ?? target.path;
-				if (requested !== undefined && isAbsolute(requested)) return ok(resolve(requested));
-				const sourceMetadata = await stat(source);
-				const root = sourceMetadata.isDirectory() ? source : dirname(target.path);
-				if (requested !== undefined) return ok(resolve(root, requested));
-				return ok(target.bundleInfoPlist ?? resolve(root, "Contents/Info.plist"));
-			} catch (cause) {
-				return err(new ProviderAdapterError(NATIVE_MACOS_PROVIDER_IDENTITY.id, "inspect_plist", { cause }));
-			}
+		plutilDiagnostic = (capture, path) => {
+			const diagnostics = [capture.stderr, capture.stdout].map((stream) => {
+				const text = stream.trim();
+				return text.startsWith(`${path}: `) ? text.slice(path.length + 2) : text;
+			}).filter((text) => text.length > 0);
+			return diagnostics.length === 0 ? "plutil printed no diagnostic" : diagnostics.join("\n");
 		};
 	})))();
 }