rea-agents 1.7.0 → 2.1.0

package/dist/dotnet/ManagedMetadataRowSizes.js

@@ -0,0 +1,54 @@
+import { managedFailure } from "./ManagedReaderFailure.js";
+const ROW_SIZE_FACTORIES = [
+    ({ stringSize: s, guidSize: g }) => 2 + s + g * 3,
+    ({ codedSize: c, stringSize: s }) => c("ResolutionScope") + s * 2,
+    ({ tableSize: t, codedSize: c, stringSize: s }) => 4 + s * 2 + c("TypeDefOrRef") + t(4) + t(6),
+    ({ tableSize: t }) => t(4),
+    ({ stringSize: s, blobSize: b }) => 2 + s + b,
+    ({ tableSize: t }) => t(6),
+    ({ tableSize: t, stringSize: s, blobSize: b }) => 8 + s + b + t(8),
+    ({ tableSize: t }) => t(8),
+    ({ stringSize: s }) => 4 + s,
+    ({ tableSize: t, codedSize: c }) => t(2) + c("TypeDefOrRef"),
+    ({ codedSize: c, stringSize: s, blobSize: b }) => c("MemberRefParent") + s + b,
+    ({ codedSize: c, blobSize: b }) => 2 + c("HasConstant") + b,
+    ({ codedSize: c, blobSize: b }) => c("HasCustomAttribute") + c("CustomAttributeType") + b,
+    ({ codedSize: c, blobSize: b }) => c("HasFieldMarshal") + b,
+    ({ codedSize: c, blobSize: b }) => 2 + c("HasDeclSecurity") + b,
+    ({ tableSize: t }) => 6 + t(2),
+    ({ tableSize: t }) => 4 + t(4),
+    ({ blobSize: b }) => b,
+    ({ tableSize: t }) => t(2) + t(20),
+    ({ tableSize: t }) => t(20),
+    ({ stringSize: s, codedSize: c }) => 2 + s + c("TypeDefOrRef"),
+    ({ tableSize: t }) => t(2) + t(23),
+    ({ tableSize: t }) => t(23),
+    ({ stringSize: s, blobSize: b }) => 2 + s + b,
+    ({ tableSize: t, codedSize: c }) => 2 + t(6) + c("HasSemantics"),
+    ({ tableSize: t, codedSize: c }) => t(2) + c("MethodDefOrRef") * 2,
+    ({ stringSize: s }) => s,
+    ({ blobSize: b }) => b,
+    ({ tableSize: t, codedSize: c, stringSize: s }) => 2 + c("MemberForwarded") + s + t(26),
+    ({ tableSize: t }) => 4 + t(4),
+    () => 8,
+    () => 4,
+    ({ blobSize: b, stringSize: s }) => 16 + b + s * 2,
+    () => 4,
+    () => 12,
+    ({ blobSize: b, stringSize: s }) => 12 + b * 2 + s * 2,
+    ({ tableSize: t }) => 4 + t(35),
+    ({ tableSize: t }) => 12 + t(35),
+    ({ stringSize: s, blobSize: b }) => 4 + s + b,
+    ({ stringSize: s, codedSize: c }) => 8 + s * 2 + c("Implementation"),
+    ({ stringSize: s, codedSize: c }) => 8 + s + c("Implementation"),
+    ({ tableSize: t }) => t(2) * 2,
+    ({ stringSize: s, codedSize: c }) => 4 + c("TypeOrMethodDef") + s,
+    ({ codedSize: c, blobSize: b }) => c("MethodDefOrRef") + b,
+    ({ tableSize: t, codedSize: c }) => t(42) + c("TypeDefOrRef"),
+];
+export const computeRowSize = (table, context) => {
+    const factory = ROW_SIZE_FACTORIES[table];
+    if (factory === undefined)
+        throw managedFailure("invalid-tables", "metadata.tables", `Metadata table ${String(table)} is unsupported`);
+    return factory(context);
+};

