rea-agents 6.4.0 → 6.7.0

package/dist/dotnet/ManagedMemberInspectorCore.js

@@ -1,104 +1,59 @@
+import { createHash } from "node:crypto";
 import { managedFailure, ManagedReaderFailure, readManagedValue, } from "./ManagedReaderFailure.js";
-import {} from "./ManagedMetadataLayout.js";
+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";
+import { readManagedTypeNesting, } from "./ManagedTypeNesting.js";
 import { metadataRowCursor, metadataCodedToken, metadataCodedTokenInvalidReason, metadataToken, readMetadataString, sha256Bytes, } from "./ManagedMetadataHeaps.js";
-const rowRange = (table, start, nextStart) => {
+import { memberListTable } from "./ManagedMemberPointers.js";
+const rowRange = (table, start, end) => {
     const total = table?.rowCount ?? 0;
-    if (total === 0 || start === 0)
+    if (start === null || end === null)
         return { first: null, last: null, count: 0 };
-    const end = Math.min(nextStart === 0 ? total + 1 : nextStart, total + 1);
-    if (start >= end)
+    const lastExclusive = Math.min(end, total + 1);
+    if (start >= lastExclusive)
         return { first: null, last: null, count: 0 };
-    return { first: start, last: end - 1, count: end - start };
+    return {
+        first: start,
+        last: lastExclusive - 1,
+        count: lastExclusive - start,
+    };
 };
-const fullName = (namespace, name) => namespace.length === 0 ? name : `${namespace}.${name}`;
-const readTypeRange = (bytes, layout, row, issues) => {
-    const methods = layout.table(6);
-    const fields = layout.table(4);
+export const fullName = (namespace, name) => namespace.length === 0 ? name : `${namespace}.${name}`;
+const readTypeRange = (bytes, layout, row, issues, memberLists) => {
     const cursor = metadataRowCursor(bytes, layout, 2, row);
     cursor.readUInt32();
     const nameIndex = cursor.readIndex(layout.stringIndexSize);
     const namespaceIndex = cursor.readIndex(layout.stringIndexSize);
     const declaredName = readManagedValue(() => fullName(readMetadataString(bytes, layout, namespaceIndex, layout.strings.size), readMetadataString(bytes, layout, nameIndex, layout.strings.size)), issues) ?? null;
     cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
-    const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
-    const methodStart = cursor.readIndex(layout.tableIndexSize(6));
-    let nextField = (fields?.rowCount ?? 0) + 1;
-    let nextMethod = (methods?.rowCount ?? 0) + 1;
-    const typeTable = layout.table(2);
-    if (typeTable !== undefined && row < typeTable.rowCount) {
-        const next = metadataRowCursor(bytes, layout, 2, row + 1);
-        next.readUInt32();
-        next.readIndex(layout.stringIndexSize);
-        next.readIndex(layout.stringIndexSize);
-        next.readIndex(layout.codedIndexSize("TypeDefOrRef"));
-        nextField = next.readIndex(layout.tableIndexSize(4));
-        nextMethod = next.readIndex(layout.tableIndexSize(6));
-    }
+    const current = memberLists.entries[row - 1];
     return {
         token: metadataToken(2, row),
         fullName: declaredName,
-        fieldStart,
-        fieldEnd: nextField,
-        methodStart,
-        methodEnd: nextMethod,
+        fieldStart: current?.field.start.value ?? null,
+        fieldEnd: current?.field.end ?? null,
+        methodStart: current?.method.start.value ?? null,
+        methodEnd: current?.method.end ?? null,
     };
 };
-export const typeRanges = (bytes, layout, issues) => {
+export const typeRanges = (bytes, layout, issues, memberLists) => {
+    issues.push(...memberLists.issues);
     const typeTable = layout.table(2);
     const ranges = [];
     for (let row = 1; row <= (typeTable?.rowCount ?? 0); row += 1)
-        ranges.push(readTypeRange(bytes, layout, row, issues));
+        ranges.push(readTypeRange(bytes, layout, row, issues, memberLists));
     return ranges;
 };
-export const declaringType = (ranges, table, row) => {
-    for (const range of ranges) {
-        const start = table === "field" ? range.fieldStart : range.methodStart;
-        const end = table === "field" ? range.fieldEnd : range.methodEnd;
-        if (row >= start && row < end)
-            return { token: range.token, fullName: range.fullName };
-    }
-    return null;
-};
-/** Resolve member ownership without rescanning ordered type ranges per row. */
-export const createDeclaringTypeLookup = (ranges, table) => {
-    const entries = ranges.map((range) => ({
-        range,
-        start: table === "field" ? range.fieldStart : range.methodStart,
-        end: table === "field" ? range.fieldEnd : range.methodEnd,
-    }));
-    const ordered = entries.every((entry, index) => {
-        const previous = entries[index - 1];
-        return (entry.start <= entry.end &&
-            (previous === undefined || previous.end <= entry.start));
-    });
-    // Malformed metadata can overlap or reverse ranges. Retain the original
-    // first-match interpretation rather than guessing a different owner.
-    if (!ordered)
-        return (row) => declaringType(ranges, table, row);
-    return (row) => {
-        let first = 0;
-        let end = entries.length;
-        while (first < end) {
-            const middle = first + Math.floor((end - first) / 2);
-            const entry = entries[middle];
-            if (entry === undefined)
-                return null;
-            if (row >= entry.start && row < entry.end)
-                return { token: entry.range.token, fullName: entry.range.fullName };
-            if (row < entry.start)
-                end = middle;
-            else
-                first = middle + 1;
-        }
-        return null;
-    };
-};
+/**
+ * Enclosing TypeDef row of each nested TypeDef row, from the NestedClass
+ * table. Nesting is complete only when every row was read and valid.
+ */
 export const parseTypes = (bytes, layout, ranges) => {
     const typeTable = layout.table(2);
-    const fields = layout.table(4);
-    const methods = layout.table(6);
+    const fields = memberListTable(layout, 4);
+    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);
@@ -107,11 +62,9 @@ export const parseTypes = (bytes, layout, ranges) => {
             const namespace = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), layout.strings.size);
             const extendsOffset = cursor.offset;
             const extendsRaw = cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
-            const fieldStart = cursor.readIndex(layout.tableIndexSize(4));
-            const methodStart = cursor.readIndex(layout.tableIndexSize(6));
-            const nextRange = ranges[row] ?? null;
-            const fieldRange = rowRange(fields, fieldStart, nextRange?.fieldStart ?? 0);
-            const methodRange = rowRange(methods, methodStart, nextRange?.methodStart ?? 0);
+            const currentRange = ranges[row - 1] ?? null;
+            const fieldRange = rowRange(fields, currentRange?.fieldStart ?? null, currentRange?.fieldEnd ?? null);
+            const methodRange = rowRange(methods, currentRange?.methodStart ?? null, currentRange?.methodEnd ?? null);
             const extendsReason = metadataCodedTokenInvalidReason(extendsRaw, 2, [2, 1, 27], layout.rowCounts);
             if (extendsReason !== null)
                 issues.push({
@@ -120,6 +73,7 @@ export const parseTypes = (bytes, layout, ranges) => {
                     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,
@@ -128,6 +82,8 @@ export const parseTypes = (bytes, layout, ranges) => {
                 full_name: fullName(namespace, name),
                 flags,
                 extends_token: metadataCodedToken(extendsRaw, 2, [2, 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,
@@ -141,9 +97,9 @@ export const parseTypes = (bytes, layout, ranges) => {
             });
         }, issues);
     }
-    return { types: items, issues };
+    return { types: items, issues, nesting };
 };
-const readCompressed = (bytes, offset) => {
+export const readCompressed = (bytes, offset) => {
     const first = bytes[offset];
     if (first === undefined)
         throw managedFailure("invalid-blob", "signature", "truncated compressed integer", offset);
@@ -184,39 +140,255 @@ const ELEMENT_TYPES = new Map([
     [0x19, "native-uint"],
     [0x1c, "object"],
 ]);
-const readTypeSignature = (blob, offset) => {
-    const suffixes = [];
-    let cursor = offset;
-    let kind = blob[cursor];
-    while (kind === 0x0f || kind === 0x10 || kind === 0x1d) {
-        suffixes.push(kind === 0x0f ? "*" : kind === 0x10 ? "&" : "[]");
-        cursor += 1;
-        kind = blob[cursor];
+const readSignedCompressed = (bytes, offset) => {
+    const encoded = readCompressed(bytes, offset);
+    const width = encoded.next - offset === 1 ? 7 : encoded.next - offset === 2 ? 14 : 29;
+    const magnitude = Math.floor(encoded.value / 2);
+    return {
+        value: encoded.value % 2 === 0 ? magnitude : magnitude - 2 ** (width - 1),
+        next: encoded.next,
+    };
+};
+const malformedSignature = (detail, offset) => {
+    throw managedFailure("invalid-blob", "signature", detail, offset);
+};
+// MethodDefSig and MethodRefSig headers (ECMA-335 II.23.2.1-2) without
+// HASTHIS and EXPLICITTHIS: DEFAULT, VARARG, or GENERIC, which implies DEFAULT.
+const MEMBER_METHOD_HEADERS = new Set([0x00, 0x05, 0x10]);
+// FNPTR also carries the unmanaged C, STDCALL, THISCALL, FASTCALL, and
+// UNMANAGED conventions that compilers emit for unmanaged function pointers.
+const FUNCTION_POINTER_CONVENTIONS = new Set([0, 1, 2, 3, 4, 5, 9]);
+/**
+ * Read a method signature's calling convention and counts. A header that is
+ * not a method signature in its context (a MethodDef or MemberRef row, or an
+ * FNPTR type), sets the reserved bit, or sets EXPLICITTHIS without HASTHIS is
+ * malformed, so no caller consumes its counts. FIELD, LOCAL_SIG, PROPERTY,
+ * and GENERICINST headers are never method signatures.
+ */
+const readMethodSignatureHeader = (blob, offset, context) => {
+    const first = blob[offset];
+    if (first === undefined)
+        return malformedSignature("truncated method signature", offset);
+    const allowed = context === "member"
+        ? MEMBER_METHOD_HEADERS.has(first & 0x9f)
+        : (first & 0x80) === 0 && FUNCTION_POINTER_CONVENTIONS.has(first & 0x0f);
+    if (!allowed || ((first & 0x40) !== 0 && (first & 0x20) === 0))
+        return malformedSignature(`calling convention 0x${first.toString(16)} does not head a ${context} method signature`, offset);
+    let next = offset + 1;
+    let genericParameterCount = null;
+    if ((first & 0x10) !== 0) {
+        const generic = readCompressed(blob, next);
+        genericParameterCount = generic.value;
+        next = generic.next;
     }
-    if (kind === undefined)
-        throw managedFailure("invalid-blob", "signature", "truncated type signature", cursor);
-    const named = ELEMENT_TYPES.get(kind);
-    let value;
-    let next;
-    if (named !== undefined) {
-        value = named;
-        next = cursor + 1;
+    const parameterCount = readCompressed(blob, next);
+    return {
+        first,
+        genericParameterCount,
+        parameterCount: parameterCount.value,
+        next: parameterCount.next,
+    };
+};
+const MAX_ARRAY_RANK = 32;
+const arrayShape = (blob, offset) => {
+    const rank = readCompressed(blob, offset);
+    if (rank.value === 0)
+        return malformedSignature("array rank is zero", offset);
+    // ECMA-335 leaves rank unbounded, but the CLR loads at most 32 dimensions;
+    // larger ranks would expand a few bytes into an unbounded rendering.
+    if (rank.value > MAX_ARRAY_RANK)
+        throw managedFailure("unsupported-signature", "signature", `array rank ${String(rank.value)} exceeds the ${String(MAX_ARRAY_RANK)} dimensions the CLR supports`, offset);
+    const sizeCount = readCompressed(blob, rank.next);
+    if (sizeCount.value > rank.value)
+        return malformedSignature("array has more sizes than dimensions", offset);
+    const sizes = [];
+    let next = sizeCount.next;
+    for (let index = 0; index < sizeCount.value; index += 1) {
+        const size = readCompressed(blob, next);
+        sizes.push(size.value);
+        next = size.next;
     }
-    else if (kind === 0x11 || kind === 0x12) {
-        const token = readCompressed(blob, cursor + 1);
-        value = `${kind === 0x11 ? "valuetype" : "class"}:${String(token.value)}`;
-        next = token.next;
+    const boundCount = readCompressed(blob, next);
+    if (boundCount.value > rank.value)
+        return malformedSignature("array has more lower bounds than dimensions", offset);
+    const lowerBounds = [];
+    next = boundCount.next;
+    for (let index = 0; index < boundCount.value; index += 1) {
+        const bound = readSignedCompressed(blob, next);
+        lowerBounds.push(bound.value);
+        next = bound.next;
     }
-    else if (kind === 0x1e || kind === 0x13) {
-        const variable = readCompressed(blob, cursor + 1);
-        value = `${kind === 0x1e ? "mvar" : "var"}:${String(variable.value)}`;
-        next = variable.next;
+    const dimensions = Array.from({ length: rank.value }, (_, index) => {
+        const size = sizes[index];
+        const lower = lowerBounds[index];
+        if (lower !== undefined)
+            return size === undefined
+                ? `${String(lower)}...`
+                : `${String(lower)}...${String(lower + size - 1)}`;
+        if (size !== undefined)
+            return String(size);
+        // ILAsm spelling: a bare rank-1 `[]` is reserved for SZARRAY.
+        return rank.value === 1 ? "..." : "";
+    });
+    return { value: `[${dimensions.join(",")}]`, next };
+};
+// Custom modifiers do not change the position they precede.
+const currentPosition = (stack, base) => {
+    const frame = stack.findLast(({ kind }) => kind !== "modifiers");
+    if (frame === undefined)
+        return base;
+    if (frame.kind === "suffix")
+        return frame.suffix === "*" ? "pointee" : "type";
+    if (frame.kind === "list" && frame.signatureItems)
+        return frame.items.length === 0 ? "return" : "parameter";
+    return "type";
+};
+// VOID is a RetType or a pointee; TYPEDBYREF is a RetType or Param; BYREF
+// prefixes a RetType, Param, or (since ref fields) a field type.
+const POSITION_ELEMENTS = new Map([
+    [0x01, ["return", "pointee"]],
+    [0x16, ["return", "parameter"]],
+    [0x10, ["return", "parameter", "field"]],
+]);
+/** Decode a type operand once; spec callers also validate its metadata coordinate. */
+const readTypeOperand = (blob, offset, layout, tables = [2, 1, 27]) => {
+    const token = readCompressed(blob, offset);
+    if (layout !== undefined) {
+        const reason = token.value === 0
+            ? "type operand is null"
+            : metadataCodedTokenInvalidReason(token.value, 2, tables, layout.rowCounts);
+        if (reason !== null)
+            throw managedFailure("invalid-row", "signature", `TypeDefOrRefOrSpec operand 0x${token.value.toString(16)} is invalid: ${reason}`, offset);
     }
-    else {
-        throw managedFailure("unsupported-signature", "signature", `unsupported element type 0x${kind.toString(16)}`, cursor);
+    return token;
+};
+const readTypeSignature = (blob, offset, base, { layout, operands, } = {}) => {
+    const stack = [];
+    let cursor = offset;
+    for (;;) {
+        let value;
+        const kind = blob[cursor];
+        if (kind === undefined)
+            return malformedSignature("truncated type signature", cursor);
+        const positions = POSITION_ELEMENTS.get(kind);
+        if (positions !== undefined &&
+            !positions.includes(currentPosition(stack, base)))
+            return malformedSignature(`element type 0x${kind.toString(16)} is not valid in a ${currentPosition(stack, base)} position`, cursor);
+        const named = ELEMENT_TYPES.get(kind);
+        if (named !== undefined) {
+            value = named;
+            cursor += 1;
+        }
+        else if (kind === 0x0f || kind === 0x10 || kind === 0x1d) {
+            const suffix = kind === 0x0f ? "*" : kind === 0x10 ? "&" : "[]";
+            stack.push({ kind: "suffix", suffix });
+            cursor += 1;
+        }
+        else if (kind === 0x1f || kind === 0x20) {
+            const token = readTypeOperand(blob, cursor + 1, layout);
+            operands?.push({ offset: cursor + 1, ...token });
+            const modifier = `${kind === 0x1f ? "modreq" : "modopt"}:${String(token.value)}`;
+            // A modifier frame on top was pushed by the directly preceding byte;
+            // keep an adjacent run together and in source order.
+            const top = stack.at(-1);
+            if (top?.kind === "modifiers")
+                top.modifiers.push(modifier);
+            else
+                stack.push({ kind: "modifiers", modifiers: [modifier] });
+            cursor = token.next;
+        }
+        else if (kind === 0x11 || kind === 0x12) {
+            const token = readTypeOperand(blob, cursor + 1, layout);
+            operands?.push({ offset: cursor + 1, ...token });
+            value = `${kind === 0x11 ? "valuetype" : "class"}:${String(token.value)}`;
+            cursor = token.next;
+        }
+        else if (kind === 0x1e || kind === 0x13) {
+            const variable = readCompressed(blob, cursor + 1);
+            value = `${kind === 0x1e ? "mvar" : "var"}:${String(variable.value)}`;
+            cursor = variable.next;
+        }
+        else if (kind === 0x16) {
+            value = "typedbyref";
+            cursor += 1;
+        }
+        else if (kind === 0x14) {
+            stack.push({ kind: "array" });
+            cursor += 1;
+        }
+        else if (kind === 0x15) {
+            const generic = blob[cursor + 1];
+            if (generic !== 0x11 && generic !== 0x12)
+                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 === 0x11 ? "valuetype" : "class"}:${String(token.value)}`;
+            stack.push({
+                kind: "list",
+                remaining: argumentCount.value,
+                items: [],
+                signatureItems: false,
+                render: (items) => `${head}<${items.join(",")}>`,
+            });
+            cursor = argumentCount.next;
+        }
+        else if (kind === 0x1b) {
+            const header = readMethodSignatureHeader(blob, cursor + 1, "function-pointer");
+            const convention = callingConvention(header.first);
+            const head = header.genericParameterCount === null
+                ? convention
+                : `${convention};${String(header.genericParameterCount)}`;
+            stack.push({
+                kind: "list",
+                remaining: header.parameterCount + 1,
+                items: [],
+                signatureItems: true,
+                render: ([returnType, ...parameters]) => `fnptr[${head}](${parameters.join(",")})->${returnType ?? ""}`,
+            });
+            cursor = header.next;
+        }
+        else {
+            throw managedFailure("unsupported-signature", "signature", `unsupported element type 0x${kind.toString(16)}`, cursor);
+        }
+        while (value !== undefined) {
+            const top = stack.pop();
+            if (top === undefined)
+                return { value, next: cursor };
+            if (top.kind === "suffix")
+                value += top.suffix;
+            else if (top.kind === "modifiers")
+                value = `${value} ${top.modifiers.join(" ")}`;
+            else if (top.kind === "array") {
+                const shape = arrayShape(blob, cursor);
+                value += shape.value;
+                cursor = shape.next;
+            }
+            else {
+                top.items.push(value);
+                top.remaining -= 1;
+                if (top.remaining === 0)
+                    value = top.render(top.items);
+                else {
+                    value = undefined;
+                    stack.push(top);
+                }
+            }
+        }
     }
-    return { value: value + suffixes.reverse().join(""), next };
 };
+const CALLING_CONVENTION_NAMES = new Map([
+    [0, "default"],
+    [1, "c"],
+    [2, "stdcall"],
+    [3, "thiscall"],
+    [4, "fastcall"],
+    [5, "vararg"],
+    [6, "field"],
+    [9, "unmanaged"],
+]);
 const callingConvention = (value) => {
     const base = value & 0x0f;
     const flags = [
@@ -224,28 +396,68 @@ const callingConvention = (value) => {
         (value & 0x40) === 0 ? null : "explicit-this",
         (value & 0x10) === 0 ? null : "generic",
     ].filter((flag) => flag !== null);
-    const name = base === 0
-        ? "default"
-        : base === 5
-            ? "vararg"
-            : base === 6
-                ? "field"
-                : `unknown:${String(base)}`;
+    const name = CALLING_CONVENTION_NAMES.get(base) ?? `unknown:${String(base)}`;
     return flags.length === 0 ? name : `${name} ${flags.join(" ")}`;
 };
-export const signature = (blob, rawSha256) => {
-    const raw = {
-        raw_length: blob.length,
-        raw_sha256: rawSha256 ?? sha256Bytes(blob),
-    };
+/**
+ * Decode a whole TypeSpec blob, or a MethodSpec instantiation (GENERICINST,
+ * argument count, Types), with the member-signature grammar and return the
+ * rendered types. A malformed or unsupported blob throws invalid-blob or
+ * unsupported-signature under the owning row, so coverage records it.
+ */
+export const specSignature = (layout, blob, owner) => {
+    const budget = managedDecodeBudget(layout);
+    // Rendering is transient, so charge it as member signatures are charged.
+    budget.admitTransient(blob.length * 256, owner.offset);
+    try {
+        let cursor = 0;
+        let count = 1;
+        if (owner.form === "instantiation") {
+            if (blob[0] !== 0x0a)
+                malformedSignature("MethodSpec instantiation is not GENERICINST", 0);
+            const header = readCompressed(blob, 1);
+            if (header.value === 0)
+                malformedSignature("MethodSpec instantiation has no type arguments", 1);
+            count = header.value;
+            cursor = header.next;
+        }
+        const types = [];
+        // Each Type consumes at least one byte, so a false count fails on truncation.
+        for (let index = 0; index < count; index += 1) {
+            const type = readTypeSignature(blob, cursor, "type", { layout });
+            types.push(type.value);
+            cursor = type.next;
+        }
+        if (cursor !== blob.length)
+            malformedSignature("Trailing signature data", cursor);
+        return types;
+    }
+    catch (cause) {
+        if (!(cause instanceof ManagedReaderFailure) ||
+            (cause.issue.code !== "invalid-blob" &&
+                cause.issue.code !== "invalid-row" &&
+                cause.issue.code !== "unsupported-signature"))
+            throw cause;
+        throw managedFailure(cause.issue.code, owner.scope, cause.issue.detail, owner.offset);
+    }
+    finally {
+        budget.releaseTransient();
+    }
+};
+/**
+ * Decode a field or member method signature. A malformed or unsupported blob
+ * decodes as kind `unknown` with its reason.
+ */
+const decodeSignature = (blob, operands = []) => {
     try {
         if (blob.length === 0)
             throw managedFailure("invalid-blob", "signature", "empty signature", 0);
         const first = blob[0] ?? 0;
-        if ((first & 0x0f) === 6) {
-            const fieldType = readTypeSignature(blob, 1);
+        // FieldSig (II.23.2.4) is exactly FIELD; a flagged FIELD header is not a
+        // method header either, so it is malformed below.
+        if (first === 0x06) {
+            const fieldType = readTypeSignature(blob, 1, "field", { operands });
             return {
-                ...raw,
                 kind: "field",
                 parse_status: fieldType.next === blob.length ? "decoded" : "partial",
                 calling_convention: callingConvention(first),
@@ -257,30 +469,25 @@ export const signature = (blob, rawSha256) => {
                 issue: fieldType.next === blob.length ? null : "Trailing signature data",
             };
         }
-        let offset = 1;
-        let genericParameterCount = null;
-        if ((first & 0x10) !== 0) {
-            const generic = readCompressed(blob, offset);
-            genericParameterCount = generic.value;
-            offset = generic.next;
-        }
-        const parameterCount = readCompressed(blob, offset);
-        offset = parameterCount.next;
-        const returnType = readTypeSignature(blob, offset);
-        offset = returnType.next;
+        const header = readMethodSignatureHeader(blob, 0, "member");
+        const returnType = readTypeSignature(blob, header.next, "return", {
+            operands,
+        });
+        let offset = returnType.next;
         const parameters = [];
-        for (let index = 0; index < parameterCount.value; index += 1) {
-            const parameter = readTypeSignature(blob, offset);
+        for (let index = 0; index < header.parameterCount; index += 1) {
+            const parameter = readTypeSignature(blob, offset, "parameter", {
+                operands,
+            });
             parameters.push(parameter.value);
             offset = parameter.next;
         }
         return {
-            ...raw,
             kind: "method",
             parse_status: offset === blob.length ? "decoded" : "partial",
             calling_convention: callingConvention(first),
-            generic_parameter_count: genericParameterCount,
-            parameter_count: parameterCount.value,
+            generic_parameter_count: header.genericParameterCount,
+            parameter_count: header.parameterCount,
             return_type: returnType.value,
             parameter_types: parameters,
             field_type: null,
@@ -294,7 +501,6 @@ export const signature = (blob, rawSha256) => {
             cause.issue.code !== "unsupported-signature")
             throw cause;
         return {
-            ...raw,
             kind: "unknown",
             parse_status: cause.issue.code === "unsupported-signature"
                 ? "unsupported"
@@ -309,3 +515,64 @@ export const signature = (blob, rawSha256) => {
         };
     }
 };
+/**
+ * Generic parameter count of a method signature that decodes completely, 0
+ * when it is not generic, or null when the blob is not a decodable method
+ * signature. The rendered decode is transient.
+ */
+export const methodGenericArity = (layout, blob) => {
+    const budget = managedDecodeBudget(layout);
+    budget.admitTransient(blob.length * 256, layout.blob.offset);
+    try {
+        return signatureGenericArity(decodeSignature(blob));
+    }
+    finally {
+        budget.releaseTransient();
+    }
+};
+/**
+ * Generic parameter count of a completely decoded method signature, 0 when it
+ * is not generic, or null for any other signature.
+ */
+export const signatureGenericArity = (decoded) => decoded.kind === "method" && decoded.parse_status === "decoded"
+    ? (decoded.generic_parameter_count ?? 0)
+    : null;
+/**
+ * Each type operand is replaced by 0xff, which never starts a compressed
+ * coded index, then the 32-byte name digest; a blob without type operands
+ * keeps its raw digest. So no decodable signature's resolved preimage is
+ * another's, but an undecodable blob can hold one, and its raw digest then
+ * equals that resolved digest. Comparison keys the two kinds apart.
+ */
+const OPERAND_MARKER = Buffer.from([0xff]);
+/**
+ * Digest the blob with each type operand replaced by its type's name digest,
+ * so the value does not depend on build-local row numbers.
+ */
+const 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");
+};
+export const 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,
+    };
+};