rea-agents 6.4.0 → 6.7.0

package/dist/domain/managed/managedMemberComparisonMatch.js

@@ -2,46 +2,53 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { managedMemberInspectionSchema, } from "./managedArtifact.js";
 import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
+import { comparableSides, signatureIdentity, } from "./managedMemberSignatureIdentity.js";
 export const sha256 = (value) => {
     const serialized = canonicalize(value);
     if (serialized === undefined)
         throw new TypeError("Managed comparison canonicalization failed");
     return createHash("sha256").update(serialized).digest("hex");
 };
-const keyMethod = (item) => ({
+const keyMethod = (item, declared) => ({
     item,
-    exactKey: item.body.status === "present" && item.body.normalized_il_sha256 !== null
+    identity: identityOf({ declaring_type: declared(item), name: item.name }),
+    identityUnavailable: declared(item) === null,
+    signatureId: signatureIdentity(item.signature),
+    exactKey: item.body.status === "present" &&
+        item.body.il_sha256 !== null &&
+        item.body.normalized_il_sha256 !== null
         ? sha256([
             "method-exact",
-            item.signature.raw_sha256,
+            signatureIdentity(item.signature),
+            item.body.il_sha256,
             item.body.normalized_il_sha256,
         ])
         : null,
-    // The raw blob is the exact signature; decoding only feeds shape keys.
-    signatureKey: sha256([
-        "method-signature",
-        item.declaring_type,
-        item.name,
-        item.signature.raw_sha256,
-    ]),
+    // The blob, with type operands named, is the exact signature; decoding
+    // only gates the shape keys.
+    signatureKey: declared(item) === null
+        ? null
+        : sha256([
+            "method-signature",
+            declared(item),
+            item.name,
+            signatureIdentity(item.signature),
+        ]),
     structuralKey: item.signature.parse_status === "decoded" && item.body.status === "present"
         ? sha256([
             "method-structural",
-            item.signature.kind,
-            item.signature.calling_convention,
-            item.signature.generic_parameter_count,
-            item.signature.parameter_count,
-            item.signature.return_type,
-            item.signature.parameter_types,
+            // Decoded type strings carry build-local rows; the identity names them.
+            signatureIdentity(item.signature),
             item.body.status,
             item.body.header_format,
             item.body.il_size,
             item.body.max_stack,
             item.body.init_locals,
             item.body.opcode_counts,
-            item.body.anchors.map(({ opcode, operand_kind }) => [
+            item.body.anchors.map(({ opcode, operand_kind, operand }) => [
                 opcode,
                 operand_kind,
+                operand_kind === "constant" ? operand : null,
             ]),
             item.body.exception_regions.map((region) => [
                 region.flags,
@@ -53,19 +60,24 @@ const keyMethod = (item) => ({
         ])
         : null,
 });
-const keyField = (item) => ({
+const keyField = (item, declared) => ({
     item,
+    identity: identityOf({ declaring_type: declared(item), name: item.name }),
+    identityUnavailable: declared(item) === null,
+    signatureId: signatureIdentity(item.signature),
     exactKey: item.signature.parse_status === "decoded"
-        ? sha256(["field-exact", item.signature.raw_sha256])
+        ? sha256(["field-exact", signatureIdentity(item.signature)])
         : null,
     // Only an undecoded field reaches this round: a decoded field with the
-    // same raw signature already met its counterpart in the exact round.
-    signatureKey: sha256([
-        "field-signature",
-        item.declaring_type,
-        item.name,
-        item.signature.raw_sha256,
-    ]),
+    // same signature already met its counterpart in the exact round.
+    signatureKey: declared(item) === null
+        ? null
+        : sha256([
+            "field-signature",
+            declared(item),
+            item.name,
+            signatureIdentity(item.signature),
+        ]),
     structuralKey: sha256([
         "field-structural",
         item.signature.kind,
@@ -76,52 +88,106 @@ const keyField = (item) => ({
 const matchMethods = (left, right) => matchByKeys({
     left,
     right,
-    exactBasis: "exact-il-signature",
-    fallbackBases: [
+    rounds: [
+        {
+            basis: "exact-il-signature",
+            key: declaredAs(({ exactKey }) => exactKey),
+        },
         {
             basis: "exact-signature",
             key: ({ signatureKey }) => signatureKey,
+            competitionKey: ({ signatureId }) => signatureId,
+        },
+        {
+            basis: "structural-method-shape",
+            // An unresolved owner has no declared shape match to prove.
+            key: declaredAs((keyed) => keyed.identityUnavailable ? null : keyed.structuralKey),
+            competitionKey: ({ structuralKey }) => structuralKey,
+        },
+        {
+            basis: "exact-il-signature",
+            key: ({ exactKey }) => exactKey,
+            remap: true,
         },
         {
             basis: "structural-method-shape",
             key: ({ structuralKey }) => structuralKey,
+            competitionKey: ({ structuralKey }) => structuralKey,
+            remap: true,
         },
     ],
 });
 const matchFields = (left, right) => matchByKeys({
     left,
     right,
-    exactBasis: "field-signature",
-    fallbackBases: [
+    rounds: [
+        {
+            basis: "field-signature",
+            key: declaredAs(({ exactKey }) => exactKey),
+        },
         {
             basis: "exact-signature",
             key: ({ signatureKey }) => signatureKey,
+            competitionKey: ({ signatureId }) => signatureId,
+        },
+        {
+            basis: "field-signature",
+            key: ({ exactKey }) => exactKey,
+            remap: true,
         },
     ],
 });
-const matchByKeys = ({ left, right, exactBasis, fallbackBases, }) => {
+export const identityOf = ({ declaring_type, name, }) => sha256([declaring_type, name]);
+/** Narrow a key to members of one declared type and name. */
+const declaredAs = (key) => (item) => {
+    const value = key(item);
+    return value === null || item.identityUnavailable
+        ? null
+        : sha256([item.identity, value]);
+};
+const matchByKeys = ({ left, right, rounds, }) => {
     const usedLeft = new Set();
     const usedRight = new Set();
+    const pairedLeft = new Set();
+    const pairedRight = new Set();
     const pairs = [];
     const ambiguous = [];
-    const rounds = [
-        { basis: exactBasis, key: ({ exactKey }) => exactKey },
-        ...fallbackBases,
-    ];
     for (const round of rounds) {
-        const leftGroups = groupBy(left.filter((item) => !usedLeft.has(item)), round.key);
-        const rightGroups = groupBy(right.filter((item) => !usedRight.has(item)), round.key);
+        const competitionKey = round.competitionKey ?? ((item) => item.exactKey);
+        const unpairedLeft = unpairedOf(left, pairedLeft);
+        const unpairedRight = unpairedOf(right, pairedRight);
+        const declarable = declaredCandidates(unpairedLeft, unpairedRight, competitionKey);
+        const openLeft = left.filter((item) => !usedLeft.has(item));
+        const openRight = right.filter((item) => !usedRight.has(item));
+        // Only open candidates can justify overriding a held declared identity:
+        // consumed ambiguous rows remain identity barriers, but cannot join a
+        // later remap group to establish its ambiguity.
+        const remapContested = round.remap === true
+            ? ownerlessContested([openLeft, openRight], competitionKey)
+            : new Set();
+        const leftGroups = groupBy(round.remap === true
+            ? remappable(openLeft, unpairedRight, competitionKey, remapContested)
+            : openLeft.filter(declarable), round.key);
+        const rightGroups = groupBy(round.remap === true
+            ? remappable(openRight, unpairedLeft, competitionKey, remapContested)
+            : openRight.filter(declarable), round.key);
         for (const [key, leftItems] of leftGroups) {
             const rightItems = rightGroups.get(key);
             if (rightItems === undefined)
                 continue;
-            if (leftItems.length === 1 && rightItems.length === 1) {
+            // An unresolved owner may be either member's own counterpart, so a
+            // remap group it joins stays ambiguous.
+            const refused = round.remap === true &&
+                [...leftItems, ...rightItems].some(({ identityUnavailable }) => identityUnavailable);
+            if (!refused && leftItems.length === 1 && rightItems.length === 1) {
                 const [leftItem] = leftItems;
                 const [rightItem] = rightItems;
                 if (leftItem === undefined || rightItem === undefined)
                     continue;
                 usedLeft.add(leftItem);
                 usedRight.add(rightItem);
+                pairedLeft.add(leftItem);
+                pairedRight.add(rightItem);
                 pairs.push({
                     left: leftItem,
                     right: rightItem,
@@ -146,6 +212,17 @@ const matchByKeys = ({ left, right, exactBasis, fallbackBases, }) => {
             }
         }
     }
+    // Contention can prevent a declared signature pair even when CIL/shape
+    // evidence cannot form a later remap. Held ambiguities still contest
+    // ownership; only proven pairs leave that evidence pool. Group only open
+    // candidates so held members retain their original ambiguity and provenance.
+    for (const group of unresolvedSignatureAmbiguities(left.filter((item) => !usedLeft.has(item)), right.filter((item) => !usedRight.has(item)), ownerlessContested([unpairedOf(left, pairedLeft), unpairedOf(right, pairedRight)], (member) => member.signatureId))) {
+        for (const item of group.left)
+            usedLeft.add(item);
+        for (const item of group.right)
+            usedRight.add(item);
+        ambiguous.push(group);
+    }
     return {
         pairs,
         ambiguous,
@@ -153,6 +230,79 @@ const matchByKeys = ({ left, right, exactBasis, fallbackBases, }) => {
         rightOnly: right.filter((item) => !usedRight.has(item)),
     };
 };
+/** Open signature choices contested by unresolved owners, including held rows. */
+const unresolvedSignatureAmbiguities = (left, right, contested) => {
+    const key = (member) => competitionIdentityKey(member, member.signatureId) ?? "";
+    const leftGroups = groupBy(left, key);
+    const rightGroups = groupBy(right, key);
+    const groups = [];
+    for (const [signature, leftItems] of leftGroups) {
+        const rightItems = rightGroups.get(signature);
+        if (!contested.has(signature) || rightItems === undefined)
+            continue;
+        groups.push({
+            left: leftItems,
+            right: rightItems,
+            basis: "exact-signature",
+        });
+    }
+    return groups;
+};
+const unpairedOf = (items, paired) => items.filter((item) => !paired.has(item));
+/**
+ * Round-specific evidence keys an unresolved owner competes for, paired with
+ * its retained member name. Another same-name member on the same side can be
+ * the unresolved row's owner; a different name cannot. Contested candidates
+ * stay in remap rounds rather than pairing by declared identity.
+ */
+const competitionIdentityKey = (member, evidenceKey) => evidenceKey === null ? null : JSON.stringify([member.item.name, evidenceKey]);
+const ownerlessContested = (sides, keyOf) => {
+    const contested = new Set();
+    for (const side of sides) {
+        const seen = new Map();
+        const ownerless = new Set();
+        for (const member of side) {
+            const key = competitionIdentityKey(member, keyOf(member));
+            if (key === null)
+                continue;
+            seen.set(key, (seen.get(key) ?? 0) + 1);
+            if (member.identityUnavailable)
+                ownerless.add(key);
+        }
+        for (const key of ownerless)
+            if ((seen.get(key) ?? 0) > 1)
+                contested.add(key);
+    }
+    return contested;
+};
+/**
+ * Members a remap round may group: an unresolved owner, which keeps its group
+ * ambiguous; a member whose selected key an unresolved owner competes for, so the
+ * group that preserved the base matcher's ambiguity can form; or no member of
+ * the same declared identity left unpaired on the other side, whether
+ * one-sided or in an ambiguous group. The sets are taken before grouping, so
+ * no group order decides a remap.
+ */
+const remappable = (items, others, keyOf, contested) => {
+    const kept = new Set(others.map(({ identity }) => identity));
+    return items.filter((member) => {
+        const key = keyOf(member);
+        return ((key !== null &&
+            contested.has(competitionIdentityKey(member, key) ?? "")) ||
+            member.identityUnavailable ||
+            !kept.has(member.identity));
+    });
+};
+/** A declared round needs a resolved owner and no unresolved contender. */
+const declaredCandidates = (left, right, keyOf) => {
+    const contested = ownerlessContested([left, right], keyOf);
+    return (member) => {
+        if (member.identityUnavailable)
+            return false;
+        const key = competitionIdentityKey(member, keyOf(member));
+        return key === null || !contested.has(key);
+    };
+};
 const groupBy = (items, keyOf) => {
     const grouped = new Map();
     for (const item of items) {
@@ -165,10 +315,55 @@ const groupBy = (items, keyOf) => {
     }
     return grouped;
 };
-export const keyMembers = (left, right) => ({
-    methodMatches: matchMethods(left.result.methods.map(keyMethod), right.result.methods.map(keyMethod)),
-    fieldMatches: matchFields(left.result.fields.map(keyField), right.result.fields.map(keyField)),
-});
+/** Whether a side's inventory observed members of this declaring type. */
+const observedBy = (side) => ({ declaring_type }) => side.result.selection === null ||
+    (declaring_type !== null &&
+        side.result.selection.type_names.includes(declaring_type));
+/**
+ * Pair only members whose declaring type both sides observed. A member outside
+ * the other side's selection stays one-sided, so a type selection never yields
+ * a remap to a member of a type the other side did not inspect.
+ */
+const matchObserved = (left, right, sides, match, keyLeft, keyRight) => {
+    const matched = match(left.filter(sides.inRight).map(keyLeft), right.filter(sides.inLeft).map(keyRight));
+    return {
+        ...matched,
+        leftOnly: [
+            ...matched.leftOnly,
+            ...left.filter((item) => !sides.inRight(item)).map(keyLeft),
+        ],
+        rightOnly: [
+            ...matched.rightOnly,
+            ...right.filter((item) => !sides.inLeft(item)).map(keyRight),
+        ],
+    };
+};
+export const keyMembers = (observedLeft, observedRight) => {
+    const [left, right] = comparableSides(observedLeft, observedRight);
+    const sides = { inLeft: observedBy(left), inRight: observedBy(right) };
+    const modern = left.result.nesting_read !== null && right.result.nesting_read !== null;
+    const declared = (inspection) => {
+        const names = new Map(inspection.types.map((type) => [type.token, type.name_sha256]));
+        return (item) => {
+            if (inspection.nesting_read === false)
+                return null;
+            const digest = names.get(item.declaring_type_token ?? "");
+            // A historical counterpart cannot repair an observed current name gap.
+            if (inspection.nesting_read !== null && digest == null)
+                return null;
+            // Historical observations retain their explicitly limited bare-name mode.
+            if (!modern)
+                return item.declaring_type;
+            return digest == null ? null : ["nominal-name-sha256", digest];
+        };
+    };
+    const declaredLeft = declared(left.result);
+    const declaredRight = declared(right.result);
+    return {
+        methodMatches: matchObserved(left.result.methods, right.result.methods, sides, matchMethods, (item) => keyMethod(item, declaredLeft), (item) => keyMethod(item, declaredRight)),
+        fieldMatches: matchObserved(left.result.fields, right.result.fields, sides, matchFields, (item) => keyField(item, declaredLeft), (item) => keyField(item, declaredRight)),
+    };
+};
 export const parseManagedMemberEvidence = (evidence) => {
     const parsed = parseManagedInspectionEvidence(evidence, "inspect_managed_members", managedMemberInspectionSchema);
     return {

package/dist/domain/managed/managedMemberSignatureIdentity.js

@@ -0,0 +1,40 @@
+/**
+ * The exact signature across builds: raw bytes with type operands resolved to
+ * names. Raw bytes name types by build-local rows, so they stand in only when
+ * REA could not resolve the operands, or for Evidence recorded before it did.
+ * The kind is part of the key: an undecodable blob can hold another
+ * signature's resolved preimage, so its raw digest can equal that resolved
+ * digest without the two being the same signature.
+ */
+export const signatureIdentity = ({ raw_sha256, resolved_sha256, }) => resolved_sha256 === null
+    ? `raw:${raw_sha256}`
+    : `resolved:${resolved_sha256}`;
+/**
+ * The producer attests examination independently of whether it could resolve
+ * any operands. A current inventory of only unresolved types is not legacy.
+ */
+export const hasSignatureResolution = (result) => result.signature_resolution !== null ||
+    (result.methods.length === 0 && result.fields.length === 0);
+const withoutResolution = (members) => members.map((member) => ({
+    ...member,
+    signature: { ...member.signature, resolved_sha256: null },
+}));
+/**
+ * Compare raw signatures on both sides when either observation predates
+ * resolved digests; a resolved digest never equals a raw one for a signature
+ * that names a type, so mixing them would lose pairs a raw comparison finds.
+ */
+export const comparableSides = (left, right) => {
+    if (hasSignatureResolution(left.result) &&
+        hasSignatureResolution(right.result))
+        return [left, right];
+    const raw = (side) => ({
+        ...side,
+        result: {
+            ...side.result,
+            methods: withoutResolution(side.result.methods),
+            fields: withoutResolution(side.result.fields),
+        },
+    });
+    return [raw(left), raw(right)];
+};

package/dist/domain/managed/managedNativeVerificationMatch.js

@@ -65,10 +65,10 @@ export const collectNativeSymbols = (observations) => {
     }
     return { symbols, accepted, unsupported };
 };
-const sameSymbolName = (expected, native) => expected ===
-    (native.source === "macho-export" && native.name.startsWith("_")
-        ? native.name.slice(1)
-        : native.name);
+const normalizedSymbolName = (native) => native.source === "macho-export" && native.name.startsWith("_")
+    ? native.name.slice(1)
+    : native.name;
+const sameSymbolName = (expected, native) => expected === normalizedSymbolName(native);
 const normalizeModule = (value) => basename(value)
     .toLowerCase()
     .replace(/\.(dll|dylib|so|node|exe)$/u, "");
@@ -81,13 +81,14 @@ const nativeModuleIdentities = (value) => {
     return identities;
 };
 const moduleCompatible = (scope, symbol) => {
-    if (scope === null)
-        return true;
+    if (scope === null || scope.trim().length === 0)
+        return false;
     const expected = normalizeModule(scope);
     return [symbol.module_name, symbol.module_path]
-        .filter((value) => value !== null)
+        .filter((value) => value !== null && normalizeModule(value).length > 0)
         .some((value) => nativeModuleIdentities(value).has(expected));
 };
+const hasModuleIdentity = (symbol) => [symbol.module_name, symbol.module_path].some((value) => value !== null && normalizeModule(value).length > 0);
 const candidateNames = (managed) => {
     const names = new Set([managed.import_name]);
     if (!managed.no_mangle) {
@@ -119,20 +120,17 @@ const matchPinvoke = (managed, symbols, supportedNativeEvidence) => {
             },
         };
     const candidates = [first, ...remaining];
-    const exact = candidates.find((symbol) => managed.import_name === symbol.name &&
+    const scopeKnown = managed.import_scope_name !== null &&
+        managed.import_scope_name.trim().length > 0;
+    const exact = candidates.find((symbol) => managed.import_name === normalizedSymbolName(symbol) &&
         moduleCompatible(managed.import_scope_name, symbol));
     const decorated = candidates.find((symbol) => moduleCompatible(managed.import_scope_name, symbol));
-    const selected = exact ?? decorated ?? first;
-    if (!moduleCompatible(managed.import_scope_name, selected))
-        return {
-            match: {
-                status: "contradicted",
-                basis: "module-mismatch",
-                confidence: "unknown",
-                matched_native: selected,
-                candidates,
-            },
-        };
+    const selected = exact ??
+        decorated ??
+        (scopeKnown
+            ? candidates.find((symbol) => !hasModuleIdentity(symbol))
+            : undefined) ??
+        first;
     if (exact !== undefined)
         return {
             match: {
@@ -145,34 +143,59 @@ const matchPinvoke = (managed, symbols, supportedNativeEvidence) => {
                 candidates,
             },
         };
+    if (decorated !== undefined)
+        return {
+            match: {
+                basis: "decorated-name-candidate",
+                status: "inferred",
+                confidence: "inferred",
+                matched_native: selected,
+                candidates,
+            },
+        };
+    if (!scopeKnown || !hasModuleIdentity(selected))
+        return {
+            match: {
+                status: "unresolved",
+                basis: "module-identity-unknown",
+                confidence: "unknown",
+                matched_native: selected,
+                candidates,
+            },
+        };
     return {
         match: {
-            basis: "decorated-name-candidate",
-            status: "inferred",
-            confidence: "inferred",
+            status: "contradicted",
+            basis: "module-mismatch",
+            confidence: "unknown",
             matched_native: selected,
             candidates,
         },
     };
 };
-const pinvokeLimitations = (status, managed) => [
-    ...(managed.import_scope_name === null
+const pinvokeLimitations = (match, managed) => [
+    ...(managed.import_scope_name === null ||
+        managed.import_scope_name.trim().length === 0
         ? ["Managed declaration does not name an import scope/module."]
         : []),
-    ...(status === "inferred"
+    ...(match.status === "inferred"
         ? [
             "Native symbol matched a decorated candidate rather than the exact declared import name.",
         ]
         : []),
-    ...(status === "contradicted"
+    ...(match.status === "contradicted"
         ? [
             "A symbol name candidate exists, but the supplied native Evidence module identity does not match the managed import scope.",
         ]
         : []),
-    ...(status === "unresolved"
-        ? [
-            "No supplied native export/function Evidence matched this declared import.",
-        ]
+    ...(match.status === "unresolved"
+        ? match.basis === "module-identity-unknown"
+            ? [
+                "A native name candidate exists, but a required module identity is unavailable; module correspondence is unknown.",
+            ]
+            : [
+                "No supplied native export/function Evidence matched this declared import.",
+            ]
         : []),
 ];
 export const verifyPinvoke = ({ item, managedEvidenceId, native, }) => {
@@ -188,7 +211,7 @@ export const verifyPinvoke = ({ item, managedEvidenceId, native, }) => {
         declaration_verification: item.verification,
     };
     const selection = matchPinvoke(item, native.symbols, native.accepted);
-    const limitations = pinvokeLimitations(selection.match.status, item);
+    const limitations = pinvokeLimitations(selection.match, item);
     return {
         verification: pinvokeVerificationSchema.parse({
             item_id: `mnv_pinvoke_${digest({

package/dist/domain/managed/managedNativeVerificationSchemas.js

@@ -41,9 +41,9 @@ const pinvokeVerificationContextShape = {
     limitations: z.array(textSchema),
 };
 const observedCandidatesSchema = z
-    .tuple([nativeSymbolSchema])
-    .rest(nativeSymbolSchema);
-export const pinvokeVerificationSchema = z.discriminatedUnion("status", [
+    .tuple([nativeSymbolSchema], nativeSymbolSchema)
+    .check(z.minLength(1));
+export const pinvokeVerificationSchema = z.union([
     z.strictObject({
         ...pinvokeVerificationContextShape,
         status: z.literal("verified"),
@@ -68,6 +68,14 @@ export const pinvokeVerificationSchema = z.discriminatedUnion("status", [
         matched_native: z.null(),
         candidates: emptyArraySchema,
     }),
+    z.strictObject({
+        ...pinvokeVerificationContextShape,
+        status: z.literal("unresolved"),
+        basis: z.literal("module-identity-unknown"),
+        confidence: z.literal("unknown"),
+        matched_native: nativeSymbolSchema,
+        candidates: observedCandidatesSchema,
+    }),
     z.strictObject({
         ...pinvokeVerificationContextShape,
         status: z.literal("contradicted"),
@@ -81,7 +89,10 @@ export const pinvokeVerificationSchema = z.discriminatedUnion("status", [
 export const managedNativeVerificationInputSchema = z
     .strictObject({
     managed_boundaries: evidenceSchema,
-    native_observations: z.array(evidenceSchema).min(1),
+    native_observations: z
+        .array(evidenceSchema)
+        .min(1)
+        .describe("Native function or export Evidence records"),
 })
     .superRefine((input, context) => {
     const ids = new Set();

package/dist/domain/managed/managedReconstruction.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
-import { evidenceSchema, parseEvidence } from "../evidence.js";
+import { evidenceSchema } from "../evidence.js";
 import { cliMetadataGuidSchema, managedMemberInspectionSchema, } from "./managedArtifact.js";
-import { digestSchema } from "../digests.js";
-import { prefixedDigestSchema } from "../digests.js";
+import { digestSchema, prefixedDigestSchema } from "../digests.js";
+import { parseManagedInspectionEvidence } from "./managedInspectionEvidence.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const tokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
 const textSchema = z.string().min(1);
@@ -139,7 +139,7 @@ const buildReconstructionSummary = (methods) => ({
     decompiled_csharp_methods: methods.filter(({ reconstruction }) => reconstruction.kind === "decompiled-csharp").length,
     decompiled_il_methods: methods.filter(({ reconstruction }) => reconstruction.kind === "decompiled-il").length,
     pseudocode_methods: methods.filter(({ reconstruction }) => reconstruction.kind === "semantic-pseudocode").length,
-    total_text_bytes: methods.reduce((total, { reconstruction }) => total + reconstruction.text_length, 0),
+    total_text_bytes: methods.reduce((total, { reconstruction }) => total + Buffer.byteLength(reconstruction.text, "utf8"), 0),
 });
 const buildStaticObservation = (staticEvidence, members) => ({
     evidence_id: staticEvidence.evidence_id,
@@ -173,10 +173,7 @@ const buildReconstructionWithoutId = (input, staticEvidence, members, methods) =
 });
 /** Authenticate decompiler reconstruction against static IL Evidence. */
 export const importManagedReconstruction = (input) => {
-    const staticEvidence = parseEvidence(input.static_members);
-    if (staticEvidence.operation !== "inspect_managed_members")
-        throw new TypeError("Evidence operation is not inspect_managed_members");
-    const members = managedMemberInspectionSchema.parse(staticEvidence.normalized_result);
+    const { evidence: staticEvidence, result: members } = parseManagedInspectionEvidence(input.static_members, "inspect_managed_members", managedMemberInspectionSchema);
     const methods = input.methods.map((candidate) => {
         const observed = findObservedMethod(members, candidate);
         if (observed === undefined)