package/dist/dotnet/ManagedMethodBodyReader.js

@@ -0,0 +1,143 @@
+import { decodeInstructions, parseExceptionRegions, } from "./ManagedMemberInstructionDecoder.js";
+import { sha256Bytes } from "./ManagedMetadataHeaps.js";
+const readMethodBodyHeader = (bytes, offset) => {
+    const first = bytes.readUInt8(offset);
+    if ((first & 3) === 2)
+        return {
+            format: "tiny",
+            size: 1,
+            flags: 0,
+            maxStack: 8,
+            ilSize: first >> 2,
+            localSig: 0,
+        };
+    if ((first & 3) !== 3)
+        throw new RangeError("Unsupported method body header");
+    if (offset > bytes.length - 12)
+        throw new RangeError("Fat method body header leaves artifact");
+    const flagsAndSize = bytes.readUInt16LE(offset);
+    const headerDwords = flagsAndSize >>> 12;
+    if (headerDwords < 3)
+        throw new RangeError("Fat method body header is smaller than 12 bytes");
+    const size = headerDwords * 4;
+    if (offset > bytes.length - size)
+        throw new RangeError("Method body header leaves artifact");
+    return {
+        format: "fat",
+        size,
+        flags: flagsAndSize & 0x0fff,
+        maxStack: bytes.readUInt16LE(offset + 2),
+        ilSize: bytes.readUInt32LE(offset + 4),
+        localSig: bytes.readUInt32LE(offset + 8),
+    };
+};
+export const methodBody = (bytes, pe, rva, limits) => {
+    if (rva === 0)
+        return emptyMethodBody(rva, "absent", null);
+    try {
+        const offset = pe.rvaToOffset(rva, 1, "method.body");
+        const header = readMethodBodyHeader(bytes, offset);
+        if (header.ilSize > limits.maxMethodBodyBytes)
+            return oversizedMethodBody(header, rva, offset, limits);
+        const ilOffset = offset + header.size;
+        if (ilOffset > bytes.length - header.ilSize)
+            throw new RangeError("Method IL bytes leave artifact");
+        const il = bytes.subarray(ilOffset, ilOffset + header.ilSize);
+        const decoded = decodeInstructions(il, limits.maxMethodInstructions);
+        const opcodeCounts = {};
+        for (const instruction of decoded.parsed)
+            opcodeCounts[instruction.opcode] =
+                (opcodeCounts[instruction.opcode] ?? 0) + 1;
+        const anchors = decoded.parsed
+            .map((instruction, index) => ({ instruction, index }))
+            .filter(({ instruction }) => instruction.operandKind !== "none")
+            .slice(0, limits.instructionAnchorLimit)
+            .map(({ instruction }) => ({
+            il_offset: instruction.offset,
+            opcode: instruction.opcode,
+            operand_kind: instruction.operandKind,
+            operand: instruction.operand,
+        }));
+        const normalized = Buffer.from(JSON.stringify(decoded.parsed.map(({ opcode, operandKind, operand }) => [
+            opcode,
+            operandKind,
+            operand,
+        ])), "utf8");
+        const methodEnd = ilOffset + header.ilSize;
+        const sectionOffset = (methodEnd + 3) & ~3;
+        const status = decoded.issue !== null
+            ? "malformed"
+            : decoded.truncated > 0
+                ? "partial"
+                : "present";
+        return {
+            status,
+            header_format: header.format,
+            rva,
+            file_offset: offset,
+            max_stack: header.maxStack,
+            init_locals: (header.flags & 0x10) !== 0,
+            local_var_sig_token: header.localSig === 0
+                ? null
+                : `0x${header.localSig.toString(16).padStart(8, "0")}`,
+            il_size: header.ilSize,
+            il_sha256: sha256Bytes(il),
+            normalized_il_sha256: status === "present" ? sha256Bytes(normalized) : null,
+            instruction_count: decoded.count,
+            decoded_instruction_count: decoded.parsed.length,
+            truncated_instructions: decoded.truncated,
+            opcode_counts: opcodeCounts,
+            anchors,
+            exception_regions: header.format === "fat" && (header.flags & 8) !== 0
+                ? parseExceptionRegions(bytes, sectionOffset, bytes.length)
+                : [],
+            issue: decoded.issue ??
+                (decoded.truncated > 0
+                    ? `Instruction decode reached max_method_instructions ${String(limits.maxMethodInstructions)} before the end of the method body`
+                    : null),
+        };
+    }
+    catch (cause) {
+        return emptyMethodBody(rva, "malformed", cause instanceof Error ? cause.message : "Method body parse failed");
+    }
+};
+const emptyMethodBody = (rva, status, issue) => ({
+    status,
+    header_format: status === "absent" ? "none" : "unknown",
+    rva,
+    file_offset: null,
+    max_stack: null,
+    init_locals: null,
+    local_var_sig_token: null,
+    il_size: 0,
+    il_sha256: null,
+    normalized_il_sha256: null,
+    instruction_count: 0,
+    decoded_instruction_count: 0,
+    truncated_instructions: 0,
+    opcode_counts: {},
+    anchors: [],
+    exception_regions: [],
+    issue,
+});
+const oversizedMethodBody = (header, rva, offset, limits) => ({
+    status: "too-large",
+    header_format: header.format,
+    rva,
+    file_offset: offset,
+    max_stack: header.maxStack,
+    init_locals: (header.flags & 0x10) !== 0,
+    local_var_sig_token: header.localSig === 0
+        ? null
+        : `0x${header.localSig.toString(16).padStart(8, "0")}`,
+    il_size: header.ilSize,
+    il_sha256: null,
+    normalized_il_sha256: null,
+    instruction_count: 0,
+    decoded_instruction_count: 0,
+    truncated_instructions: 0,
+    opcode_counts: {},
+    anchors: [],
+    exception_regions: [],
+    issue: `Method body exceeds max_method_body_bytes ${String(limits.maxMethodBodyBytes)}`,
+});

