rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{ManagedSnapshot-rqyBHcdL.js → ManagedSnapshot-CPE9C3OD.js}

@@ -1,15 +1,16 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { AnalysisCancelledError, AnalysisError, AnalysisResourceConstraintError, init_analysisErrorBase, init_analysisErrorCore } from "./errorSchemas-CTRmvMl3.js";
-import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-BXkffc1D.js";
-import { RegularFileChangedError, init_RegularFile } from "./RegularFile-B_6KPCNQ.js";
-import { EvidenceIntegrityError, init_evidenceErrors } from "./analysisErrorPresentation-DGt7TdsH.js";
-import { analysisErrorWithCleanupFailure, init_analysisErrorCleanup } from "./analysisErrorCleanup-Do6YeeoD.js";
-import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-Ceq8f0wK.js";
-import { MANAGED_STATIC_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-DoQRIHii.js";
-import { init_BoundedFileBytes, readBoundedFileBytes } from "./BoundedFileBytes-BU30odTm.js";
-import { RegularFileCleanupFailure, init_RegularFileRead, withRegularFile } from "./RegularFileRead-DVlC5faM.js";
-import { init_managedArtifact, managedMemberInspectionSchema } from "./managedApplicationGraph-B08jb3jq.js";
-import { classifyBinaryTargetFilesystemFailure, decodePeMachine, init_BinaryTargetResolver, init_peMachine } from "./BinaryTargetResolver-CVIJ_s1A.js";
+import { AnalysisCancelledError, AnalysisError, AnalysisResourceConstraintError, init_analysisErrorBase, init_analysisErrorCore } from "./errorSchemas-Ixz_q7qt.js";
+import { RegularFileChangedError, RegularFileCleanupFailure, init_OwnedRegularFile, init_RegularFile } from "./OwnedRegularFile-D1f5nUCx.js";
+import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-DMwm42bk.js";
+import { EvidenceIntegrityError, init_evidenceErrors } from "./cliResultOutput-10sd6xGx.js";
+import { analysisErrorWithCleanupFailure, init_analysisErrorCleanup } from "./analysisErrorCleanup-COdAmDsb.js";
+import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-BhsJyAhk.js";
+import { MANAGED_STATIC_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-CFh4a64d.js";
+import { init_BoundedFileBytes, readBoundedFileBytes } from "./BoundedFileBytes-DRtiQNAQ.js";
+import { init_RegularFileRead, withRegularFile } from "./RegularFileRead-mbgGYtxe.js";
+import { init_managedArtifact, managedMemberInspectionSchema } from "./managedApplicationGraph-BazVqpJv.js";
+import { decodePeMachine, init_peMachine } from "./peMachine-B9ggfSJJ.js";
+import { classifyBinaryTargetFilesystemFailure, init_BinaryTargetResolver } from "./BinaryTargetResolver-tuCTjBlQ.js";
 import { createHash } from "node:crypto";
 
 //#region dist/dotnet/ManagedReaderFailure.js
@@ -58,6 +59,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;
@@ -104,6 +106,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);
 			}
@@ -154,6 +164,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);
@@ -168,6 +179,7 @@ function init_ManagedDecodeBudget() {
 				}
 			};
 			visit(value);
+			if (value !== null && typeof value === "object") budget.prepay(value);
 			return value;
 		};
 	})))();
@@ -175,7 +187,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();
@@ -185,6 +197,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);
 		};
@@ -617,17 +630,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)
@@ -655,25 +668,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,
@@ -690,7 +703,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,
@@ -706,12 +719,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;
@@ -743,7 +756,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)}`,
@@ -761,7 +774,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,
@@ -1003,7 +1016,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);
@@ -1526,13 +1538,44 @@ function init_ManagedMetadataInventory() {
 	})))();
 }
 
+//#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) => {
@@ -1585,6 +1628,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);
@@ -1607,6 +1651,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,
@@ -1619,6 +1664,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,
@@ -1634,7 +1681,8 @@ function init_ManagedMemberInspectorCore() {
 			}
 			return {
 				types: items,
-				issues
+				issues,
+				nesting
 			};
 		};
 		readCompressed = (bytes, offset) => {
@@ -1786,7 +1834,7 @@ function init_ManagedMemberInspectorCore() {
 			}
 			return token;
 		};
-		readTypeSignature = (blob, offset, base, layout) => {
+		readTypeSignature = (blob, offset, base, { layout, operands } = {}) => {
 			const stack = [];
 			let cursor = offset;
 			for (;;) {
@@ -1808,6 +1856,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);
@@ -1818,6 +1870,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) {
@@ -1834,6 +1890,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)}`;
@@ -1919,7 +1979,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;
 				}
@@ -1932,12 +1992,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",
@@ -1951,11 +2011,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;
 				}
@@ -1996,11 +2056,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
+			};
+		};
 	})))();
 }
 
