reverseport 0.0.0-stage → 1.2.0

package/dist/dotnet/ManagedMemberInstructionDecoder.js

@@ -0,0 +1,468 @@
+import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
+const PREFIX_OPCODES = new Set([
+    "unaligned.",
+    "volatile.",
+    "tail.",
+    "constrained.",
+    "readonly.",
+]);
+const OPCODES = new Map([
+    [0x00, { name: "nop", operand: "none" }],
+    [0x01, { name: "break", operand: "none" }],
+    [0x02, { name: "ldarg.0", operand: "none" }],
+    [0x03, { name: "ldarg.1", operand: "none" }],
+    [0x04, { name: "ldarg.2", operand: "none" }],
+    [0x05, { name: "ldarg.3", operand: "none" }],
+    [0x06, { name: "ldloc.0", operand: "none" }],
+    [0x07, { name: "ldloc.1", operand: "none" }],
+    [0x08, { name: "ldloc.2", operand: "none" }],
+    [0x09, { name: "ldloc.3", operand: "none" }],
+    [0x0a, { name: "stloc.0", operand: "none" }],
+    [0x0b, { name: "stloc.1", operand: "none" }],
+    [0x0c, { name: "stloc.2", operand: "none" }],
+    [0x0d, { name: "stloc.3", operand: "none" }],
+    [0x0e, { name: "ldarg.s", operand: "short-var" }],
+    [0x0f, { name: "ldarga.s", operand: "short-var" }],
+    [0x10, { name: "starg.s", operand: "short-var" }],
+    [0x11, { name: "ldloc.s", operand: "short-var" }],
+    [0x12, { name: "ldloca.s", operand: "short-var" }],
+    [0x13, { name: "stloc.s", operand: "short-var" }],
+    [0x14, { name: "ldnull", operand: "none" }],
+    [0x15, { name: "ldc.i4.m1", operand: "none" }],
+    [0x16, { name: "ldc.i4.0", operand: "none" }],
+    [0x17, { name: "ldc.i4.1", operand: "none" }],
+    [0x18, { name: "ldc.i4.2", operand: "none" }],
+    [0x19, { name: "ldc.i4.3", operand: "none" }],
+    [0x1a, { name: "ldc.i4.4", operand: "none" }],
+    [0x1b, { name: "ldc.i4.5", operand: "none" }],
+    [0x1c, { name: "ldc.i4.6", operand: "none" }],
+    [0x1d, { name: "ldc.i4.7", operand: "none" }],
+    [0x1e, { name: "ldc.i4.8", operand: "none" }],
+    [0x1f, { name: "ldc.i4.s", operand: "short-i" }],
+    [0x20, { name: "ldc.i4", operand: "i" }],
+    [0x21, { name: "ldc.i8", operand: "i8" }],
+    [0x22, { name: "ldc.r4", operand: "r4" }],
+    [0x23, { name: "ldc.r8", operand: "r8" }],
+    [0x25, { name: "dup", operand: "none" }],
+    [0x26, { name: "pop", operand: "none" }],
+    [0x27, { name: "jmp", operand: "method" }],
+    [0x28, { name: "call", operand: "method" }],
+    [0x29, { name: "calli", operand: "signature" }],
+    [0x2a, { name: "ret", operand: "none" }],
+    [0x2b, { name: "br.s", operand: "short-branch" }],
+    [0x2c, { name: "brfalse.s", operand: "short-branch" }],
+    [0x2d, { name: "brtrue.s", operand: "short-branch" }],
+    [0x2e, { name: "beq.s", operand: "short-branch" }],
+    [0x2f, { name: "bge.s", operand: "short-branch" }],
+    [0x30, { name: "bgt.s", operand: "short-branch" }],
+    [0x31, { name: "ble.s", operand: "short-branch" }],
+    [0x32, { name: "blt.s", operand: "short-branch" }],
+    [0x33, { name: "bne.un.s", operand: "short-branch" }],
+    [0x34, { name: "bge.un.s", operand: "short-branch" }],
+    [0x35, { name: "bgt.un.s", operand: "short-branch" }],
+    [0x36, { name: "ble.un.s", operand: "short-branch" }],
+    [0x37, { name: "blt.un.s", operand: "short-branch" }],
+    [0x38, { name: "br", operand: "branch" }],
+    [0x39, { name: "brfalse", operand: "branch" }],
+    [0x3a, { name: "brtrue", operand: "branch" }],
+    [0x3b, { name: "beq", operand: "branch" }],
+    [0x3c, { name: "bge", operand: "branch" }],
+    [0x3d, { name: "bgt", operand: "branch" }],
+    [0x3e, { name: "ble", operand: "branch" }],
+    [0x3f, { name: "blt", operand: "branch" }],
+    [0x40, { name: "bne.un", operand: "branch" }],
+    [0x41, { name: "bge.un", operand: "branch" }],
+    [0x42, { name: "bgt.un", operand: "branch" }],
+    [0x43, { name: "ble.un", operand: "branch" }],
+    [0x44, { name: "blt.un", operand: "branch" }],
+    [0x45, { name: "switch", operand: "switch" }],
+    [0x46, { name: "ldind.i1", operand: "none" }],
+    [0x47, { name: "ldind.u1", operand: "none" }],
+    [0x48, { name: "ldind.i2", operand: "none" }],
+    [0x49, { name: "ldind.u2", operand: "none" }],
+    [0x4a, { name: "ldind.i4", operand: "none" }],
+    [0x4b, { name: "ldind.u4", operand: "none" }],
+    [0x4c, { name: "ldind.i8", operand: "none" }],
+    [0x4d, { name: "ldind.i", operand: "none" }],
+    [0x4e, { name: "ldind.r4", operand: "none" }],
+    [0x4f, { name: "ldind.r8", operand: "none" }],
+    [0x50, { name: "ldind.ref", operand: "none" }],
+    [0x51, { name: "stind.ref", operand: "none" }],
+    [0x52, { name: "stind.i1", operand: "none" }],
+    [0x53, { name: "stind.i2", operand: "none" }],
+    [0x54, { name: "stind.i4", operand: "none" }],
+    [0x55, { name: "stind.i8", operand: "none" }],
+    [0x56, { name: "stind.r4", operand: "none" }],
+    [0x57, { name: "stind.r8", operand: "none" }],
+    [0x58, { name: "add", operand: "none" }],
+    [0x59, { name: "sub", operand: "none" }],
+    [0x5a, { name: "mul", operand: "none" }],
+    [0x5b, { name: "div", operand: "none" }],
+    [0x5c, { name: "div.un", operand: "none" }],
+    [0x5d, { name: "rem", operand: "none" }],
+    [0x5e, { name: "rem.un", operand: "none" }],
+    [0x5f, { name: "and", operand: "none" }],
+    [0x60, { name: "or", operand: "none" }],
+    [0x61, { name: "xor", operand: "none" }],
+    [0x62, { name: "shl", operand: "none" }],
+    [0x63, { name: "shr", operand: "none" }],
+    [0x64, { name: "shr.un", operand: "none" }],
+    [0x65, { name: "neg", operand: "none" }],
+    [0x66, { name: "not", operand: "none" }],
+    [0x67, { name: "conv.i1", operand: "none" }],
+    [0x68, { name: "conv.i2", operand: "none" }],
+    [0x69, { name: "conv.i4", operand: "none" }],
+    [0x6a, { name: "conv.i8", operand: "none" }],
+    [0x6b, { name: "conv.r4", operand: "none" }],
+    [0x6c, { name: "conv.r8", operand: "none" }],
+    [0x6d, { name: "conv.u4", operand: "none" }],
+    [0x6e, { name: "conv.u8", operand: "none" }],
+    [0x6f, { name: "callvirt", operand: "method" }],
+    [0x70, { name: "cpobj", operand: "type" }],
+    [0x71, { name: "ldobj", operand: "type" }],
+    [0x72, { name: "ldstr", operand: "string" }],
+    [0x73, { name: "newobj", operand: "method" }],
+    [0x74, { name: "castclass", operand: "type" }],
+    [0x75, { name: "isinst", operand: "type" }],
+    [0x76, { name: "conv.r.un", operand: "none" }],
+    [0x79, { name: "unbox", operand: "type" }],
+    [0x7a, { name: "throw", operand: "none" }],
+    [0x7b, { name: "ldfld", operand: "field" }],
+    [0x7c, { name: "ldflda", operand: "field" }],
+    [0x7d, { name: "stfld", operand: "field" }],
+    [0x7e, { name: "ldsfld", operand: "field" }],
+    [0x7f, { name: "ldsflda", operand: "field" }],
+    [0x80, { name: "stsfld", operand: "field" }],
+    [0x81, { name: "stobj", operand: "type" }],
+    [0x82, { name: "conv.ovf.i1.un", operand: "none" }],
+    [0x83, { name: "conv.ovf.i2.un", operand: "none" }],
+    [0x84, { name: "conv.ovf.i4.un", operand: "none" }],
+    [0x85, { name: "conv.ovf.i8.un", operand: "none" }],
+    [0x86, { name: "conv.ovf.u1.un", operand: "none" }],
+    [0x87, { name: "conv.ovf.u2.un", operand: "none" }],
+    [0x88, { name: "conv.ovf.u4.un", operand: "none" }],
+    [0x89, { name: "conv.ovf.u8.un", operand: "none" }],
+    [0x8a, { name: "conv.ovf.i.un", operand: "none" }],
+    [0x8b, { name: "conv.ovf.u.un", operand: "none" }],
+    [0x8c, { name: "box", operand: "type" }],
+    [0x8d, { name: "newarr", operand: "type" }],
+    [0x8e, { name: "ldlen", operand: "none" }],
+    [0x8f, { name: "ldelema", operand: "type" }],
+    [0x90, { name: "ldelem.i1", operand: "none" }],
+    [0x91, { name: "ldelem.u1", operand: "none" }],
+    [0x92, { name: "ldelem.i2", operand: "none" }],
+    [0x93, { name: "ldelem.u2", operand: "none" }],
+    [0x94, { name: "ldelem.i4", operand: "none" }],
+    [0x95, { name: "ldelem.u4", operand: "none" }],
+    [0x96, { name: "ldelem.i8", operand: "none" }],
+    [0x97, { name: "ldelem.i", operand: "none" }],
+    [0x98, { name: "ldelem.r4", operand: "none" }],
+    [0x99, { name: "ldelem.r8", operand: "none" }],
+    [0x9a, { name: "ldelem.ref", operand: "none" }],
+    [0x9b, { name: "stelem.i", operand: "none" }],
+    [0x9c, { name: "stelem.i1", operand: "none" }],
+    [0x9d, { name: "stelem.i2", operand: "none" }],
+    [0x9e, { name: "stelem.i4", operand: "none" }],
+    [0x9f, { name: "stelem.i8", operand: "none" }],
+    [0xa0, { name: "stelem.r4", operand: "none" }],
+    [0xa1, { name: "stelem.r8", operand: "none" }],
+    [0xa2, { name: "stelem.ref", operand: "none" }],
+    [0xa3, { name: "ldelem", operand: "type" }],
+    [0xa4, { name: "stelem", operand: "type" }],
+    [0xa5, { name: "unbox.any", operand: "type" }],
+    [0xb3, { name: "conv.ovf.i1", operand: "none" }],
+    [0xb4, { name: "conv.ovf.u1", operand: "none" }],
+    [0xb5, { name: "conv.ovf.i2", operand: "none" }],
+    [0xb6, { name: "conv.ovf.u2", operand: "none" }],
+    [0xb7, { name: "conv.ovf.i4", operand: "none" }],
+    [0xb8, { name: "conv.ovf.u4", operand: "none" }],
+    [0xb9, { name: "conv.ovf.i8", operand: "none" }],
+    [0xba, { name: "conv.ovf.u8", operand: "none" }],
+    [0xc2, { name: "refanyval", operand: "type" }],
+    [0xc3, { name: "ckfinite", operand: "none" }],
+    [0xc6, { name: "mkrefany", operand: "type" }],
+    [0xd0, { name: "ldtoken", operand: "token" }],
+    [0xd1, { name: "conv.u2", operand: "none" }],
+    [0xd2, { name: "conv.u1", operand: "none" }],
+    [0xd3, { name: "conv.i", operand: "none" }],
+    [0xd4, { name: "conv.ovf.i", operand: "none" }],
+    [0xd5, { name: "conv.ovf.u", operand: "none" }],
+    [0xd6, { name: "add.ovf", operand: "none" }],
+    [0xd7, { name: "add.ovf.un", operand: "none" }],
+    [0xd8, { name: "mul.ovf", operand: "none" }],
+    [0xd9, { name: "mul.ovf.un", operand: "none" }],
+    [0xda, { name: "sub.ovf", operand: "none" }],
+    [0xdb, { name: "sub.ovf.un", operand: "none" }],
+    [0xdc, { name: "endfinally", operand: "none" }],
+    [0xdd, { name: "leave", operand: "branch" }],
+    [0xde, { name: "leave.s", operand: "short-branch" }],
+    [0xdf, { name: "stind.i", operand: "none" }],
+    [0xe0, { name: "conv.u", operand: "none" }],
+    [0xfe00, { name: "arglist", operand: "none" }],
+    [0xfe01, { name: "ceq", operand: "none" }],
+    [0xfe02, { name: "cgt", operand: "none" }],
+    [0xfe03, { name: "cgt.un", operand: "none" }],
+    [0xfe04, { name: "clt", operand: "none" }],
+    [0xfe05, { name: "clt.un", operand: "none" }],
+    [0xfe06, { name: "ldftn", operand: "method" }],
+    [0xfe07, { name: "ldvirtftn", operand: "method" }],
+    [0xfe09, { name: "ldarg", operand: "var" }],
+    [0xfe0a, { name: "ldarga", operand: "var" }],
+    [0xfe0b, { name: "starg", operand: "var" }],
+    [0xfe0c, { name: "ldloc", operand: "var" }],
+    [0xfe0d, { name: "ldloca", operand: "var" }],
+    [0xfe0e, { name: "stloc", operand: "var" }],
+    [0xfe0f, { name: "localloc", operand: "none" }],
+    [0xfe11, { name: "endfilter", operand: "none" }],
+    [0xfe12, { name: "unaligned.", operand: "short-i" }],
+    [0xfe13, { name: "volatile.", operand: "none" }],
+    [0xfe14, { name: "tail.", operand: "none" }],
+    [0xfe15, { name: "initobj", operand: "type" }],
+    [0xfe16, { name: "constrained.", operand: "type" }],
+    [0xfe17, { name: "cpblk", operand: "none" }],
+    [0xfe18, { name: "initblk", operand: "none" }],
+    [0xfe1a, { name: "rethrow", operand: "none" }],
+    [0xfe1c, { name: "sizeof", operand: "type" }],
+    [0xfe1d, { name: "refanytype", operand: "none" }],
+    [0xfe1e, { name: "readonly.", operand: "none" }],
+]);
+const tokenKind = (token) => {
+    if (token.startsWith("0x06") ||
+        token.startsWith("0x0a") ||
+        token.startsWith("0x2b"))
+        return "method";
+    if (token.startsWith("0x04"))
+        return "field";
+    if (token.startsWith("0x70"))
+        return "string";
+    if (token.startsWith("0x11"))
+        return "signature";
+    if (token.startsWith("0x01") ||
+        token.startsWith("0x02") ||
+        token.startsWith("0x1b"))
+        return "type";
+    return "token";
+};
+const FIXED_OPERAND_READERS = new Map([
+    [
+        "none",
+        (_il, offset) => ({ next: offset, anchorKind: "none", value: null }),
+    ],
+    [
+        "short-var",
+        (il, offset) => ({
+            next: offset + 1,
+            anchorKind: "variable",
+            value: String(il.readUInt8(offset)),
+        }),
+    ],
+    [
+        "var",
+        (il, offset) => ({
+            next: offset + 2,
+            anchorKind: "variable",
+            value: String(il.readUInt16LE(offset)),
+        }),
+    ],
+    [
+        "short-i",
+        (il, offset) => ({
+            next: offset + 1,
+            anchorKind: "constant",
+            value: String(il.readInt8(offset)),
+        }),
+    ],
+    [
+        "i",
+        (il, offset) => ({
+            next: offset + 4,
+            anchorKind: "constant",
+            value: String(il.readInt32LE(offset)),
+        }),
+    ],
+    [
+        "i8",
+        (il, offset) => ({
+            next: offset + 8,
+            anchorKind: "constant",
+            value: il.readBigInt64LE(offset).toString(),
+        }),
+    ],
+    [
+        "r4",
+        (il, offset) => ({
+            next: offset + 4,
+            anchorKind: "constant",
+            value: String(il.readFloatLE(offset)),
+        }),
+    ],
+    [
+        "r8",
+        (il, offset) => ({
+            next: offset + 8,
+            anchorKind: "constant",
+            value: String(il.readDoubleLE(offset)),
+        }),
+    ],
+    [
+        "short-branch",
+        (il, offset) => ({
+            next: offset + 1,
+            anchorKind: "branch",
+            value: String(offset + 1 + il.readInt8(offset)),
+        }),
+    ],
+    [
+        "branch",
+        (il, offset) => ({
+            next: offset + 4,
+            anchorKind: "branch",
+            value: String(offset + 4 + il.readInt32LE(offset)),
+        }),
+    ],
+]);
+const TOKEN_OPERAND_KINDS = new Map([
+    ["method", "method"],
+    ["field", "field"],
+    ["type", "type"],
+    ["string", "string"],
+    ["signature", "signature"],
+]);
+const readOperand = (il, offset, kind) => {
+    const fixed = FIXED_OPERAND_READERS.get(kind);
+    if (fixed !== undefined)
+        return fixed(il, offset);
+    if (kind === "switch") {
+        const count = il.readUInt32LE(offset);
+        return {
+            next: offset + 4 + count * 4,
+            anchorKind: "switch",
+            value: String(count),
+        };
+    }
+    const raw = il.readUInt32LE(offset);
+    const token = `0x${raw.toString(16).padStart(8, "0")}`;
+    const tokenOperandKind = TOKEN_OPERAND_KINDS.get(kind);
+    if (tokenOperandKind !== undefined)
+        return { next: offset + 4, anchorKind: tokenOperandKind, value: token };
+    if (kind === "token")
+        return { next: offset + 4, anchorKind: tokenKind(token), value: token };
+    return { next: offset, anchorKind: "unknown", value: null };
+};
+export const decodeInstructions = (il, admitInstruction) => {
+    const parsed = [];
+    const instructionStarts = [];
+    let offset = 0;
+    let prefixStart = null;
+    let issue = null;
+    try {
+        while (offset < il.length) {
+            const start = offset;
+            const first = il.readUInt8(offset);
+            offset += 1;
+            const code = first === 0xfe ? 0xfe00 + il.readUInt8(offset++) : first;
+            const descriptor = OPCODES.get(code);
+            if (descriptor === undefined) {
+                issue = `Unsupported CIL opcode 0x${code.toString(16)} at IL offset ${String(start)}`;
+                break;
+            }
+            const operand = readOperand(il, offset, descriptor.operand);
+            if (operand.next < offset || operand.next > il.length) {
+                issue = `Instruction ${descriptor.name} at IL offset ${String(start)} leaves method body`;
+                break;
+            }
+            // Charge each actual instruction before growing the decoded arrays.
+            // A multi-byte operand must not consume a full record per raw IL byte.
+            admitInstruction?.(start);
+            offset = operand.next;
+            if (PREFIX_OPCODES.has(descriptor.name)) {
+                prefixStart ??= start;
+            }
+            else {
+                instructionStarts.push(prefixStart ?? start);
+                prefixStart = null;
+            }
+            parsed.push({
+                offset: start,
+                opcode: descriptor.name,
+                operandKind: operand.anchorKind,
+                operand: operand.value,
+            });
+        }
+    }
+    catch (cause) {
+        if (cause instanceof ManagedReaderFailure)
+            throw cause;
+        issue =
+            cause instanceof Error ? cause.message : "Instruction decode failed";
+    }
+    const truncated = offset < il.length && issue === null ? 1 : 0;
+    return { parsed, instructionStarts, count: parsed.length, truncated, issue };
+};
+export const parseExceptionRegions = (bytes, offset, methodEnd, budget) => {
+    const regions = [];
+    let sectionOffset = offset;
+    let hasMoreSections = true;
+    while (hasMoreSections) {
+        if (!Number.isSafeInteger(sectionOffset) ||
+            sectionOffset < 0 ||
+            sectionOffset > methodEnd - 4 ||
+            sectionOffset > bytes.length - 4)
+            return malformedExceptionRegions("Exception section header leaves artifact", regions);
+        const kind = bytes.readUInt8(sectionOffset);
+        if ((kind & 0x3f) !== 1)
+            return malformedExceptionRegions(`Unsupported method data section kind ${String(kind & 0x3f)}`, regions);
+        const fat = (kind & 0x40) !== 0;
+        const size = fat
+            ? bytes.readUInt8(sectionOffset + 1) |
+                (bytes.readUInt8(sectionOffset + 2) << 8) |
+                (bytes.readUInt8(sectionOffset + 3) << 16)
+            : bytes.readUInt8(sectionOffset + 1);
+        const clauseSize = fat ? 24 : 12;
+        if (size < 4 ||
+            sectionOffset > methodEnd - size ||
+            sectionOffset > bytes.length - size)
+            return malformedExceptionRegions("Exception section size leaves artifact", regions);
+        if ((size - 4) % clauseSize !== 0)
+            return malformedExceptionRegions("Exception section size does not contain whole clauses", regions);
+        if (!fat &&
+            (bytes[sectionOffset + 2] !== 0 || bytes[sectionOffset + 3] !== 0))
+            return malformedExceptionRegions("Small exception section reserved bytes are nonzero", regions);
+        const count = (size - 4) / clauseSize;
+        // Accumulates with the method IL bound; the body reserves what it retains.
+        budget?.admitTransient(count * 256, sectionOffset);
+        for (const region of readExceptionClauses(bytes, sectionOffset + 4, count, fat))
+            regions.push(region);
+        hasMoreSections = (kind & 0x80) !== 0;
+        sectionOffset += size;
+    }
+    return { status: "complete", regions };
+};
+const malformedExceptionRegions = (issue, regions = []) => ({ status: "malformed", regions, issue });
+const readExceptionClauses = (bytes, start, count, fat) => {
+    const regions = [];
+    const clauseSize = fat ? 24 : 12;
+    for (let index = 0; index < count; index += 1) {
+        const clause = start + index * clauseSize;
+        const flags = fat ? bytes.readUInt32LE(clause) : bytes.readUInt16LE(clause);
+        const extra = bytes.readUInt32LE(clause + (fat ? 20 : 8));
+        regions.push({
+            flags,
+            try_offset: fat
+                ? bytes.readUInt32LE(clause + 4)
+                : bytes.readUInt16LE(clause + 2),
+            try_length: fat
+                ? bytes.readUInt32LE(clause + 8)
+                : bytes.readUInt8(clause + 4),
+            handler_offset: fat
+                ? bytes.readUInt32LE(clause + 12)
+                : bytes.readUInt16LE(clause + 5),
+            handler_length: fat
+                ? bytes.readUInt32LE(clause + 16)
+                : bytes.readUInt8(clause + 7),
+            class_token: flags === 0 ? `0x${extra.toString(16).padStart(8, "0")}` : null,
+            filter_offset: flags === 1 ? extra : null,
+        });
+    }
+    return regions;
+};