package/dist/dotnet/ManagedNativeBoundaryHelpers.js

@@ -0,0 +1,311 @@
+import { managedNativeBoundaryInspectionSchema, } from "../domain/managedArtifact.js";
+import { metadataRowOffset, } from "./ManagedMetadataLayout.js";
+import { MetadataRowCursor, metadataToken, readMetadataString, } from "./ManagedMetadataHeaps.js";
+import { managedTableRowCounts } from "./ManagedMetadataInventory.js";
+import { managedFailure } from "./ManagedReaderFailure.js";
+const rowCursor = ({ bytes, layout, table, row, }) => {
+    const descriptor = layout.table(table);
+    const start = metadataRowOffset(layout, table, row);
+    if (descriptor === undefined)
+        throw managedFailure("invalid-row", `metadata.${String(table)}`, "Metadata table is absent", start);
+    return new MetadataRowCursor(bytes, start, start + descriptor.rowSize, `metadata.${descriptor.name}`);
+};
+const codedToken = (raw, tagBits, tables) => {
+    const tagMask = (1 << tagBits) - 1;
+    const table = tables[raw & tagMask];
+    const row = raw >> tagBits;
+    if (table === undefined || row === 0)
+        return null;
+    return metadataToken(table, row);
+};
+const flagsHex = (value) => `0x${value.toString(16).padStart(4, "0")}`;
+const page = (items, offset, limit) => {
+    const safeOffset = Math.min(offset, items.length);
+    const selected = items.slice(safeOffset, safeOffset + limit);
+    return {
+        items: selected,
+        offset,
+        limit,
+        total: items.length,
+        returned: selected.length,
+        dropped: Math.max(0, items.length - safeOffset - selected.length),
+        complete: safeOffset === 0 && selected.length === items.length,
+    };
+};
+export const parseModuleRefs = (bytes, layout, maxBytes) => {
+    const refs = [];
+    const table = layout.table(26);
+    for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
+        const cursor = rowCursor({ bytes, layout, table: 26, row });
+        refs.push({
+            token: metadataToken(26, row),
+            row_offset: cursor.start,
+            name: readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes),
+        });
+    }
+    return refs;
+};
+export const parseFields = (bytes, layout, maxBytes) => {
+    const fields = new Map();
+    const table = layout.table(4);
+    for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
+        const cursor = rowCursor({ bytes, layout, table: 4, row });
+        const flags = cursor.readUInt16();
+        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+        cursor.readIndex(layout.blobIndexSize);
+        const token = metadataToken(4, row);
+        fields.set(token, {
+            token,
+            rowOffset: cursor.start,
+            kind: "field",
+            name,
+            flags,
+            implFlags: null,
+            rva: null,
+        });
+    }
+    return fields;
+};
+export const parseMethods = (bytes, layout, maxBytes) => {
+    const methods = new Map();
+    const table = layout.table(6);
+    for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
+        const cursor = rowCursor({ bytes, layout, table: 6, row });
+        const rva = cursor.readUInt32();
+        const implFlags = cursor.readUInt16();
+        const flags = cursor.readUInt16();
+        const name = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+        cursor.readIndex(layout.blobIndexSize);
+        cursor.readIndex(layout.tableIndexSize(8));
+        const token = metadataToken(6, row);
+        methods.set(token, {
+            token,
+            rowOffset: cursor.start,
+            kind: "method",
+            name,
+            flags,
+            implFlags,
+            rva,
+        });
+    }
+    return methods;
+};
+export const parseImplMaps = ({ bytes, layout, maxBytes, modules, members, }) => {
+    const moduleNames = new Map(modules.map((module) => [module.token, module]));
+    const imports = [];
+    const table = layout.table(28);
+    for (let row = 1; row <= (table?.rowCount ?? 0); row += 1) {
+        const cursor = rowCursor({ bytes, layout, table: 28, row });
+        const mappingFlags = cursor.readUInt16();
+        const memberToken = codedToken(cursor.readIndex(layout.codedIndexSize("MemberForwarded")), 1, [4, 6]);
+        const importName = readMetadataString(bytes, layout, cursor.readIndex(layout.stringIndexSize), maxBytes);
+        const importScopeRow = cursor.readIndex(layout.tableIndexSize(26));
+        const importScopeToken = importScopeRow === 0 ? null : metadataToken(26, importScopeRow);
+        const member = memberToken === null ? undefined : members.get(memberToken);
+        imports.push({
+            token: metadataToken(28, row),
+            row_offset: cursor.start,
+            mapping_flags: mappingFlags,
+            mapping_flags_hex: flagsHex(mappingFlags),
+            member_token: memberToken,
+            member_kind: member?.kind ?? "unknown",
+            member_name: member?.name ?? null,
+            import_name: importName,
+            import_scope_token: importScopeToken,
+            import_scope_name: importScopeToken === null
+                ? null
+                : (moduleNames.get(importScopeToken)?.name ?? null),
+            no_mangle: (mappingFlags & 0x0001) !== 0,
+            char_set: charSet(mappingFlags),
+            call_convention: callConvention(mappingFlags),
+            supports_last_error: (mappingFlags & 0x0040) !== 0,
+            best_fit: bestFit(mappingFlags),
+            throw_on_unmappable_char: throwOnUnmappable(mappingFlags),
+            verification: "managed-declaration-only",
+        });
+    }
+    return imports;
+};
+const charSet = (flags) => {
+    switch (flags & 0x0006) {
+        case 0x0000:
+            return "not-specified";
+        case 0x0002:
+            return "ansi";
+        case 0x0004:
+            return "unicode";
+        case 0x0006:
+            return "auto";
+        default:
+            return "unknown";
+    }
+};
+const callConvention = (flags) => {
+    switch (flags & 0x0700) {
+        case 0x0000:
+            return "not-specified";
+        case 0x0100:
+            return "winapi";
+        case 0x0200:
+            return "cdecl";
+        case 0x0300:
+            return "stdcall";
+        case 0x0400:
+            return "thiscall";
+        case 0x0500:
+            return "fastcall";
+        default:
+            return "unknown";
+    }
+};
+const bestFit = (flags) => {
+    switch (flags & 0x0030) {
+        case 0x0000:
+            return "assembly-default";
+        case 0x0010:
+            return "enabled";
+        case 0x0020:
+            return "disabled";
+        default:
+            return "unknown";
+    }
+};
+const throwOnUnmappable = (flags) => {
+    switch (flags & 0x3000) {
+        case 0x0000:
+            return "assembly-default";
+        case 0x1000:
+            return "enabled";
+        case 0x2000:
+            return "disabled";
+        default:
+            return "unknown";
+    }
+};
+export const nativeImplementations = (methods, pinvokeTokens) => {
+    const implementations = [];
+    for (const method of methods) {
+        const implFlags = method.implFlags ?? 0;
+        const codeType = codeTypeFor(implFlags);
+        const managedKind = managedKindFor(implFlags);
+        const pinvokeDeclared = pinvokeTokens.has(method.token) || (method.flags & 0x2000) !== 0;
+        if (!pinvokeDeclared && codeType === "il" && managedKind === "managed")
+            continue;
+        implementations.push({
+            token: method.token,
+            row_offset: method.rowOffset,
+            name: method.name,
+            rva: method.rva ?? 0,
+            flags: method.flags,
+            impl_flags: implFlags,
+            code_type: codeType,
+            managed_kind: managedKind,
+            pinvoke_declared: pinvokeDeclared,
+            boundary_kind: boundaryKind(pinvokeDeclared, codeType, managedKind),
+            body_interpretation: codeType === "il" && managedKind === "managed" && !pinvokeDeclared
+                ? "managed-cil"
+                : method.rva === 0
+                    ? "not-file-backed"
+                    : "native-or-runtime",
+        });
+    }
+    return implementations;
+};
+const codeTypeFor = (implFlags) => {
+    switch (implFlags & 0x0003) {
+        case 0x0000:
+            return "il";
+        case 0x0001:
+            return "native";
+        case 0x0002:
+            return "optil";
+        case 0x0003:
+            return "runtime";
+        default:
+            return "unknown";
+    }
+};
+const managedKindFor = (implFlags) => {
+    switch (implFlags & 0x0004) {
+        case 0x0000:
+            return "managed";
+        case 0x0004:
+            return "unmanaged";
+        default:
+            return "unknown";
+    }
+};
+const boundaryKind = (pinvokeDeclared, codeType, managedKind) => {
+    if (pinvokeDeclared)
+        return "pinvoke";
+    if (codeType === "native")
+        return "native-body";
+    if (codeType === "runtime")
+        return "runtime-provided";
+    if (managedKind === "unmanaged")
+        return "unmanaged-method";
+    return "mixed-or-unknown";
+};
+export const cliNative = (pe) => {
+    if (pe.cli === null)
+        return {
+            il_only: false,
+            requires_32bit: false,
+            strong_name_signed: false,
+            native_entry_point: false,
+            ready_to_run_signature: false,
+            managed_native_header_rva: 0,
+            managed_native_header_size: 0,
+        };
+    return {
+        il_only: (pe.cli.flags & 0x0000_0001) !== 0,
+        requires_32bit: (pe.cli.flags & 0x0000_0002) !== 0,
+        strong_name_signed: (pe.cli.flags & 0x0000_0008) !== 0,
+        native_entry_point: (pe.cli.flags & 0x0000_0010) !== 0,
+        ready_to_run_signature: pe.cli.readyToRunSignature,
+        managed_native_header_rva: pe.cli.managedNativeHeader.rva,
+        managed_native_header_size: pe.cli.managedNativeHeader.size,
+    };
+};
+export const buildNativeBoundaryInspection = ({ target, bytes, limits, layout, inventory, moduleRefs, imports, implementations, native, issues, }) => managedNativeBoundaryInspectionSchema.parse({
+    schema_version: 1,
+    artifact: {
+        path: target.path,
+        sha256: target.sha256,
+        byte_length: bytes.length,
+        format: "pe",
+    },
+    module: inventory.module,
+    metadata: {
+        status: issues.length === 0 ? "complete" : "partial",
+        version: layout.version,
+        table_row_counts: managedTableRowCounts(layout),
+    },
+    identity_scope: {
+        token_identity: "build-local",
+        requires_artifact_sha256: target.sha256,
+        requires_mvid: inventory.module?.mvid ?? null,
+    },
+    cli_native: native,
+    module_refs: page(moduleRefs, limits.moduleRefOffset, limits.moduleRefLimit),
+    pinvoke_imports: page(imports, limits.importOffset, limits.importLimit),
+    native_implementations: page(implementations, limits.implementationOffset, limits.implementationLimit),
+    summary: {
+        module_ref_count: moduleRefs.length,
+        pinvoke_import_count: imports.length,
+        native_implementation_count: implementations.length,
+        ready_to_run: native.ready_to_run_signature,
+        mixed_mode_or_native_header: native.managed_native_header_rva !== 0 ||
+            native.managed_native_header_size !== 0 ||
+            native.native_entry_point,
+    },
+    coverage: {
+        state: issues.length === 0 ? "complete" : "partial",
+        issues,
+    },
+    limitations: [
+        "P/Invoke rows prove managed import declarations only; this inspection does not verify that a native library, export, thunk, or provider-qualified function exists.",
+        "Managed metadata tokens are build-local coordinates and are only meaningful with the reported artifact SHA-256 and MVID.",
+        "ReadyToRun, NativeAOT, C++/CLI, and IL2CPP native semantics require separately selected native-provider evidence; this tool does not translate managed tokens into native addresses.",
+    ],
+});

