rea-agents 6.5.0 → 6.7.0

package/dist/mcp/{ManagedStaticProvider-BthZbKyZ.js → ManagedStaticProvider-CZuoPme2.js}

@@ -1,15 +1,19 @@
 import { n as __exportAll, t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
-import { _ as ok, a as AnalysisCapabilityUnavailableError, f as init_analysisErrorCore, g as init_result, h as err, i as AnalysisCancelledError, l as AnalysisResourceConstraintError, m as init_analysisErrorBase, o as AnalysisInputError, p as AnalysisError } from "./analysisErrorCore-DXRTvF_m.js";
-import { d as init_evidenceErrors, l as EvidenceIntegrityError } from "./analysisErrorProjection-BN0EPM-3.js";
-import { a as createAnalysisExecution, i as init_providerCleanupError, n as init_ArtifactResourceScope, o as init_AnalysisProvider, r as ProviderCleanupError, t as ArtifactResourceScope } from "./ArtifactResourceScope-P3tq5z8Z.js";
-import { d as init_RegularFile, u as RegularFileChangedError } from "./propertyListKeys-DD25WsjI.js";
-import { ar as managedArtifactInspectionSchema, ir as init_managedArtifact, or as managedMemberInspectionSchema, sr as managedNativeBoundaryInspectionSchema } from "./toolOutputSchemaGroups-ColvNZ1r.js";
-import { n as init_providerAdapterError, t as ProviderAdapterError } from "./providerAdapterError-sDxToNal.js";
-import { i as init_analysisErrorCleanup, n as readBoundedFileBytes, r as analysisErrorWithCleanupFailure, t as init_BoundedFileBytes } from "./BoundedFileBytes-DuczXiQZ.js";
-import { a as init_RegularFileRead, c as withRegularFile, d as decodePeMachine, f as init_peMachine, i as RegularFileCleanupFailure, n as init_BinaryTargetResolver, t as classifyBinaryTargetFilesystemFailure } from "./BinaryTargetResolver-BMaE_0H1.js";
-import { D as MANAGED_STATIC_PROVIDER, P as init_InvestigationProviders } from "./InterfaceBuilderDecodeBudget-5F2AkxJT.js";
-import { a as managedTargetInputSchema, i as managedMembersInputSchema, n as init_managedToolContracts, t as MANAGED_TOOL_CONTRACTS } from "./managedToolContracts-CK--I_s7.js";
-import { r as init_ArtifactReader, t as ArtifactReaderFailure } from "./ArtifactReader-OyM03Gjn.js";
+import { A as err, D as AnalysisError, M as ok, O as init_analysisErrorBase, a as AnalysisCapabilityUnavailableError, f as init_analysisErrorCore, i as AnalysisCancelledError, j as init_result, l as AnalysisResourceConstraintError, o as AnalysisInputError } from "./analysisErrorCore-BIEP7tvF.js";
+import { d as init_evidenceErrors, l as EvidenceIntegrityError } from "./analysisErrorProjection-B8teQwwD.js";
+import { i as init_ArtifactReader, t as ArtifactReaderFailure } from "./ArtifactReader-BrnwNaKY.js";
+import { c as RegularFileCleanupFailure, h as RegularFileChangedError, l as init_OwnedRegularFile, v as init_RegularFile } from "./machoContainer-CMSxUBlK.js";
+import { n as init_providerCleanupError, t as ProviderCleanupError } from "./providerCleanupError-DIRHxzWo.js";
+import { n as ArtifactResourceScope, r as init_ArtifactResourceScope } from "./ArtifactResourceScope-zi3Dkqzy.js";
+import { n as readBoundedFileBytes, t as init_BoundedFileBytes } from "./BoundedFileBytes-DYt5q9G2.js";
+import { l as withRegularFile, n as init_BinaryTargetResolver, o as init_RegularFileRead, t as classifyBinaryTargetFilesystemFailure } from "./BinaryTargetResolver-BUncASDP.js";
+import { r as init_AnalysisProvider, t as createAnalysisExecution } from "./AnalysisProvider-BABWbLoM.js";
+import { i as init_providerAdapterError, r as ProviderAdapterError } from "./browserObservationError-C5okJ5el.js";
+import { n as init_analysisErrorCleanup, t as analysisErrorWithCleanupFailure } from "./analysisErrorCleanup-Q344SnTO.js";
+import { n as init_peMachine, t as decodePeMachine } from "./peMachine-aP1iYnHq.js";
+import { D as MANAGED_STATIC_PROVIDER, P as init_InvestigationProviders } from "./callerPath-CpPnMZyN.js";
+import { cr as managedMemberInspectionSchema, lr as managedNativeBoundaryInspectionSchema, or as init_managedArtifact, sr as managedArtifactInspectionSchema } from "./toolOutputSchemaGroups-MJ_f-PMK.js";
+import { a as managedTargetInputSchema, i as managedMembersInputSchema, n as init_managedToolContracts, t as MANAGED_TOOL_CONTRACTS } from "./managedToolContracts-CSlbKJP-.js";
 import { createHash } from "node:crypto";
 
 //#region dist/dotnet/ManagedStaticProviderMetadata.js
@@ -85,6 +89,7 @@ function init_ManagedDecodeBudget() {
 			#rows = new Map();
 			#strings = new Map();
 			#digests = new WeakMap();
+			#prepaid = new WeakSet();
 			reserve(bytes, offset) {
 				this.#admit(bytes, offset);
 				this.#remaining -= bytes;
@@ -131,6 +136,14 @@ function init_ManagedDecodeBudget() {
 				ranges.set(key, digest);
 				return digest;
 			}
+			/** Record an admitted projection; its next serialized occurrence is already charged. */
+			prepay(value) {
+				this.#prepaid.add(value);
+			}
+			/** Spend an admitted projection's charge once; repeated occurrences pay again. */
+			consumePrepaid(value) {
+				return this.#prepaid.delete(value);
+			}
 			cachedString(index) {
 				return this.#strings.get(index);
 			}
@@ -181,6 +194,7 @@ function init_ManagedDecodeBudget() {
 		jsonBytes = (item) => typeof item === "string" ? managedJsonStringBytes(item) : Buffer.byteLength(JSON.stringify(item) ?? "null");
 		admitManagedProjection = (value, budget = new ManagedDecodeBudget()) => {
 			const visit = (item) => {
+				if (item !== null && typeof item === "object" && budget.consumePrepaid(item)) return;
 				if (Array.isArray(item)) {
 					budget.reserve(item.length + 2, null);
 					for (const child of item) visit(child);
@@ -195,6 +209,7 @@ function init_ManagedDecodeBudget() {
 				}
 			};
 			visit(value);
+			if (value !== null && typeof value === "object") budget.prepay(value);
 			return value;
 		};
 	})))();
@@ -202,7 +217,7 @@ function init_ManagedDecodeBudget() {
 
 //#endregion
 //#region dist/dotnet/ManagedPeReader.js
-var managedCli32BitRequirement, requireRange$1, add, architectureFor, resolveRva, mapRva, readDirectory, readCliHeader, readCoffHeader, readOptionalHeader, readSections, readCliDirectory, readManagedPeLayout;
+var managedCli32BitRequirement, managedCliIsMixedClrNative, requireRange$1, add, architectureFor, resolveRva, mapRva, readDirectory, readCliHeader, readCoffHeader, readOptionalHeader, readSections, readCliDirectory, readManagedPeLayout;
 function init_ManagedPeReader() {
 	return (init_ManagedPeReader = __esmMin((() => {
 		init_peMachine();
@@ -212,6 +227,7 @@ function init_ManagedPeReader() {
 			if (pair === 2) return "required";
 			return pair === 131074 ? "preferred" : "none";
 		};
+		managedCliIsMixedClrNative = (cli) => (cli.flags & 1) === 0 && !cli.readyToRunSignature;
 		requireRange$1 = (bytes, offset, length, scope) => {
 			if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset > bytes.length - length) throw managedFailure("invalid-directory", scope, `${scope} leaves the artifact byte range`, Number.isSafeInteger(offset) && offset >= 0 ? offset : null);
 		};
@@ -644,17 +660,17 @@ function init_ManagedMetadataLayout() {
 			}
 		};
 		SUPPORTED_TABLE_MASK = (1n << BigInt(METADATA_TABLE_NAMES.length)) - 1n;
-		requireRange = (bytes, offset, length, scope) => {
-			if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset > bytes.length - length) throw managedFailure("invalid-metadata-root", scope, `${scope} leaves the metadata byte range`, Number.isSafeInteger(offset) && offset >= 0 ? offset : null);
+		requireRange = (bytes, base, offset, length, scope) => {
+			if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset > bytes.length - length) throw managedFailure("invalid-metadata-root", scope, `${scope} leaves the metadata byte range`, Number.isSafeInteger(base + offset) && offset >= 0 ? base + offset : null);
 		};
 		align4 = (value) => Math.ceil(value / 4) * 4;
-		readStreamName = (bytes, offset) => {
+		readStreamName = (bytes, rootOffset, offset) => {
 			const endLimit = Math.min(bytes.length, offset + 32);
 			let end = offset;
 			while (end < endLimit && bytes[end] !== 0) end += 1;
-			if (end === endLimit) throw managedFailure("invalid-stream", "metadata.stream-name", "Metadata stream name is missing a bounded terminator", offset);
+			if (end === endLimit) throw managedFailure("invalid-stream", "metadata.stream-name", "Metadata stream name is missing a bounded terminator", rootOffset + offset);
 			const nameBytes = bytes.subarray(offset, end);
-			if (nameBytes.some((byte) => byte < 32 || byte > 126)) throw managedFailure("invalid-stream", "metadata.stream-name", "Metadata stream name is not printable ASCII", offset);
+			if (nameBytes.some((byte) => byte < 32 || byte > 126)) throw managedFailure("invalid-stream", "metadata.stream-name", "Metadata stream name is not printable ASCII", rootOffset + offset);
 			return {
 				name: nameBytes.toString("ascii"),
 				next: align4(end + 1)
@@ -682,25 +698,25 @@ function init_ManagedMetadataLayout() {
 		readMetadataStreams = (bytes, rootOffset, budget) => {
 			if (bytes.readUInt32LE(0) !== 1112167234) throw managedFailure("invalid-metadata-root", "metadata.signature", "CLI metadata signature is not BSJB", rootOffset);
 			const versionLength = bytes.readUInt32LE(12);
-			requireRange(bytes, 16, versionLength, "metadata.version");
+			requireRange(bytes, rootOffset, 16, versionLength, "metadata.version");
 			const versionBytes = bytes.subarray(16, 16 + versionLength);
 			const zero = versionBytes.indexOf(0);
 			const decodedVersionLength = zero < 0 ? versionBytes.length : zero;
 			budget.reserveString(decodedVersionLength, rootOffset + 16);
 			const version = versionBytes.subarray(0, decodedVersionLength).toString("utf8");
 			let cursor = align4(16 + versionLength);
-			requireRange(bytes, cursor, 4, "metadata.stream-count");
+			requireRange(bytes, rootOffset, cursor, 4, "metadata.stream-count");
 			const streamCount = bytes.readUInt16LE(cursor + 2);
 			if (streamCount === 0 || streamCount > 64) throw managedFailure("invalid-stream", "metadata.stream-count", "Metadata stream count is outside the admitted range", rootOffset + cursor + 2);
 			cursor += 4;
 			const streams = new Map();
 			for (let index = 0; index < streamCount; index += 1) {
-				requireRange(bytes, cursor, 8, "metadata.stream-header");
+				requireRange(bytes, rootOffset, cursor, 8, "metadata.stream-header");
 				const relativeOffset = bytes.readUInt32LE(cursor);
 				const streamSize = bytes.readUInt32LE(cursor + 4);
-				const named = readStreamName(bytes, cursor + 8);
+				const named = readStreamName(bytes, rootOffset, cursor + 8);
 				if (streams.has(named.name)) throw managedFailure("invalid-stream", "metadata.stream-header", `Duplicate metadata stream ${named.name}`, rootOffset + cursor);
-				requireRange(bytes, relativeOffset, streamSize, `metadata.${named.name}`);
+				requireRange(bytes, rootOffset, relativeOffset, streamSize, `metadata.${named.name}`);
 				streams.set(named.name, {
 					name: named.name,
 					offset: rootOffset + relativeOffset,
@@ -717,7 +733,7 @@ function init_ManagedMetadataLayout() {
 			const tablesStream = streamByName(streams, ["#~", "#-"]);
 			if (tablesStream === undefined) throw managedFailure("missing-stream", "metadata.tables", "Required metadata table stream #~ or #- is absent");
 			const tableBytes = bytes.subarray(tablesStream.offset, tablesStream.offset + tablesStream.size);
-			requireRange(tableBytes, 0, 24, "metadata.tables-header");
+			requireRange(tableBytes, tablesStream.offset, 0, 24, "metadata.tables-header");
 			const heapSizes = tableBytes[6] ?? 0;
 			const heaps = {
 				string: (heapSizes & 1) === 0 ? 2 : 4,
@@ -733,12 +749,12 @@ function init_ManagedMetadataLayout() {
 				valid
 			};
 		};
-		readRowCounts = (tableBytes, valid) => {
+		readRowCounts = (tableBytes, tablesOffset, valid) => {
 			const rowCounts = Array(METADATA_TABLE_NAMES.length).fill(0);
 			let tableCursor = 24;
 			for (let index = 0; index < METADATA_TABLE_NAMES.length; index += 1) {
 				if ((valid & 1n << BigInt(index)) === 0n) continue;
-				requireRange(tableBytes, tableCursor, 4, "metadata.table-row-count");
+				requireRange(tableBytes, tablesOffset, tableCursor, 4, "metadata.table-row-count");
 				const count = tableBytes.readUInt32LE(tableCursor);
 				rowCounts[index] = count;
 				tableCursor += 4;
@@ -770,7 +786,7 @@ function init_ManagedMetadataLayout() {
 				const sizeOfRow = computeRowSize(index, context);
 				const byteLength = count * sizeOfRow;
 				if (!Number.isSafeInteger(byteLength)) throw managedFailure("invalid-tables", "metadata.tables", "Metadata table byte size overflowed", tablesOffset + tableCursor);
-				requireRange(tableBytes, tableCursor, byteLength, "metadata.table-data");
+				requireRange(tableBytes, tablesOffset, tableCursor, byteLength, "metadata.table-data");
 				tables.set(index, {
 					index,
 					name: METADATA_TABLE_NAMES[index] ?? `Table${String(index)}`,
@@ -788,7 +804,7 @@ function init_ManagedMetadataLayout() {
 			const budget = new ManagedDecodeBudget();
 			const { streams, version } = readMetadataStreams(bytes, rootOffset, budget);
 			const { tableBytes, tablesOffset, heaps, valid } = readTablesHeader(artifact, streams);
-			const rowCounts = readRowCounts(tableBytes, valid);
+			const rowCounts = readRowCounts(tableBytes, tablesOffset, valid);
 			const tables = buildMetadataTables({
 				tableBytes,
 				rowCounts,
@@ -1030,7 +1046,6 @@ function init_ManagedMetadataHeaps() {
 			const start = layout.strings.offset + index;
 			const cached = managedDecodeBudget(layout).cachedString(index);
 			if (cached !== undefined && cached.encodedBytes <= heapExtent) {
-				managedDecodeBudget(layout).reserveString(cached.encodedBytes, start);
 				return cached.value;
 			}
 			const maximum = Math.min(layout.strings.offset + layout.strings.size, start + heapExtent + 1);
@@ -1773,7 +1788,7 @@ function init_ManagedArtifactInspector() {
 				limitations
 			}));
 		};
-		runtimeFamilyFromCliHeader = (cli) => cli?.readyToRunSignature === true ? "modern-dotnet" : cli !== null && (cli.flags & 1) === 0 ? "mixed-clr-native" : "unknown";
+		runtimeFamilyFromCliHeader = (cli) => cli?.readyToRunSignature === true ? "modern-dotnet" : cli !== null && managedCliIsMixedClrNative(cli) ? "mixed-clr-native" : "unknown";
 		runtimeFamilyFor = (cli, inventory, metadata, layout) => {
 			const evidence = [{
 				code: "cli-header-observed",
@@ -1950,13 +1965,44 @@ function init_ManagedArtifactInspector() {
 	})))();
 }
 
+//#endregion
+//#region dist/dotnet/ManagedTypeNesting.js
+var readManagedTypeNesting;
+function init_ManagedTypeNesting() {
+	return (init_ManagedTypeNesting = __esmMin((() => {
+		init_ManagedDecodeBudget();
+		init_ManagedMetadataHeaps();
+		init_ManagedReaderFailure();
+		readManagedTypeNesting = (bytes, layout, issues) => {
+			const initialIssues = issues.length;
+			const typeCount = layout.table(2)?.rowCount ?? 0;
+			const enclosing = new Map();
+			for (let row = 1; row <= (layout.table(41)?.rowCount ?? 0); row += 1) {
+				readManagedValue(() => {
+					const cursor = metadataRowCursor(bytes, layout, 41, row);
+					const nested = cursor.readIndex(layout.tableIndexSize(2));
+					const outer = cursor.readIndex(layout.tableIndexSize(2));
+					if (nested < 1 || outer < 1 || nested > typeCount || outer > typeCount || nested === outer || enclosing.has(nested)) throw managedFailure("invalid-row", `metadata.NestedClass:${metadataToken(41, row)}`, `NestedClass requires a unique nested type and distinct existing enclosing type; observed ${nested} -> ${outer}`, cursor.start);
+					managedDecodeBudget(layout).reserve(128, cursor.start);
+					enclosing.set(nested, outer);
+				}, issues);
+			}
+			return {
+				enclosing,
+				complete: issues.length === initialIssues
+			};
+		};
+	})))();
+}
+
 //#endregion
 //#region dist/dotnet/ManagedMemberInspectorCore.js
-var rowRange, fullName, readTypeRange, typeRanges, parseTypes, readCompressed, ELEMENT_TYPES, readSignedCompressed, malformedSignature, MEMBER_METHOD_HEADERS, FUNCTION_POINTER_CONVENTIONS, readMethodSignatureHeader, MAX_ARRAY_RANK, arrayShape, currentPosition, POSITION_ELEMENTS, readTypeOperand, readTypeSignature, CALLING_CONVENTION_NAMES, callingConvention, specSignature, decodeSignature, methodGenericArity, signatureGenericArity, signature;
+var rowRange, fullName, readTypeRange, typeRanges, parseTypes, readCompressed, ELEMENT_TYPES, readSignedCompressed, malformedSignature, MEMBER_METHOD_HEADERS, FUNCTION_POINTER_CONVENTIONS, readMethodSignatureHeader, MAX_ARRAY_RANK, arrayShape, currentPosition, POSITION_ELEMENTS, readTypeOperand, readTypeSignature, CALLING_CONVENTION_NAMES, callingConvention, specSignature, decodeSignature, methodGenericArity, signatureGenericArity, OPERAND_MARKER, resolvedSha256, signature;
 function init_ManagedMemberInspectorCore() {
 	return (init_ManagedMemberInspectorCore = __esmMin((() => {
 		init_ManagedReaderFailure();
 		init_ManagedDecodeBudget();
+		init_ManagedTypeNesting();
 		init_ManagedMetadataHeaps();
 		init_ManagedMemberPointers();
 		rowRange = (table, start, end) => {
@@ -2009,6 +2055,7 @@ function init_ManagedMemberInspectorCore() {
 			const methods = memberListTable(layout, 6);
 			const items = [];
 			const issues = [];
+			const nesting = readManagedTypeNesting(bytes, layout, issues);
 			for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1) {
 				readManagedValue(() => {
 					const cursor = metadataRowCursor(bytes, layout, 2, row);
@@ -2031,6 +2078,7 @@ function init_ManagedMemberInspectorCore() {
 						offset: extendsOffset,
 						detail: `TypeDef Extends coded index 0x${extendsRaw.toString(16)} is invalid: ${extendsReason}`
 					});
+					const enclosingRow = nesting.enclosing.get(row);
 					items.push({
 						token: metadataToken(2, row),
 						row_offset: cursor.start,
@@ -2043,6 +2091,8 @@ function init_ManagedMemberInspectorCore() {
 							1,
 							27
 						], layout.rowCounts),
+						enclosing_type_token: enclosingRow === undefined ? null : metadataToken(2, enclosingRow),
+						name_sha256: null,
 						field_list: {
 							first_row: fieldRange.first,
 							last_row: fieldRange.last,
@@ -2058,7 +2108,8 @@ function init_ManagedMemberInspectorCore() {
 			}
 			return {
 				types: items,
-				issues
+				issues,
+				nesting
 			};
 		};
 		readCompressed = (bytes, offset) => {
@@ -2210,7 +2261,7 @@ function init_ManagedMemberInspectorCore() {
 			}
 			return token;
 		};
-		readTypeSignature = (blob, offset, base, layout) => {
+		readTypeSignature = (blob, offset, base, { layout, operands } = {}) => {
 			const stack = [];
 			let cursor = offset;
 			for (;;) {
@@ -2232,6 +2283,10 @@ function init_ManagedMemberInspectorCore() {
 					cursor += 1;
 				} else if (kind === 31 || kind === 32) {
 					const token = readTypeOperand(blob, cursor + 1, layout);
+					operands?.push({
+						offset: cursor + 1,
+						...token
+					});
 					const modifier = `${kind === 31 ? "modreq" : "modopt"}:${String(token.value)}`;
 					const top = stack.at(-1);
 					if (top?.kind === "modifiers") top.modifiers.push(modifier);
@@ -2242,6 +2297,10 @@ function init_ManagedMemberInspectorCore() {
 					cursor = token.next;
 				} else if (kind === 17 || kind === 18) {
 					const token = readTypeOperand(blob, cursor + 1, layout);
+					operands?.push({
+						offset: cursor + 1,
+						...token
+					});
 					value = `${kind === 17 ? "valuetype" : "class"}:${String(token.value)}`;
 					cursor = token.next;
 				} else if (kind === 30 || kind === 19) {
@@ -2258,6 +2317,10 @@ function init_ManagedMemberInspectorCore() {
 					const generic = blob[cursor + 1];
 					if (generic !== 17 && generic !== 18) return malformedSignature("generic instantiation does not name a class or value type", cursor + 1);
 					const token = readTypeOperand(blob, cursor + 2, layout, [2, 1]);
+					operands?.push({
+						offset: cursor + 2,
+						...token
+					});
 					const argumentCount = readCompressed(blob, token.next);
 					if (argumentCount.value === 0) return malformedSignature("generic instantiation has no type arguments", token.next);
 					const head = `${generic === 17 ? "valuetype" : "class"}:${String(token.value)}`;
@@ -2343,7 +2406,7 @@ function init_ManagedMemberInspectorCore() {
 				}
 				const types = [];
 				for (let index = 0; index < count; index += 1) {
-					const type = readTypeSignature(blob, cursor, "type", layout);
+					const type = readTypeSignature(blob, cursor, "type", { layout });
 					types.push(type.value);
 					cursor = type.next;
 				}
@@ -2356,12 +2419,12 @@ function init_ManagedMemberInspectorCore() {
 				budget.releaseTransient();
 			}
 		};
-		decodeSignature = (blob) => {
+		decodeSignature = (blob, operands = []) => {
 			try {
 				if (blob.length === 0) throw managedFailure("invalid-blob", "signature", "empty signature", 0);
 				const first = blob[0] ?? 0;
 				if (first === 6) {
-					const fieldType = readTypeSignature(blob, 1, "field");
+					const fieldType = readTypeSignature(blob, 1, "field", { operands });
 					return {
 						kind: "field",
 						parse_status: fieldType.next === blob.length ? "decoded" : "partial",
@@ -2375,11 +2438,11 @@ function init_ManagedMemberInspectorCore() {
 					};
 				}
 				const header = readMethodSignatureHeader(blob, 0, "member");
-				const returnType = readTypeSignature(blob, header.next, "return");
+				const returnType = readTypeSignature(blob, header.next, "return", { operands });
 				let offset = returnType.next;
 				const parameters = [];
 				for (let index = 0; index < header.parameterCount; index += 1) {
-					const parameter = readTypeSignature(blob, offset, "parameter");
+					const parameter = readTypeSignature(blob, offset, "parameter", { operands });
 					parameters.push(parameter.value);
 					offset = parameter.next;
 				}
@@ -2420,11 +2483,31 @@ function init_ManagedMemberInspectorCore() {
 			}
 		};
 		signatureGenericArity = (decoded) => decoded.kind === "method" && decoded.parse_status === "decoded" ? decoded.generic_parameter_count ?? 0 : null;
-		signature = (blob, rawSha256) => ({
-			raw_length: blob.length,
-			raw_sha256: rawSha256 ?? sha256Bytes(blob),
-			...decodeSignature(blob)
-		});
+		OPERAND_MARKER = Buffer.from([255]);
+		resolvedSha256 = (blob, operands, typeName) => {
+			const hash = createHash("sha256");
+			let copied = 0;
+			for (const operand of operands) {
+				const name = typeName(operand.value);
+				if (name === null) return null;
+				hash.update(blob.subarray(copied, operand.offset));
+				hash.update(OPERAND_MARKER);
+				hash.update(name);
+				copied = operand.next;
+			}
+			hash.update(blob.subarray(copied));
+			return hash.digest("hex");
+		};
+		signature = (blob, rawSha256, typeName = () => null) => {
+			const operands = [];
+			const decoded = decodeSignature(blob, operands);
+			return {
+				raw_length: blob.length,
+				raw_sha256: rawSha256 ?? sha256Bytes(blob),
+				resolved_sha256: decoded.kind === "unknown" ? null : resolvedSha256(blob, operands, typeName),
+				...decoded
+			};
+		};
 	})))();
 }
 
@@ -2499,67 +2582,160 @@ function init_ManagedMethodSpecs() {
 	})))();
 }
 
+//#endregion
+//#region dist/dotnet/ManagedTypeNameDigests.js
+var TYPE_REF, TYPE_DEF, MAX_TYPE_NESTING_DEPTH, TOP_LEVEL, NESTED, NAME_SEPARATOR, nestedTypeDigests, managedTypeNameDigests;
+function init_ManagedTypeNameDigests() {
+	return (init_ManagedTypeNameDigests = __esmMin((() => {
+		init_ManagedDecodeBudget();
+		init_ManagedMetadataHeaps();
+		init_ManagedReaderFailure();
+		TYPE_REF = 1;
+		TYPE_DEF = 2;
+		MAX_TYPE_NESTING_DEPTH = 64;
+		TOP_LEVEL = Buffer.from([0]);
+		NESTED = Buffer.from([1]);
+		NAME_SEPARATOR = Buffer.from([0]);
+		nestedTypeDigests = (link, retain) => {
+			const named = new Map();
+			const remember = (row, value) => {
+				retain();
+				named.set(row, value);
+			};
+			const links = new Map();
+			const readLink = (row) => {
+				const known = links.get(row);
+				if (known !== undefined) return known;
+				const read = link(row);
+				retain();
+				links.set(row, read);
+				return read;
+			};
+			return (row) => {
+				const path = [];
+				const seen = new Set();
+				let outer = null;
+				for (let current = row; current !== null;) {
+					const known = named.get(current);
+					if (known !== undefined) {
+						if (known === null) {
+							for (const step of path) remember(step.row, null);
+							return null;
+						}
+						outer = known;
+						break;
+					}
+					if (seen.has(current)) {
+						for (const step of path) remember(step.row, null);
+						return null;
+					}
+					if (path.length === 64) {
+						remember(row, null);
+						return null;
+					}
+					const step = readLink(current);
+					if (step === null) {
+						remember(current, null);
+						for (const visited of path) remember(visited.row, null);
+						return null;
+					}
+					seen.add(current);
+					path.push({
+						row: current,
+						link: step
+					});
+					current = step.enclosingRow;
+				}
+				let inner = outer;
+				let exceeded = false;
+				for (const step of path.reverse()) {
+					const depth = (inner?.depth ?? 0) + 1;
+					exceeded ||= depth > 64;
+					if (exceeded) {
+						remember(step.row, null);
+						continue;
+					}
+					const hash = createHash("sha256");
+					if (inner === null) hash.update(TOP_LEVEL);
+					else hash.update(NESTED).update(inner.digest);
+					hash.update(step.link.namespace).update(NAME_SEPARATOR).update(step.link.name);
+					inner = {
+						digest: hash.digest(),
+						depth
+					};
+					remember(step.row, inner);
+				}
+				return exceeded ? null : inner?.digest ?? null;
+			};
+		};
+		managedTypeNameDigests = (layout, issues, parsedTypes, reference) => {
+			const retain = () => managedDecodeBudget(layout).reserve(128, null);
+			managedDecodeBudget(layout).reserve(parsedTypes.types.length * 128, null);
+			const types = new Map();
+			for (const type of parsedTypes.types) types.set(type.token, type);
+			const definitions = nestedTypeDigests((row) => {
+				if (!parsedTypes.nesting.complete) return null;
+				const type = types.get(metadataToken(TYPE_DEF, row));
+				if (type === undefined && (row < 1 || row > (layout.table(TYPE_DEF)?.rowCount ?? 0))) {
+					readManagedValue(() => {
+						throw managedFailure("invalid-row", `metadata.signature.type:${TYPE_DEF}:${row}`, `Signature references an unavailable TypeDef row ${row}`);
+					}, issues);
+					return null;
+				}
+				if (type === undefined) return null;
+				const enclosingRow = parsedTypes.nesting.enclosing.get(row) ?? null;
+				const nested = (type.flags & 7) >= 2;
+				if (nested !== (enclosingRow !== null)) {
+					managedDecodeBudget(layout).reserve(512, type.row_offset);
+					readManagedValue(() => {
+						throw managedFailure("invalid-row", `metadata.TypeDef:${type.token}`, nested ? `Nested TypeDef ${type.token} has no NestedClass enclosing entry` : `Top-level TypeDef ${type.token} has a NestedClass enclosing entry`, type.row_offset);
+					}, issues);
+					return null;
+				}
+				return {
+					namespace: type.namespace,
+					name: type.name,
+					enclosingRow
+				};
+			}, retain);
+			const references = nestedTypeDigests((row) => {
+				const value = reference(row);
+				return value?.scopeValid === true ? value : null;
+			}, retain);
+			const digests = new Map();
+			return (codedIndex) => {
+				let digest = digests.get(codedIndex);
+				if (digest === undefined) {
+					managedDecodeBudget(layout).reserve(256, null);
+					const row = codedIndex >>> 2;
+					const table = codedIndex & 3;
+					digest = table === 0 ? definitions(row) : table === 1 ? references(row) : null;
+					digests.set(codedIndex, digest);
+				}
+				return digest;
+			};
+		};
+	})))();
+}
+
 //#endregion
 //#region dist/dotnet/ManagedTypeNames.js
 var typeNameLookup;
 function init_ManagedTypeNames() {
 	return (init_ManagedTypeNames = __esmMin((() => {
-		init_ManagedDecodeBudget();
 		init_ManagedMemberInspectorCore();
 		init_ManagedMetadataLayout();
 		init_ManagedMetadataHeaps();
 		init_ManagedReaderFailure();
-		typeNameLookup = (bytes, layout, ranges, issues) => {
+		typeNameLookup = (bytes, layout, ranges, issues, references) => {
 			const names = new Map();
-			const checkedScopes = new Set();
-			const validateScopeChain = (row) => {
-				const path = new Set();
-				let current = row;
-				while (!checkedScopes.has(current)) {
-					const cursor = metadataRowCursor(bytes, layout, 1, current);
-					if (path.has(current)) {
-						issues.push({
-							code: "invalid-row",
-							scope: `metadata.TypeRef:${metadataToken(1, current)}`,
-							offset: cursor.start,
-							detail: "TypeRef ResolutionScope chain contains a cycle"
-						});
-						break;
-					}
-					managedDecodeBudget(layout).reserve(128, cursor.start);
-					path.add(current);
-					const raw = cursor.readIndex(layout.codedIndexSize("ResolutionScope"));
-					const reason = metadataCodedTokenInvalidReason(raw, 2, [
-						0,
-						26,
-						35,
-						1
-					], layout.rowCounts);
-					if (reason !== null) {
-						issues.push({
-							code: "invalid-row",
-							scope: `metadata.TypeRef:${metadataToken(1, current)}`,
-							offset: cursor.start,
-							detail: `TypeRef ResolutionScope coded index 0x${raw.toString(16)} is invalid: ${reason}`
-						});
-						break;
-					}
-					if (raw === 0 || (raw & 3) !== 3) break;
-					current = Math.floor(raw / 4);
-				}
-				for (const visited of path) checkedScopes.add(visited);
-			};
 			const definitionName = (table, row) => {
 				if (table === 2) {
 					metadataRowOffset(layout, 2, row);
 					return ranges[row - 1]?.fullName ?? null;
 				}
-				const cursor = metadataRowCursor(bytes, layout, 1, row);
-				cursor.readIndex(layout.codedIndexSize("ResolutionScope"));
-				readManagedValue(() => validateScopeChain(row), issues);
-				const name = cursor.readIndex(layout.stringIndexSize);
-				const namespace = cursor.readIndex(layout.stringIndexSize);
-				return fullName(readMetadataString(bytes, layout, namespace, layout.strings.size), readMetadataString(bytes, layout, name, layout.strings.size));
+				const reference = references(row);
+				return reference === null ? null : fullName(reference.namespace, reference.name);
 			};
 			const specName = (row) => {
 				const cursor = metadataRowCursor(bytes, layout, 27, row);
@@ -2589,6 +2765,103 @@ function init_ManagedTypeNames() {
 	})))();
 }
 
+//#endregion
+//#region dist/dotnet/ManagedTypeReferences.js
+var managedTypeReferences;
+function init_ManagedTypeReferences() {
+	return (init_ManagedTypeReferences = __esmMin((() => {
+		init_ManagedDecodeBudget();
+		init_ManagedMetadataHeaps();
+		init_ManagedReaderFailure();
+		init_ManagedMetadataLayout();
+		managedTypeReferences = (bytes, layout, issues) => {
+			const rows = new Map();
+			const names = new Map();
+			const checked = new Map();
+			const read = (row) => {
+				const cached = rows.get(row);
+				if (cached !== undefined) return cached;
+				managedDecodeBudget(layout).reserve(384, null);
+				const value = readManagedValue(() => {
+					const cursor = metadataRowCursor(bytes, layout, 1, row);
+					const raw = cursor.readIndex(layout.codedIndexSize("ResolutionScope"));
+					const reason = metadataCodedTokenInvalidReason(raw, 2, [
+						0,
+						26,
+						35,
+						1
+					], layout.rowCounts);
+					if (reason !== null) issues.push({
+						code: "invalid-row",
+						scope: `metadata.TypeRef:${metadataToken(1, row)}`,
+						offset: cursor.start,
+						detail: `TypeRef ResolutionScope coded index 0x${raw.toString(16)} is invalid: ${reason}`
+					});
+					return {
+						nameIndex: cursor.readIndex(layout.stringIndexSize),
+						namespaceIndex: cursor.readIndex(layout.stringIndexSize),
+						enclosingRow: raw !== 0 && (raw & 3) === 3 ? Math.floor(raw / 4) : null,
+						scopeValid: reason === null
+					};
+				}, issues) ?? null;
+				rows.set(row, value);
+				return value;
+			};
+			const validate = (row) => {
+				const prior = checked.get(row);
+				if (prior !== undefined) return prior;
+				const path = [];
+				const seen = new Set();
+				let current = row;
+				let valid = true;
+				while (current !== null) {
+					const known = checked.get(current);
+					if (known !== undefined) {
+						valid = known;
+						break;
+					}
+					if (seen.has(current)) {
+						issues.push({
+							code: "invalid-row",
+							scope: `metadata.TypeRef:${metadataToken(1, current)}`,
+							offset: metadataRowOffset(layout, 1, current),
+							detail: "TypeRef ResolutionScope chain contains a cycle"
+						});
+						valid = false;
+						break;
+					}
+					seen.add(current);
+					path.push(current);
+					const value = read(current);
+					if (value === null || !value.scopeValid) {
+						valid = false;
+						break;
+					}
+					current = value.enclosingRow;
+				}
+				for (const visited of path) checked.set(visited, valid);
+				return valid;
+			};
+			return (row) => {
+				const cached = names.get(row);
+				if (cached !== undefined) return cached;
+				const value = read(row);
+				if (value === null) return null;
+				const scopeValid = validate(row);
+				managedDecodeBudget(layout).reserve(128, null);
+				const named = readManagedValue(() => ({
+					namespace: readMetadataString(bytes, layout, value.namespaceIndex, layout.strings.size),
+					name: readMetadataString(bytes, layout, value.nameIndex, layout.strings.size),
+					enclosingRow: value.enclosingRow,
+					scopeValid
+				}), issues) ?? null;
+				names.set(row, named);
+				return named;
+			};
+		};
+	})))();
+}
+
 //#endregion
 //#region dist/dotnet/ManagedUserStrings.js
 var inventory, USER_STRING_TOKEN_BYTES, parseUserStrings;
@@ -3961,7 +4234,7 @@ function init_ManagedMemberRows() {
 		init_ManagedMethodBodyReader();
 		init_ManagedMemberOwnership();
 		isSelected = (selected, declared) => selected === null || declared !== undefined && selected.has(declared.token);
-		parseFields$1 = (bytes, layout, ranges, memberLists, selected = null) => {
+		parseFields$1 = (bytes, layout, ranges, memberLists, { signatureTypeName, selected = null }) => {
 			const fields = [];
 			const core = new Map();
 			const issues = [];
@@ -3990,7 +4263,7 @@ function init_ManagedMemberRows() {
 						declaring_type: declared?.fullName ?? null,
 						name,
 						flags,
-						signature: budgetedSignature(sig, layout)
+						signature: budgetedSignature(sig, layout, signatureTypeName)
 					});
 				}, issues);
 			}
@@ -4047,7 +4320,7 @@ function init_ManagedMemberRows() {
 				issues
 			};
 		};
-		parseMemberRefs = (bytes, layout, typeName) => {
+		parseMemberRefs = (bytes, layout, typeName, signatureTypeName) => {
 			const refs = [];
 			const core = new Map();
 			const issues = [];
@@ -4080,7 +4353,7 @@ function init_ManagedMemberRows() {
 						27
 					], layout.rowCounts);
 					const parentName = typeName(parentToken);
-					const decoded = budgetedSignature(sig, layout);
+					const decoded = budgetedSignature(sig, layout, signatureTypeName);
 					refs.push({
 						token,
 						row_offset: cursor.start,
@@ -4104,7 +4377,7 @@ function init_ManagedMemberRows() {
 				issues
 			};
 		};
-		parseMethods$1 = ({ bytes, layout, pe, ranges, memberLists, selected = null, methodOffset = 0, methodLimit = Number.MAX_SAFE_INTEGER }) => {
+		parseMethods$1 = ({ bytes, layout, pe, ranges, signatureTypeName, memberLists, selected = null, methodOffset = 0, methodLimit = Number.MAX_SAFE_INTEGER }) => {
 			const methods = [];
 			const core = new Map();
 			const issues = [];
@@ -4135,7 +4408,7 @@ function init_ManagedMemberRows() {
 					if (!isSelected(selected, declared)) return;
 					const sig = readMetadataBlob(bytes, layout, cursor.readIndex(layout.blobIndexSize), layout.blob.size);
 					cursor.readIndex(layout.tableIndexSize(8));
-					const decoded = budgetedSignature(sig, layout);
+					const decoded = budgetedSignature(sig, layout, signatureTypeName);
 					core.set(token, {
 						...member,
 						genericArity: signatureGenericArity(decoded)
@@ -4216,11 +4489,11 @@ function init_ManagedMemberRows() {
 		};
 		callerName = (method) => method.declaring_type === null ? method.name : `${method.declaring_type}.${method.name}`;
 		callerNameBytes = (method) => method.declaring_type === null ? managedJsonStringBytes(method.name) : managedJsonStringBytes(method.declaring_type) + managedJsonStringBytes(method.name) - 1;
-		budgetedSignature = (bytes, layout) => {
+		budgetedSignature = (bytes, layout, signatureTypeName) => {
 			const budget = managedDecodeBudget(layout);
 			budget.admitTransient(bytes.length * 256, layout.blob.offset);
 			try {
-				return admitManagedProjection(signature(bytes, budget.digest(bytes, "sha256")), budget);
+				return admitManagedProjection(signature(bytes, budget.digest(bytes, "sha256"), signatureTypeName), budget);
 			} finally {
 				budget.releaseTransient();
 			}
@@ -4241,7 +4514,9 @@ function init_ManagedMemberInspector() {
 		init_ManagedReaderFailure();
 		init_ManagedMemberInspectorCore();
 		init_ManagedMethodSpecs();
+		init_ManagedTypeNameDigests();
 		init_ManagedTypeNames();
+		init_ManagedTypeReferences();
 		init_ManagedUserStrings();
 		init_ManagedTypeMemberLists();
 		init_ManagedMemberRows();
@@ -4264,6 +4539,8 @@ function init_ManagedMemberInspector() {
 				requires_mvid: null
 			},
 			types: [],
+			signature_resolution: "type-names-v1",
+			nesting_read: false,
 			exported_types: null,
 			user_strings: null,
 			fields: [],
@@ -4331,14 +4608,20 @@ function init_ManagedMemberInspector() {
 				appendManagedParseIssues(issues, parsedTypes.issues);
 				const exportedTypes = parseExportedTypes(bytes, layout);
 				appendManagedParseIssues(issues, exportedTypes.issues);
-				const fields = parseFields$1(bytes, layout, ranges, memberLists, selected);
-				const memberRefs = parseMemberRefs(bytes, layout, typeNameLookup(bytes, layout, ranges, issues));
+				const typeReferences = managedTypeReferences(bytes, layout, issues);
+				const signatureTypeName = managedTypeNameDigests(layout, issues, parsedTypes, typeReferences);
+				const fields = parseFields$1(bytes, layout, ranges, memberLists, {
+					signatureTypeName,
+					selected
+				});
+				const memberRefs = parseMemberRefs(bytes, layout, typeNameLookup(bytes, layout, ranges, issues, typeReferences), signatureTypeName);
 				appendManagedParseIssues(issues, memberRefs.issues);
 				const methods = parseMethods$1({
 					bytes,
 					layout,
 					pe,
 					ranges,
+					signatureTypeName,
 					memberLists,
 					selected,
 					methodOffset,
@@ -4355,13 +4638,21 @@ function init_ManagedMemberInspector() {
 					methods.core
 				]);
 				appendManagedParseIssues(issues, targets.issues);
-				const coverageIssues = uniqueManagedParseIssues(issues);
 				const incompleteMembers = [
 					...fields.fields,
 					...memberRefs.refs,
 					...methods.methods
 				].some((member) => member.signature.parse_status !== "decoded") || methods.methods.some((method) => method.body.status === "partial" || method.body.status === "malformed");
 				const related = edges(methods.methods, targets.members, managedDecodeBudget(layout));
+				const types = parsedTypes.types.filter((type) => selected === null || selected.has(type.token)).map((type) => {
+					managedDecodeBudget(layout).reserve(512, type.row_offset);
+					return {
+						...type,
+						name_sha256: signatureTypeName(Number.parseInt(type.token.slice(4), 16) * 4)?.toString("hex") ?? null
+					};
+				});
+				const unnamedTypes = types.reduce((count, type) => count + Number(type.name_sha256 === null), 0);
+				const coverageIssues = uniqueManagedParseIssues(issues);
 				return managedMemberInspectionSchema.parse(admitManagedProjection({
 					artifact: {
 						path: target.path,
@@ -4380,7 +4671,9 @@ function init_ManagedMemberInspector() {
 						requires_artifact_sha256: target.sha256,
 						requires_mvid: inventory.module?.mvid ?? null
 					},
-					types: selected === null ? parsedTypes.types : parsedTypes.types.filter((type) => selected.has(type.token)),
+					types,
+					signature_resolution: "type-names-v1",
+					nesting_read: parsedTypes.nesting.complete,
 					exported_types: exportedTypes.exportedTypes,
 					fields: fields.fields,
 					methods: methods.methods,
@@ -4394,6 +4687,7 @@ function init_ManagedMemberInspector() {
 						issues: coverageIssues
 					},
 					limitations: [
+						...unnamedTypes === 0 ? [] : [`${String(unnamedTypes)} returned TypeDef name identity(s) remain unresolved; incomplete, missing, contradictory, cyclic or over-deep enclosing facts cannot be repaired by bare display names.`],
 						"Metadata tokens are build-local coordinates and are only meaningful with the reported artifact SHA-256 and MVID.",
 						"CIL instruction anchors are decoded from file-backed method bodies only; no target assembly is loaded or executed.",
 						"Exported types are reported from ExportedType rows as declared; forwarded types are not resolved in their implementing assemblies.",
@@ -4625,24 +4919,24 @@ function init_ManagedNativeBoundaryHelpers() {
 			if (managedKind === "unmanaged") return "unmanaged-method";
 			return "mixed-or-unknown";
 		};
-		cliNative = (pe) => {
-			if (pe.cli === null) return null;
+		cliNative = (cli) => {
+			if (cli === null) return null;
 			return {
-				il_only: (pe.cli.flags & 1) !== 0,
-				requires_32bit: managedCli32BitRequirement(pe.cli.flags) === "required",
-				strong_name_signed: (pe.cli.flags & 8) !== 0,
-				native_entry_point: (pe.cli.flags & 16) !== 0,
-				ready_to_run_signature: pe.cli.readyToRunSignature,
-				managed_native_header_rva: pe.cli.managedNativeHeader.rva,
-				managed_native_header_size: pe.cli.managedNativeHeader.size
+				il_only: (cli.flags & 1) !== 0,
+				requires_32bit: managedCli32BitRequirement(cli.flags) === "required",
+				strong_name_signed: (cli.flags & 8) !== 0,
+				native_entry_point: (cli.flags & 16) !== 0,
+				ready_to_run_signature: cli.readyToRunSignature,
+				managed_native_header_rva: cli.managedNativeHeader.rva,
+				managed_native_header_size: cli.managedNativeHeader.size
 			};
 		};
-		nativeBoundarySummary = (native, counts) => ({
+		nativeBoundarySummary = (cli, counts) => ({
 			...counts,
-			ready_to_run: native?.ready_to_run_signature ?? null,
-			mixed_mode_or_native_header: native === null ? null : native.managed_native_header_rva !== 0 || native.managed_native_header_size !== 0 || native.native_entry_point
+			ready_to_run: cli?.readyToRunSignature ?? null,
+			mixed_mode_or_native_header: cli === null ? null : managedCliIsMixedClrNative(cli) || cli.managedNativeHeader.rva !== 0 || cli.managedNativeHeader.size !== 0 || (cli.flags & 16) !== 0
 		});
-		buildNativeBoundaryInspection = ({ target, bytes, layout, inventory, moduleRefs, imports, implementations, native, issues }) => managedNativeBoundaryInspectionSchema.parse(admitManagedProjection({
+		buildNativeBoundaryInspection = ({ target, bytes, pe, layout, inventory, moduleRefs, imports, implementations, issues }) => managedNativeBoundaryInspectionSchema.parse(admitManagedProjection({
 			artifact: {
 				path: target.path,
 				sha256: target.sha256,
@@ -4660,11 +4954,11 @@ function init_ManagedNativeBoundaryHelpers() {
 				requires_artifact_sha256: target.sha256,
 				requires_mvid: inventory.module?.mvid ?? null
 			},
-			cli_native: native,
+			cli_native: cliNative(pe.cli),
 			module_refs: moduleRefs,
 			pinvoke_imports: imports,
 			native_implementations: implementations,
-			summary: nativeBoundarySummary(native, {
+			summary: nativeBoundarySummary(pe.cli, {
 				module_ref_count: moduleRefs.length,
 				pinvoke_import_count: imports.length,
 				native_implementation_count: implementations.length
@@ -4695,7 +4989,7 @@ function init_ManagedNativeBoundaryInspector() {
 		init_ManagedPeReader();
 		init_ManagedReaderFailure();
 		init_ManagedNativeBoundaryHelpers();
-		emptyInspection = (target, bytes, classification, { native = null, issues = [] } = {}) => {
+		emptyInspection = (target, bytes, classification, { cli = null, issues = [] } = {}) => {
 			return managedNativeBoundaryInspectionSchema.parse(admitManagedProjection({
 				artifact: {
 					path: target.path,
@@ -4714,11 +5008,11 @@ function init_ManagedNativeBoundaryInspector() {
 					requires_artifact_sha256: target.sha256,
 					requires_mvid: null
 				},
-				cli_native: native,
+				cli_native: cliNative(cli),
 				module_refs: [],
 				pinvoke_imports: [],
 				native_implementations: [],
-				summary: nativeBoundarySummary(native, {
+				summary: nativeBoundarySummary(cli, {
 					module_ref_count: 0,
 					pinvoke_import_count: 0,
 					native_implementation_count: 0
@@ -4751,7 +5045,7 @@ function init_ManagedNativeBoundaryInspector() {
 			} catch (cause) {
 				if (!(cause instanceof ManagedReaderFailure)) throw cause;
 				return emptyInspection(target, bytes, "malformed", {
-					native: cliNative(pe),
+					cli: pe.cli,
 					issues: [cause.issue]
 				});
 			}
@@ -4779,13 +5073,12 @@ function init_ManagedNativeBoundaryInspector() {
 					moduleRefs,
 					imports,
 					implementations,
-					native: cliNative(pe),
 					issues
 				});
 			} catch (cause) {
 				if (!(cause instanceof ManagedReaderFailure)) throw cause;
 				return emptyInspection(target, bytes, "malformed", {
-					native: cliNative(pe),
+					cli: pe.cli,
 					issues: [...issues, cause.issue]
 				});
 			}
@@ -4830,16 +5123,15 @@ function init_ManagedSnapshot() {
 			if (metadata.size > 134217728) throw managedSnapshotCapacityError(operation);
 			const digest = createHash("sha256");
 			let byteLength = 0;
-			const stream = handle.createReadStream({
-				autoClose: false,
-				...signal === undefined ? {} : { signal }
-			});
-			for await (const chunk of stream) {
+			const chunk = Buffer.allocUnsafe(64 * 1024);
+			for (;;) {
 				signal?.throwIfAborted();
-				if (!Buffer.isBuffer(chunk)) throw new TypeError("Managed source stream returned non-buffer data");
-				if (chunk.length > 134217728 - byteLength) throw managedSnapshotCapacityError(operation);
-				byteLength += chunk.length;
-				digest.update(chunk);
+				const { bytesRead } = await handle.read(chunk, 0, Math.min(chunk.length, MAX_MANAGED_SNAPSHOT_BYTES - byteLength + 1), null);
+				signal?.throwIfAborted();
+				if (bytesRead === 0) break;
+				if (bytesRead > 134217728 - byteLength) throw managedSnapshotCapacityError(operation);
+				byteLength += bytesRead;
+				digest.update(chunk.subarray(0, bytesRead));
 			}
 			return {
 				byteLength,
@@ -4850,6 +5142,7 @@ function init_ManagedSnapshot() {
 			throw normalizeManagedReadFailure(cause, path, operation, options.signal);
 		});
 		normalizeManagedReadFailure = (cause, fallbackPath, operation, signal) => {
+			if (signal?.aborted === true && cause === signal.reason) return normalizeReadFailure(cause, fallbackPath, operation, signal);
 			const cleanupError = managedCleanupError(cause, fallbackPath, operation, signal);
 			if (cleanupError !== undefined) return cleanupError;
 			return normalizeReadFailure(cause, fallbackPath, operation, signal);
@@ -4869,7 +5162,12 @@ function init_ManagedSnapshot() {
 			});
 			return undefined;
 		};
-		normalizeReadFailure = (cause, path, operation, signal) => cause instanceof RegularFileChangedError ? new EvidenceIntegrityError(`Managed source changed while ${operation} was reading ${path}.`, { cause }) : cause instanceof AnalysisError ? cause : classifyBinaryTargetFilesystemFailure(path, cause) ?? (signal?.aborted === true ? new AnalysisCancelledError(operation, { cause }) : cause);
+		normalizeReadFailure = (cause, path, operation, signal) => {
+			if (signal?.aborted === true && cause === signal.reason) return new AnalysisCancelledError(operation, { cause });
+			if (cause instanceof RegularFileChangedError) return new EvidenceIntegrityError(`Managed source changed while ${operation} was reading ${path}.`, { cause });
+			if (cause instanceof AnalysisError) return cause;
+			return classifyBinaryTargetFilesystemFailure(path, cause) ?? (signal?.aborted === true ? new AnalysisCancelledError(operation, { cause }) : cause);
+		};
 	})))();
 }