package/dist/dotnet/ManagedMemberOwnership.js

@@ -0,0 +1,71 @@
+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";
+import { metadataRowCursor } from "./ManagedMetadataHeaps.js";
+import { memberListIndexSize, memberListRowLookup, memberListTable, } from "./ManagedMemberPointers.js";
+import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
+const lookups = new WeakMap();
+/** One first-match TypeDef owner per physical member, shared by every inspection facet. */
+export const memberDeclaringTypeRowLookup = (bytes, layout, table) => {
+    let byTable = lookups.get(layout);
+    const cached = byTable?.get(table);
+    if (cached instanceof ManagedReaderFailure)
+        throw cached;
+    if (cached !== undefined)
+        return cached;
+    if (byTable === undefined) {
+        byTable = new Map();
+        lookups.set(layout, byTable);
+    }
+    try {
+        const positionOf = memberListRowLookup(bytes, layout, table);
+        const positions = memberListTable(layout, table)?.rowCount ?? 0;
+        const types = layout.table(2)?.rowCount ?? 0;
+        managedDecodeBudget(layout).reserve((2 * positions + 3) * Uint32Array.BYTES_PER_ELEMENT + 256, layout.table(2)?.offset ?? null);
+        const owners = new Uint32Array(positions + 1);
+        // Skip already-owned positions so overlapping malformed lists remain near-linear.
+        const next = Uint32Array.from({ length: positions + 2 }, (_, p) => p);
+        const unowned = (position) => {
+            let root = position;
+            while (next[root] !== root)
+                root = next[root] ?? root;
+            for (let p = position; p !== root;) {
+                const following = next[p] ?? root;
+                next[p] = root;
+                p = following;
+            }
+            return root;
+        };
+        const startForType = (row) => {
+            const cursor = metadataRowCursor(bytes, layout, 2, row);
+            cursor.readUInt32();
+            cursor.readIndex(layout.stringIndexSize);
+            cursor.readIndex(layout.stringIndexSize);
+            cursor.readIndex(layout.codedIndexSize("TypeDefOrRef"));
+            const fieldStart = cursor.readIndex(memberListIndexSize(layout, 4));
+            return table === 4
+                ? fieldStart
+                : cursor.readIndex(memberListIndexSize(layout, 6));
+        };
+        let start = types === 0 ? 0 : startForType(1);
+        for (let row = 1; row <= types; row += 1) {
+            const end = row === types ? positions + 1 : startForType(row + 1);
+            const limit = Math.min(end, positions + 1);
+            for (let p = unowned(Math.min(Math.max(start, 1), positions + 1)); p < limit; p = unowned(p + 1)) {
+                owners[p] = row;
+                next[p] = p + 1;
+            }
+            start = end;
+        }
+        const definitions = layout.table(table)?.rowCount ?? 0;
+        const lookup = (definition) => definition < 1 || definition > definitions
+            ? 0
+            : (owners[positionOf(definition)] ?? 0);
+        byTable.set(table, lookup);
+        return lookup;
+    }
+    catch (cause) {
+        // Replaying a malformed layout must neither rebuild nor charge the index again.
+        if (cause instanceof ManagedReaderFailure)
+            byTable.set(table, cause);
+        throw cause;
+    }
+};