package/dist/dotnet/ManagedNativeBoundaryInspector.js

@@ -0,0 +1,143 @@
+import { managedNativeBoundaryInspectionSchema, } from "../domain/managedArtifact.js";
+import { readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
+import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
+import { readManagedPeLayout, } from "./ManagedPeReader.js";
+import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
+import { buildNativeBoundaryInspection, cliNative, nativeImplementations, parseFields, parseImplMaps, parseMethods, parseModuleRefs, } from "./ManagedNativeBoundaryHelpers.js";
+const emptyPage = () => ({
+    items: [],
+    offset: 0,
+    limit: 0,
+    total: 0,
+    returned: 0,
+    dropped: 0,
+    complete: true,
+});
+const emptyInspection = (target, bytes, classification, issues = []) => managedNativeBoundaryInspectionSchema.parse({
+    schema_version: 1,
+    artifact: {
+        path: target.path,
+        sha256: target.sha256,
+        byte_length: bytes.length,
+        format: "pe",
+    },
+    module: null,
+    metadata: {
+        status: classification === "malformed" || classification === "not-available"
+            ? "malformed"
+            : "absent",
+        version: null,
+        table_row_counts: {},
+    },
+    identity_scope: {
+        token_identity: "build-local",
+        requires_artifact_sha256: target.sha256,
+        requires_mvid: null,
+    },
+    cli_native: {
+        il_only: false,
+        requires_32bit: false,
+        strong_name_signed: false,
+        native_entry_point: false,
+        ready_to_run_signature: false,
+        managed_native_header_rva: 0,
+        managed_native_header_size: 0,
+    },
+    module_refs: emptyPage(),
+    pinvoke_imports: emptyPage(),
+    native_implementations: emptyPage(),
+    summary: {
+        module_ref_count: 0,
+        pinvoke_import_count: 0,
+        native_implementation_count: 0,
+        ready_to_run: false,
+        mixed_mode_or_native_header: false,
+    },
+    coverage: { state: classification, issues },
+    limitations: [
+        "No CLI data was admitted; native boundary declarations are unavailable.",
+        "Static inspection does not load or execute target code, so native export resolution is not performed.",
+    ],
+});
+const readBoundaryInventory = (bytes, pe, limits) => {
+    const cli = pe.cli;
+    const metadataOffset = pe.rvaToOffset(cli.metadata.rva, cli.metadata.size, "cli.metadata");
+    const layout = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size, limits.maxTableRows);
+    const resourceDirectory = {
+        offset: pe.rvaToOffset(cli.resources.rva, cli.resources.size, "cli.resources"),
+        size: cli.resources.size,
+    };
+    const inventory = readManagedMetadataInventory(bytes, layout, {
+        referenceOffset: 0,
+        referenceLimit: 0,
+        resourceOffset: 0,
+        resourceLimit: 0,
+        attributeOffset: 0,
+        attributeLimit: 0,
+        maxHeapItemBytes: limits.maxHeapItemBytes,
+    }, resourceDirectory);
+    return { layout, inventory };
+};
+const metadataLimitIssue = (cli, maxBytes) => ({
+    code: "limit-exceeded",
+    scope: "cli.metadata",
+    offset: cli.headerOffset + 8,
+    detail: `CLI metadata size exceeds max_metadata_bytes ${String(maxBytes)}`,
+});
+/** Inspect managed/native boundary declarations from PE metadata without execution. */
+export const inspectManagedNativeBoundariesBytes = (bytes, target, limits) => {
+    let pe;
+    try {
+        pe = readManagedPeLayout(bytes);
+    }
+    catch (cause) {
+        if (!(cause instanceof ManagedReaderFailure))
+            throw cause;
+        return emptyInspection(target, bytes, "malformed", [cause.issue]);
+    }
+    if (pe.cli === null)
+        return emptyInspection(target, bytes, pe.cliDirectoryPresent ? "malformed" : "not-managed", pe.cliIssue === null ? [] : [pe.cliIssue]);
+    if (pe.cli.metadata.size > limits.maxMetadataBytes)
+        return emptyInspection(target, bytes, "malformed", [
+            metadataLimitIssue(pe.cli, limits.maxMetadataBytes),
+        ]);
+    let layout;
+    let inventory;
+    try {
+        ({ layout, inventory } = readBoundaryInventory(bytes, pe, limits));
+    }
+    catch (cause) {
+        if (!(cause instanceof ManagedReaderFailure))
+            throw cause;
+        return emptyInspection(target, bytes, "malformed", [cause.issue]);
+    }
+    const moduleRefs = parseModuleRefs(bytes, layout, limits.maxHeapItemBytes);
+    const members = new Map([
+        ...parseFields(bytes, layout, limits.maxHeapItemBytes),
+        ...parseMethods(bytes, layout, limits.maxHeapItemBytes),
+    ]);
+    const imports = parseImplMaps({
+        bytes,
+        layout,
+        maxBytes: limits.maxHeapItemBytes,
+        modules: moduleRefs,
+        members,
+    });
+    const pinvokeTokens = new Set(imports
+        .map(({ member_token }) => member_token)
+        .filter((token) => token !== null));
+    const implementations = nativeImplementations(members.values(), pinvokeTokens);
+    return buildNativeBoundaryInspection({
+        target,
+        bytes,
+        limits,
+        pe,
+        layout,
+        inventory,
+        moduleRefs,
+        imports,
+        implementations,
+        native: cliNative(pe),
+        issues: [],
+    });
+};