@@ -2075,67 +2155,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);
@@ -2165,6 +2338,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;
@@ -3651,7 +3921,7 @@ function init_ManagedMemberRows() {
 		init_ManagedMethodBodyReader();
 		init_ManagedMemberOwnership();
 		isSelected = (selected, declared) => selected === null || declared !== undefined && selected.has(declared.token);
-		parseFields = (bytes, layout, ranges, memberLists, selected = null) => {
+		parseFields = (bytes, layout, ranges, memberLists, { signatureTypeName, selected = null }) => {
 			const fields = [];
 			const core = new Map();
 			const issues = [];
@@ -3680,7 +3950,7 @@ function init_ManagedMemberRows() {
 						declaring_type: declared?.fullName ?? null,
 						name,
 						flags,
-						signature: budgetedSignature(sig, layout)
+						signature: budgetedSignature(sig, layout, signatureTypeName)
 					});
 				}, issues);
 			}
@@ -3737,7 +4007,7 @@ function init_ManagedMemberRows() {
 				issues
 			};
 		};
-		parseMemberRefs = (bytes, layout, typeName) => {
+		parseMemberRefs = (bytes, layout, typeName, signatureTypeName) => {
 			const refs = [];
 			const core = new Map();
 			const issues = [];
@@ -3770,7 +4040,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,
@@ -3794,7 +4064,7 @@ function init_ManagedMemberRows() {
 				issues
 			};
 		};
-		parseMethods = ({ bytes, layout, pe, ranges, memberLists, selected = null, methodOffset = 0, methodLimit = Number.MAX_SAFE_INTEGER }) => {
+		parseMethods = ({ bytes, layout, pe, ranges, signatureTypeName, memberLists, selected = null, methodOffset = 0, methodLimit = Number.MAX_SAFE_INTEGER }) => {
 			const methods = [];
 			const core = new Map();
 			const issues = [];
@@ -3825,7 +4095,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)
@@ -3906,11 +4176,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();
 			}
@@ -3931,7 +4201,9 @@ function init_ManagedMemberInspector() {
 		init_ManagedReaderFailure();
 		init_ManagedMemberInspectorCore();
 		init_ManagedMethodSpecs();
+		init_ManagedTypeNameDigests();
 		init_ManagedTypeNames();
+		init_ManagedTypeReferences();
 		init_ManagedUserStrings();
 		init_ManagedTypeMemberLists();
 		init_ManagedMemberRows();
@@ -3954,6 +4226,8 @@ function init_ManagedMemberInspector() {
 				requires_mvid: null
 			},
 			types: [],
+			signature_resolution: "type-names-v1",
+			nesting_read: false,
 			exported_types: null,
 			user_strings: null,
 			fields: [],
@@ -4021,14 +4295,20 @@ function init_ManagedMemberInspector() {
 				appendManagedParseIssues(issues, parsedTypes.issues);
 				const exportedTypes = parseExportedTypes(bytes, layout);
 				appendManagedParseIssues(issues, exportedTypes.issues);
-				const fields = parseFields(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(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({
 					bytes,
 					layout,
 					pe,
 					ranges,
+					signatureTypeName,
 					memberLists,
 					selected,
 					methodOffset,
@@ -4045,13 +4325,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,
@@ -4070,7 +4358,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,
@@ -4084,6 +4374,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.",
@@ -4138,16 +4429,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,
@@ -4158,6 +4448,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);
@@ -4177,9 +4468,14 @@ 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);
+		};
 	})))();
 }
 
 //#endregion
-export { ManagedReaderFailure, admitManagedProjection, hashManagedSource, init_ManagedDecodeBudget, init_ManagedMemberInspector, init_ManagedMetadataHeaps, init_ManagedMetadataInventory, init_ManagedMetadataLayout, init_ManagedPeReader, init_ManagedReaderFailure, init_ManagedSnapshot, init_ManagedTypeMemberLists, inspectManagedMembersBytes, managedCleanupError, managedCli32BitRequirement, managedDecodeBudget, managedTableRowCounts, metadataCodedToken, metadataCodedTokenInvalidReason, metadataRowCursor, metadataToken, readManagedMetadataInventory, readManagedMetadataLayout, readManagedPeLayout, readManagedResourceDirectory, readManagedSnapshot, readManagedValue, readMetadataString, readTypeMemberListFacts };
+export { ManagedReaderFailure, admitManagedProjection, hashManagedSource, init_ManagedDecodeBudget, init_ManagedMemberInspector, init_ManagedMetadataHeaps, init_ManagedMetadataInventory, init_ManagedMetadataLayout, init_ManagedPeReader, init_ManagedReaderFailure, init_ManagedSnapshot, init_ManagedTypeMemberLists, inspectManagedMembersBytes, managedCleanupError, managedCli32BitRequirement, managedCliIsMixedClrNative, managedDecodeBudget, managedTableRowCounts, metadataCodedToken, metadataCodedTokenInvalidReason, metadataRowCursor, metadataToken, readManagedMetadataInventory, readManagedMetadataLayout, readManagedPeLayout, readManagedResourceDirectory, readManagedSnapshot, readManagedValue, readMetadataString, readTypeMemberListFacts };