package/dist/dotnet/ManagedMemberPointers.js

@@ -0,0 +1,62 @@
+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";
+import { managedFailure, ManagedReaderFailure, } from "./ManagedReaderFailure.js";
+const lookups = new WeakMap();
+/** TypeDef list coordinates refer to the nonempty pointer table when present. */
+export const memberListTable = (layout, table) => {
+    const pointers = layout.table(table - 1);
+    return pointers !== undefined && pointers.rowCount > 0
+        ? pointers
+        : layout.table(table);
+};
+/** List columns must accommodate either physical definition or pointer rows. */
+export const memberListIndexSize = (layout, table) => layout.tableIndexSize(table - 1) === 4 || layout.tableIndexSize(table) === 4
+    ? 4
+    : 2;
+/** Resolve physical definition rows to list positions without changing token identity. */
+export const memberListRowLookup = (bytes, layout, table) => {
+    const pointers = layout.table(table - 1);
+    if (pointers === undefined || pointers.rowCount === 0)
+        return (row) => row;
+    let byTable = lookups.get(layout);
+    const cached = byTable?.get(table);
+    if (cached instanceof ManagedReaderFailure)
+        throw cached;
+    if (cached !== undefined)
+        return cached;
+    const definitionCount = layout.table(table)?.rowCount ?? 0;
+    // The layout already admitted the source table extent. Reserve retained index
+    // storage and its fixed bookkeeping before allocating either container.
+    managedDecodeBudget(layout).reserve((definitionCount + 1) * Uint32Array.BYTES_PER_ELEMENT + 256, pointers.offset);
+    if (byTable === undefined) {
+        byTable = new Map();
+        lookups.set(layout, byTable);
+    }
+    const positions = new Uint32Array(definitionCount + 1);
+    try {
+        const width = layout.tableIndexSize(table);
+        for (let row = 1; row <= pointers.rowCount; row += 1) {
+            const offset = pointers.offset + (row - 1) * pointers.rowSize;
+            const definition = width === 2 ? bytes.readUInt16LE(offset) : bytes.readUInt32LE(offset);
+            if (definition === 0 || definition > definitionCount)
+                throw managedFailure("invalid-row", `metadata.${pointers.name}`, `Pointer row ${String(row)} names an out-of-range definition row ${String(definition)}`, offset);
+            if (positions[definition] !== 0)
+                throw managedFailure("invalid-row", `metadata.${pointers.name}`, `Definition row ${String(definition)} has more than one pointer row; its declaring type is ambiguous`, offset);
+            positions[definition] = row;
+        }
+        const lookup = (definition) => {
+            const position = positions[definition] ?? 0;
+            if (position === 0)
+                throw managedFailure("invalid-row", `metadata.${pointers.name}`, `Definition row ${String(definition)} has no pointer row identifying its declaring type`, pointers.offset);
+            return position;
+        };
+        byTable.set(table, lookup);
+        return lookup;
+    }
+    catch (cause) {
+        // Invalid metadata must not rebuild and charge the same retained index for
+        // every attribute/member that asks for its owner.
+        if (cause instanceof ManagedReaderFailure)
+            byTable.set(table, cause);
+        throw cause;
+    }
+};