rea-agents 6.4.0 → 6.5.0

package/dist/dotnet/ManagedMemberInstructionDecoder.js

@@ -1,9 +1,11 @@
+import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
 const PREFIX_OPCODES = new Set([
     "unaligned.",
     "volatile.",
     "tail.",
     "constrained.",
     "readonly.",
+    "no.",
 ]);
 const OPCODES = new Map([
     [0x00, { name: "nop", operand: "none" }],
@@ -220,6 +222,7 @@ const OPCODES = new Map([
     [0xfe16, { name: "constrained.", operand: "type" }],
     [0xfe17, { name: "cpblk", operand: "none" }],
     [0xfe18, { name: "initblk", operand: "none" }],
+    [0xfe19, { name: "no.", operand: "short-i" }],
     [0xfe1a, { name: "rethrow", operand: "none" }],
     [0xfe1c, { name: "sizeof", operand: "type" }],
     [0xfe1d, { name: "refanytype", operand: "none" }],
@@ -242,82 +245,92 @@ const tokenKind = (token) => {
         return "type";
     return "token";
 };
+// String(-0) loses a CIL constant's sign in both anchors and normalized hashes.
+const floatingPointOperand = (value) => Object.is(value, -0) ? "-0" : String(value);
+const fixed = (width, read) => ({
+    width,
+    read,
+});
 const FIXED_OPERAND_READERS = new Map([
     [
         "none",
-        (_il, offset) => ({ next: offset, anchorKind: "none", value: null }),
+        fixed(0, (_il, offset) => ({
+            next: offset,
+            anchorKind: "none",
+            value: null,
+        })),
     ],
     [
         "short-var",
-        (il, offset) => ({
+        fixed(1, (il, offset) => ({
             next: offset + 1,
             anchorKind: "variable",
             value: String(il.readUInt8(offset)),
-        }),
+        })),
     ],
     [
         "var",
-        (il, offset) => ({
+        fixed(2, (il, offset) => ({
             next: offset + 2,
             anchorKind: "variable",
             value: String(il.readUInt16LE(offset)),
-        }),
+        })),
     ],
     [
         "short-i",
-        (il, offset) => ({
+        fixed(1, (il, offset) => ({
             next: offset + 1,
             anchorKind: "constant",
             value: String(il.readInt8(offset)),
-        }),
+        })),
     ],
     [
         "i",
-        (il, offset) => ({
+        fixed(4, (il, offset) => ({
             next: offset + 4,
             anchorKind: "constant",
             value: String(il.readInt32LE(offset)),
-        }),
+        })),
     ],
     [
         "i8",
-        (il, offset) => ({
+        fixed(8, (il, offset) => ({
             next: offset + 8,
             anchorKind: "constant",
             value: il.readBigInt64LE(offset).toString(),
-        }),
+        })),
     ],
     [
         "r4",
-        (il, offset) => ({
+        fixed(4, (il, offset) => ({
             next: offset + 4,
             anchorKind: "constant",
-            value: String(il.readFloatLE(offset)),
-        }),
+            value: floatingPointOperand(il.readFloatLE(offset)),
+        })),
     ],
     [
         "r8",
-        (il, offset) => ({
+        fixed(8, (il, offset) => ({
             next: offset + 8,
             anchorKind: "constant",
-            value: String(il.readDoubleLE(offset)),
-        }),
+            value: floatingPointOperand(il.readDoubleLE(offset)),
+        })),
     ],
     [
         "short-branch",
-        (il, offset) => ({
+        fixed(1, (il, offset) => ({
             next: offset + 1,
             anchorKind: "branch",
             value: String(offset + 1 + il.readInt8(offset)),
-        }),
+        })),
     ],
     [
         "branch",
-        (il, offset) => ({
+        fixed(4, (il, offset) => ({
             next: offset + 4,
             anchorKind: "branch",
             value: String(offset + 4 + il.readInt32LE(offset)),
-        }),
+        })),
     ],
 ]);
 const TOKEN_OPERAND_KINDS = new Map([
@@ -327,10 +340,35 @@ const TOKEN_OPERAND_KINDS = new Map([
     ["string", "string"],
     ["signature", "signature"],
 ]);
+/** Every token operand is a 4-byte metadata token. */
+const TOKEN_OPERAND_WIDTH = 4;
+/**
+ * Bytes the operand at `offset` occupies, or `null` when the extent itself
+ * cannot be read from `il`. This is the single extent authority: `readOperand`
+ * must never be called for an operand whose extent it cannot bound, so no
+ * operand read can leave the method body.
+ */
+const operandExtent = (il, offset, kind) => {
+    const fixedOperand = FIXED_OPERAND_READERS.get(kind);
+    if (fixedOperand !== undefined)
+        return fixedOperand.width;
+    if (kind === "switch") {
+        if (offset > il.length - 4)
+            return null;
+        return 4 + il.readUInt32LE(offset) * 4;
+    }
+    return TOKEN_OPERAND_KINDS.has(kind) || kind === "token"
+        ? TOKEN_OPERAND_WIDTH
+        : 0;
+};
+/**
+ * Read an operand whose extent is already known to fit. `next` is always
+ * `offset + operandExtent(il, offset, kind)`; callers bound the read first.
+ */
 const readOperand = (il, offset, kind) => {
-    const fixed = FIXED_OPERAND_READERS.get(kind);
-    if (fixed !== undefined)
-        return fixed(il, offset);
+    const fixedOperand = FIXED_OPERAND_READERS.get(kind);
+    if (fixedOperand !== undefined)
+        return fixedOperand.read(il, offset);
     if (kind === "switch") {
         const count = il.readUInt32LE(offset);
         return {
@@ -339,16 +377,17 @@ const readOperand = (il, offset, kind) => {
             value: String(count),
         };
     }
+    if (!TOKEN_OPERAND_KINDS.has(kind) && kind !== "token")
+        return { next: offset, anchorKind: "unknown", value: null };
     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 };
+    return {
+        next: offset + TOKEN_OPERAND_WIDTH,
+        anchorKind: TOKEN_OPERAND_KINDS.get(kind) ?? tokenKind(token),
+        value: token,
+    };
 };
-export const decodeInstructions = (il) => {
+export const decodeInstructions = (il, admitInstruction) => {
     const parsed = [];
     const instructionStarts = [];
     let offset = 0;
@@ -359,17 +398,28 @@ export const decodeInstructions = (il) => {
             const start = offset;
             const first = il.readUInt8(offset);
             offset += 1;
+            if (first === 0xfe && offset >= il.length) {
+                issue = `Two-byte CIL opcode at IL offset ${String(start)} leaves method body`;
+                break;
+            }
             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) {
+            // Bound the operand extent before reading its value. Reading first would
+            // throw a raw Buffer RangeError out of a truncated body and replace this
+            // diagnostic with the runtime message, losing the instruction identity.
+            const extent = operandExtent(il, offset, descriptor.operand);
+            if (extent === null || offset + extent > il.length) {
                 issue = `Instruction ${descriptor.name} at IL offset ${String(start)} leaves method body`;
                 break;
             }
+            const operand = readOperand(il, offset, descriptor.operand);
+            // 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;
@@ -387,6 +437,8 @@ export const decodeInstructions = (il) => {
         }
     }
     catch (cause) {
+        if (cause instanceof ManagedReaderFailure)
+            throw cause;
         issue =
             cause instanceof Error ? cause.message : "Instruction decode failed";
     }
@@ -417,17 +469,37 @@ export const parseExceptionRegions = (bytes, offset, methodEnd, budget) => {
             sectionOffset > methodEnd - size ||
             sectionOffset > bytes.length - size)
             return malformedExceptionRegions("Exception section size leaves artifact", regions);
-        if ((size - 4) % clauseSize !== 0)
+        let count;
+        let sectionSize = size;
+        if (fat) {
+            if ((size - 4) % clauseSize !== 0)
+                return malformedExceptionRegions("Exception section size does not contain whole clauses", regions);
+            count = (size - 4) / clauseSize;
+        }
+        else if ((size - 4) % clauseSize === 0) {
+            count = (size - 4) / clauseSize;
+        }
+        else if (size >= clauseSize && size % clauseSize === 0) {
+            // CoreCLR accommodates legacy VB/MC++ sections whose DataSize omits the
+            // four-byte section header. DataSize is still not the physical extent.
+            count = size / clauseSize;
+            sectionSize = 4 + count * clauseSize;
+        }
+        else {
             return malformedExceptionRegions("Exception section size does not contain whole clauses", regions);
+        }
+        if (sectionOffset > methodEnd - sectionSize ||
+            sectionOffset > bytes.length - sectionSize)
+            return malformedExceptionRegions("Exception section size leaves artifact", 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;
-        budget?.reserve(count * 256, sectionOffset);
+        // 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;
+        sectionOffset += sectionSize;
     }
     return { status: "complete", regions };
 };

package/dist/dotnet/ManagedMemberOwnership.js

@@ -0,0 +1,65 @@
+import { managedDecodeBudget } from "./ManagedDecodeBudget.js";
+import { 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, facts) => {
+    let byTable = lookups.get(facts);
+    const cached = byTable?.get(table);
+    if (cached instanceof ManagedReaderFailure)
+        throw cached;
+    if (cached !== undefined)
+        return cached;
+    if (byTable === undefined) {
+        byTable = new Map();
+        lookups.set(facts, 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;
+        };
+        for (let row = 1; row <= types; row += 1) {
+            const memberStart = table === 4
+                ? facts.entries[row - 1]?.field
+                : facts.entries[row - 1]?.method;
+            const start = memberStart?.start.value ?? null;
+            const end = memberStart?.end ?? null;
+            // A malformed endpoint makes this entire interval uncertain. In
+            // particular, zero must not become row one through owner-side clamping.
+            if (start !== null && end !== null) {
+                const limit = Math.min(end, positions + 1);
+                for (let p = unowned(Math.min(start, positions + 1)); p < limit; p = unowned(p + 1)) {
+                    owners[p] = row;
+                    next[p] = p + 1;
+                }
+            }
+        }
+        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,69 @@
+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;
+/** Normalize a TypeDef list coordinate once for parsing and owner lookup. */
+export const validatedMemberListStart = (start, table) => {
+    const total = table?.rowCount ?? 0;
+    return Number.isSafeInteger(start) && start >= 1 && start <= total + 1
+        ? start
+        : null;
+};
+/** 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;
+    }
+};