rea-agents 6.1.0 → 6.3.0

package/dist/domain/functionComparisonDimensions.js

@@ -1,40 +1,50 @@
 import { canonicalJson } from "./comparisonSemantics.js";
 import { diffLines } from "diff";
-import { commentProjection, combineCoverage, identityProjection, isAutoName, normalizeCfg, project, referenceKindProjection, referenceProjection, sorted, stringAndNameProjection, } from "./functionComparisonNormalization.js";
-import { dimensionResult, unresolvedDimension as buildUnresolvedDimension, } from "./functionComparisonResults.js";
-const unresolvedDimension = (...[dimension, status, links, leftCount, rightCount, limitations]) => buildUnresolvedDimension({
-    dimension,
-    status,
-    links,
-    leftCount,
-    rightCount,
-    limitations,
-});
-export const compareDimensions = (left, right, links, providersDiffer) => [
-    compareIdentity(left, right, links, providersDiffer),
-    compareText("pseudocode", left.pseudocode.text, right.pseudocode.text, left.pseudocode.complete, right.pseudocode.complete, links, providersDiffer),
-    compareText("assembly", left.collections.assembly.items.join("\n"), right.collections.assembly.items.join("\n"), left.collections.assembly.complete, right.collections.assembly.complete, links, providersDiffer, left.collections.assembly.truncated || right.collections.assembly.truncated, "Assembly is opaque provider text; relocation normalization is unavailable."),
-    compareComments(left, right, links, providersDiffer),
-    compareCalls(left, right, links, providersDiffer),
-    compareReferences(left, right, links, providersDiffer),
-    compareStringsAndNames(left, right, links, providersDiffer),
-    compareCfg(left, right, links, providersDiffer),
-];
-const compareText = (...[dimension, left, right, leftComplete, rightComplete, links, providersDiffer, explicitTruncation, limitation,]) => {
-    const truncated = explicitTruncation ?? (!leftComplete || !rightComplete);
-    if (!leftComplete || !rightComplete || providersDiffer)
-        return unresolvedDimension(dimension, truncated ? "truncated" : "unknown", links, left.length, right.length, [
-            ...(limitation === undefined ? [] : [limitation]),
-            ...(providersDiffer
-                ? ["Exact text comparison requires one provider identity."]
-                : []),
-        ]);
+import { commentProjection, identityProjection, isAutoName, normalizeCfg, referenceKindProjection, referenceProjection, sorted, stringAndNameProjection, } from "./functionComparisonNormalization.js";
+import { dimensionResult, unresolvedDimension, } from "./functionComparisonResults.js";
+export const compareDimensions = (left, right, context) => {
+    return [
+        compareIdentity(left, right, context),
+        compareText("pseudocode", left.dossier.pseudocode, right.dossier.pseudocode, context),
+        compareText("assembly", left.dossier.assembly.join("\n"), right.dossier.assembly.join("\n"), context),
+        compareComments(left, right, context),
+        compareCalls(left, right, context),
+        compareReferences(left, right, context),
+        compareStringsAndNames(left, right, context),
+        compareCfg(left, right, context),
+    ];
+};
+const compareText = (dimension, left, right, context) => {
+    const limitations = dimension === "assembly"
+        ? [
+            "Assembly is opaque provider text; relocation normalization is unavailable.",
+        ]
+        : [];
+    if (context.providersDiffer)
+        return unresolvedDimension({
+            dimension,
+            links: context.links,
+            leftCount: [...left].length,
+            rightCount: [...right].length,
+            limitations: [
+                ...limitations,
+                "Exact text comparison requires one provider identity.",
+            ],
+        });
     const changes = diffLines(left, right, {
         timeout: 100,
         maxEditLength: 10_000,
     });
     if (changes === undefined)
-        return unresolvedDimension(dimension, "unknown", links, left.length, right.length, ["Bounded line diff exceeded its time or edit-distance limit."]);
+        return unresolvedDimension({
+            dimension,
+            links: context.links,
+            leftCount: [...left].length,
+            rightCount: [...right].length,
+            limitations: [
+                "Bounded line diff exceeded its time or edit-distance limit.",
+            ],
+        });
     const delta = changes.reduce((summary, change) => ({
         added_lines: summary.added_lines + (change.added ? (change.count ?? 0) : 0),
         removed_lines: summary.removed_lines + (change.removed ? (change.count ?? 0) : 0),
@@ -45,48 +55,48 @@ const compareText = (...[dimension, left, right, leftComplete, rightComplete, li
         status: delta.hunks === 0 ? "unchanged" : "changed",
         left,
         right,
-        links,
-        providersDiffer,
+        ...context,
         leftCount: [...left].length,
         rightCount: [...right].length,
         textDelta: delta,
-        limitations: limitation === undefined ? [] : [limitation],
+        limitations,
     });
 };
-const compareCollections = (...[dimension, left, right, leftCoverage, rightCoverage, links, providersDiffer,]) => {
-    if (!leftCoverage.complete || !rightCoverage.complete)
-        return unresolvedDimension(dimension, leftCoverage.truncated || rightCoverage.truncated
-            ? "truncated"
-            : "unknown", links, left.length, right.length, []);
-    return compareValues(dimension, sorted(left), sorted(right), links, true, true, providersDiffer);
-};
-const compareComments = (left, right, links, providersDiffer) => {
+const compareComments = (left, right, context) => {
     const leftValues = commentProjection(left);
     const rightValues = commentProjection(right);
     if (leftValues === null || rightValues === null)
-        return unresolvedDimension("comments", "unknown", links, left.collections.comments.items.length, right.collections.comments.items.length, ["Comment locations could not be normalized relative to the function."]);
-    return compareCollections("comments", leftValues, rightValues, left.collections.comments, right.collections.comments, links, providersDiffer);
+        return unresolvedDimension({
+            dimension: "comments",
+            links: context.links,
+            leftCount: left.dossier.comments.length,
+            rightCount: right.dossier.comments.length,
+            limitations: [
+                "Comment locations could not be normalized relative to the function.",
+            ],
+        });
+    return compareValues("comments", leftValues, rightValues, context);
 };
-const compareStringsAndNames = (left, right, links, providersDiffer) => {
+const compareStringsAndNames = (left, right, context) => {
     const leftValues = stringAndNameProjection(left);
     const rightValues = stringAndNameProjection(right);
     if (leftValues === null || rightValues === null)
-        return unresolvedDimension("strings_names", "unknown", links, null, null, [
-            "Reference source locations could not be normalized to function offsets.",
-        ]);
-    return compareCollections("strings_names", leftValues, rightValues, combineCoverage(left.collections.referenced_strings, left.collections.referenced_names), combineCoverage(right.collections.referenced_strings, right.collections.referenced_names), links, providersDiffer);
+        return unresolvedDimension({
+            dimension: "strings_names",
+            links: context.links,
+            leftCount: null,
+            rightCount: null,
+            limitations: [
+                "Reference source locations could not be normalized to function offsets.",
+            ],
+        });
+    return compareValues("strings_names", leftValues, rightValues, context);
 };
-const compareReferences = (left, right, links, providersDiffer) => {
-    const leftCoverage = combineCoverage(left.collections.incoming_references, left.collections.outgoing_references);
-    const rightCoverage = combineCoverage(right.collections.incoming_references, right.collections.outgoing_references);
-    if (!leftCoverage.complete || !rightCoverage.complete)
-        return unresolvedDimension("references", leftCoverage.truncated || rightCoverage.truncated
-            ? "truncated"
-            : "unknown", links, leftCoverage.items.length, rightCoverage.items.length, []);
+const compareReferences = (left, right, context) => {
     const leftProjection = referenceProjection(left);
     const rightProjection = referenceProjection(right);
     if (leftProjection.length === 0 && rightProjection.length === 0)
-        return compareValues("references", leftProjection, rightProjection, links, true, true, providersDiffer);
+        return compareValues("references", leftProjection, rightProjection, context);
     if (canonicalJson(leftProjection, "Function comparison") !==
         canonicalJson(rightProjection, "Function comparison"))
         return dimensionResult({
@@ -94,8 +104,7 @@ const compareReferences = (left, right, links, providersDiffer) => {
             status: "changed",
             left: leftProjection,
             right: rightProjection,
-            links,
-            providersDiffer,
+            ...context,
             leftCount: leftProjection.length,
             rightCount: rightProjection.length,
             textDelta: null,
@@ -106,49 +115,74 @@ const compareReferences = (left, right, links, providersDiffer) => {
     const leftKinds = referenceKindProjection(left);
     const rightKinds = referenceKindProjection(right);
     if (leftKinds !== null && rightKinds !== null)
-        return compareValues("references", leftKinds, rightKinds, links, true, true, providersDiffer);
-    return unresolvedDimension("references", "unknown", links, leftProjection.length, rightProjection.length, [
-        "At least one provider did not expose reference kinds, so equal endpoints do not prove equal edge semantics.",
-    ]);
+        return compareValues("references", leftKinds, rightKinds, context);
+    return unresolvedDimension({
+        dimension: "references",
+        links: context.links,
+        leftCount: leftProjection.length,
+        rightCount: rightProjection.length,
+        limitations: [
+            "At least one provider did not expose reference kinds, so equal endpoints do not prove equal edge semantics.",
+        ],
+    });
 };
-const compareIdentity = (left, right, links, providersDiffer) => {
-    if (isAutoName(left.procedure.name) || isAutoName(right.procedure.name))
-        return unresolvedDimension("identity", "unknown", links, null, null, [
-            "Address-derived function names are not stable cross-version identity.",
-        ]);
-    return compareValues("identity", identityProjection(left), identityProjection(right), links, true, true, providersDiffer);
+const compareIdentity = (left, right, context) => {
+    if (isAutoName(left.dossier.procedure.name) ||
+        isAutoName(right.dossier.procedure.name))
+        return unresolvedDimension({
+            dimension: "identity",
+            links: context.links,
+            leftCount: null,
+            rightCount: null,
+            limitations: [
+                "Address-derived function names are not stable cross-version identity.",
+            ],
+        });
+    return compareValues("identity", identityProjection(left), identityProjection(right), context);
 };
-const compareCalls = (left, right, links, providersDiffer) => {
+const compareCalls = (left, right, context) => {
     const leftValues = callProjection(left);
     const rightValues = callProjection(right);
     if ([...leftValues, ...rightValues].some(({ name }) => isAutoName(name)))
-        return unresolvedDimension("calls", "unknown", links, leftValues.length, rightValues.length, ["Address-derived callee or caller names cannot be matched safely."]);
-    return compareCollections("calls", leftValues, rightValues, combineCoverage(left.collections.callers, left.collections.callees), combineCoverage(right.collections.callers, right.collections.callees), links, providersDiffer);
+        return unresolvedDimension({
+            dimension: "calls",
+            links: context.links,
+            leftCount: leftValues.length,
+            rightCount: rightValues.length,
+            limitations: [
+                "Address-derived callee or caller names cannot be matched safely.",
+            ],
+        });
+    return compareValues("calls", sorted(leftValues), sorted(rightValues), context);
 };
 const callProjection = (snapshot) => [
-    ...project(snapshot.collections.callers, ({ name }) => ({
+    ...snapshot.dossier.callers.map(({ name }) => ({
         direction: "in",
         name,
     })),
-    ...project(snapshot.collections.callees, ({ name }) => ({
+    ...snapshot.dossier.callees.map(({ name }) => ({
         direction: "out",
         name,
     })),
 ];
-const compareCfg = (left, right, links, providersDiffer) => {
-    const leftBlocks = left.collections.basic_blocks;
-    const rightBlocks = right.collections.basic_blocks;
-    if (!leftBlocks.complete || !rightBlocks.complete)
-        return unresolvedDimension("cfg", leftBlocks.truncated || rightBlocks.truncated ? "truncated" : "unknown", links, leftBlocks.items.length, rightBlocks.items.length, []);
-    const leftGraph = normalizeCfg(leftBlocks.items);
-    const rightGraph = normalizeCfg(rightBlocks.items);
+const compareCfg = (left, right, context) => {
+    const leftBlocks = left.dossier.basic_blocks;
+    const rightBlocks = right.dossier.basic_blocks;
+    const leftGraph = normalizeCfg(leftBlocks);
+    const rightGraph = normalizeCfg(rightBlocks);
     if (leftGraph === null || rightGraph === null)
-        return unresolvedDimension("cfg", "unknown", links, leftBlocks.items.length, rightBlocks.items.length, ["CFG addresses could not be normalized to local block indices."]);
-    return compareValues("cfg", leftGraph, rightGraph, links, true, true, providersDiffer);
+        return unresolvedDimension({
+            dimension: "cfg",
+            links: context.links,
+            leftCount: leftBlocks.length,
+            rightCount: rightBlocks.length,
+            limitations: [
+                "CFG addresses could not be normalized to local block indices.",
+            ],
+        });
+    return compareValues("cfg", leftGraph, rightGraph, context);
 };
-const compareValues = (...[dimension, left, right, links, leftComplete, rightComplete, providersDiffer,]) => {
-    if (!leftComplete || !rightComplete)
-        return unresolvedDimension(dimension, "unknown", links, null, null, []);
+const compareValues = (dimension, left, right, context) => {
     const leftJson = canonicalJson(left, "Function comparison");
     const rightJson = canonicalJson(right, "Function comparison");
     return dimensionResult({
@@ -156,8 +190,7 @@ const compareValues = (...[dimension, left, right, links, leftComplete, rightCom
         status: leftJson === rightJson ? "unchanged" : "changed",
         left,
         right,
-        links,
-        providersDiffer,
+        ...context,
         leftCount: Array.isArray(left) ? left.length : null,
         rightCount: Array.isArray(right) ? right.length : null,
         textDelta: null,

package/dist/domain/functionComparisonNormalization.js

@@ -1,26 +1,28 @@
 import { canonicalJson } from "./comparisonSemantics.js";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 export const identityProjection = (snapshot) => ({
-    name: snapshot.procedure.name,
-    signature: snapshot.procedure.signature,
-    locals: snapshot.procedure.locals
+    name: snapshot.dossier.procedure.name,
+    signature: snapshot.dossier.procedure.signature,
+    locals: snapshot.dossier.procedure.locals
         .map(({ description }) => description)
         .sort(),
 });
 export const functionMatch = (left, right) => {
-    if (!isAutoName(left.procedure.name) &&
-        left.procedure.name === right.procedure.name)
+    if (!isAutoName(left.dossier.procedure.name) &&
+        left.dossier.procedure.name === right.dossier.procedure.name)
         return {
             status: "matched",
             method: "symbol",
-            left_name: left.procedure.name,
-            right_name: right.procedure.name,
+            left_name: left.dossier.procedure.name,
+            right_name: right.dossier.procedure.name,
         };
     return {
-        status: left.procedure.name === right.procedure.name ? "ambiguous" : "mismatched",
+        status: left.dossier.procedure.name === right.dossier.procedure.name
+            ? "ambiguous"
+            : "mismatched",
         method: "explicit",
-        left_name: left.procedure.name,
-        right_name: right.procedure.name,
+        left_name: left.dossier.procedure.name,
+        right_name: right.dossier.procedure.name,
     };
 };
 export const normalizeCfg = (blocks) => {
@@ -56,12 +58,12 @@ export const normalizeCfg = (blocks) => {
     return graph;
 };
 export const referenceProjection = (snapshot) => sorted([
-    ...snapshot.collections.incoming_references.items.map((item) => ({
+    ...snapshot.dossier.incoming_references.map((item) => ({
         direction: "in",
         source: item.source_procedure?.name ?? null,
         target: item.target_procedure?.name ?? null,
     })),
-    ...snapshot.collections.outgoing_references.items.map((item) => ({
+    ...snapshot.dossier.outgoing_references.map((item) => ({
         direction: "out",
         source: item.source_procedure?.name ?? null,
         target: item.target_procedure?.name ?? null,
@@ -69,11 +71,11 @@ export const referenceProjection = (snapshot) => sorted([
 ]);
 export const referenceKindProjection = (snapshot) => {
     const edges = [
-        ...snapshot.collections.incoming_references.items.map((edge) => ({
+        ...snapshot.dossier.incoming_references.map((edge) => ({
             direction: "in",
             edge,
         })),
-        ...snapshot.collections.outgoing_references.items.map((edge) => ({
+        ...snapshot.dossier.outgoing_references.map((edge) => ({
             direction: "out",
             edge,
         })),
@@ -105,8 +107,8 @@ export const referenceKindProjection = (snapshot) => {
     }));
 };
 export const commentProjection = (snapshot) => {
-    const values = snapshot.collections.comments.items.map(({ address, kind, text }) => ({
-        offset: relativeAddress(address, snapshot.procedure.address),
+    const values = snapshot.dossier.comments.map(({ address, kind, text }) => ({
+        offset: relativeAddress(address, snapshot.dossier.procedure.address),
         kind,
         text,
     }));
@@ -114,14 +116,14 @@ export const commentProjection = (snapshot) => {
 };
 export const stringAndNameProjection = (snapshot) => {
     const values = [
-        ...snapshot.collections.referenced_strings.items.map(({ source_address: sourceAddress, value }) => ({
+        ...snapshot.dossier.referenced_strings.map(({ source_address: sourceAddress, value }) => ({
             kind: "string",
-            source_offset: relativeAddress(sourceAddress, snapshot.procedure.address),
+            source_offset: relativeAddress(sourceAddress, snapshot.dossier.procedure.address),
             value,
         })),
-        ...snapshot.collections.referenced_names.items.map(({ source_address: sourceAddress, value }) => ({
+        ...snapshot.dossier.referenced_names.map(({ source_address: sourceAddress, value }) => ({
             kind: "name",
-            source_offset: relativeAddress(sourceAddress, snapshot.procedure.address),
+            source_offset: relativeAddress(sourceAddress, snapshot.dossier.procedure.address),
             value,
         })),
     ];
@@ -134,22 +136,10 @@ export const sorted = (values) => values
     value,
     json: canonicalJson(value, "Function normalization"),
 }))
-    .sort((left, right) => {
-    // Preserve existing collation while ordering distinct values within a tie.
-    return (left.json.localeCompare(right.json) ||
-        compareCodePoints(left.json, right.json));
-})
+    .sort((left, right) => compareUnicodeCodePoints(left.json, right.json))
     .map(({ value }) => value);
-export const combineCoverage = (left, right) => {
-    return {
-        items: [...left.items, ...right.items],
-        total: left.total + right.total,
-        complete: true,
-        truncated: false,
-    };
-};
-export const project = (collection, mapper) => collection.items.map(mapper);
-export const isAutoName = (name) => /^(?:sub_[0-9a-f]+|fcn\.[0-9a-f]+)$/iu.test(name);
+/** Recognize address-derived procedure names without excluding named FUN_ symbols. */
+export const isAutoName = (name) => /^(?:sub_[0-9a-f]+|fcn\.[0-9a-f]+|FUN_[0-9a-f]+)$/iu.test(name);
 const parseAddress = (value) => /^0x[0-9a-f]+$/iu.test(value) ? BigInt(value) : null;
 const relativeAddress = (value, base) => {
     const parsed = parseAddress(value);

package/dist/domain/functionComparisonResults.js

@@ -1,4 +1,4 @@
-import { canonicalDigest } from "./comparisonSemantics.js";
+import { digestCanonicalValue } from "./canonicalDigest.js";
 export const dimensionResult = (input) => {
     const context = {
         dimension: input.dimension,
@@ -26,7 +26,7 @@ export const dimensionResult = (input) => {
 };
 export const unresolvedDimension = (input) => ({
     dimension: input.dimension,
-    status: input.status,
+    status: "unknown",
     left_digest: null,
     right_digest: null,
     left_count: input.leftCount,
@@ -37,8 +37,6 @@ export const unresolvedDimension = (input) => ({
     limitations: [...input.limitations],
 });
 export const overallStatus = (dimensions, match) => {
-    if (dimensions.some(({ status }) => status === "truncated"))
-        return "truncated";
     if (match === "ambiguous" ||
         dimensions.some(({ status }) => status === "unknown"))
         return "unknown";
@@ -51,7 +49,6 @@ export const overallStatus = (dimensions, match) => {
 export const summarize = (dimensions) => ({
     unchanged: dimensions.filter(({ status }) => status === "unchanged").length,
     changed: dimensions.filter(({ status }) => status === "changed").length,
-    truncated: dimensions.filter(({ status }) => status === "truncated").length,
     unknown: dimensions.filter(({ status }) => status === "unknown").length,
 });
-const digest = (value) => canonicalDigest(value, "Function comparison");
+const digest = (value) => digestCanonicalValue(value, "Function comparison");

package/dist/domain/functionComparisonSchemas.js

@@ -2,12 +2,7 @@ import { z } from "zod";
 import { evidenceSchema } from "./evidence.js";
 import { digestSchema } from "./../domain/digests.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
-const comparisonStatusSchema = z.enum([
-    "unchanged",
-    "changed",
-    "truncated",
-    "unknown",
-]);
+const comparisonStatusSchema = z.enum(["unchanged", "changed", "unknown"]);
 const dimensionNameSchema = z.enum([
     "identity",
     "pseudocode",
@@ -55,7 +50,7 @@ const functionDimensionSchema = z.union([
     }),
     z.object({
         ...functionDimensionContextShape,
-        status: z.enum(["truncated", "unknown"]),
+        status: z.literal("unknown"),
         left_digest: z.null(),
         right_digest: z.null(),
         text_delta: z.null(),
@@ -85,7 +80,6 @@ export const functionComparisonResultSchema = z.object({
     summary: z.object({
         unchanged: z.number().int().min(0),
         changed: z.number().int().min(0),
-        truncated: z.number().int().min(0),
         unknown: z.number().int().min(0),
     }),
     dimensions: z.array(functionDimensionSchema).length(8),

package/dist/domain/functionDossierEvidence.js

@@ -1,16 +1,6 @@
 import { parseEvidence } from "./evidence.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 import { functionDossierSchema } from "./hopperValues.js";
-const DOSSIER_COLLECTION_FIELDS = [
-    "assembly",
-    "comments",
-    "callers",
-    "callees",
-    "incoming_references",
-    "outgoing_references",
-    "referenced_strings",
-    "referenced_names",
-    "basic_blocks",
-];
 /** Parse one complete analyze_function Evidence record for comparison workflows. */
 export const parseFunctionEvidence = (input) => {
     const evidence = parseEvidence(input);
@@ -20,35 +10,11 @@ export const parseFunctionEvidence = (input) => {
         throw new TypeError("Function comparison requires artifact-bound Evidence");
     const dossier = functionDossierSchema.parse(evidence.normalized_result);
     return {
-        evidence: [evidence],
-        procedure: dossier.procedure,
-        provider: evidence.provider,
+        evidence,
         subject: evidence.subject,
-        pseudocode: {
-            text: dossier.pseudocode,
-            total: [...dossier.pseudocode].length,
-            complete: true,
-            truncated: false,
-        },
-        collections: {
-            assembly: completeCollection(dossier.assembly),
-            comments: completeCollection(dossier.comments),
-            callers: completeCollection(dossier.callers),
-            callees: completeCollection(dossier.callees),
-            incoming_references: completeCollection(dossier.incoming_references),
-            outgoing_references: completeCollection(dossier.outgoing_references),
-            referenced_strings: completeCollection(dossier.referenced_strings),
-            referenced_names: completeCollection(dossier.referenced_names),
-            basic_blocks: completeCollection(dossier.basic_blocks),
-        },
+        dossier,
         limitations: [
             ...new Set([...evidence.limitations, ...dossier.limitations]),
-        ].sort((left, right) => left.localeCompare(right)),
+        ].sort((left, right) => compareUnicodeCodePoints(left, right)),
     };
 };
-const completeCollection = (items) => ({
-    items,
-    total: items.length,
-    complete: true,
-    truncated: false,
-});

package/dist/domain/hopperValues.js

@@ -29,12 +29,12 @@ const procedureMapSchema = z.record(z.string(), z.string());
 const addressedNamesSchema = z.array(z.object({ address: z.string(), name: z.string() }));
 const addressedNameMapSchema = z.record(z.string(), z.string());
 const segmentSchema = z.object({
-    name: z.string().default(""),
-    start: z.string().default(""),
-    end: z.string().default(""),
-    readable: z.boolean().nullable().default(null),
-    writable: z.boolean().nullable().default(null),
-    executable: z.boolean().nullable().default(null),
+    name: z.string(),
+    start: z.string(),
+    end: z.string(),
+    readable: z.boolean().nullable(),
+    writable: z.boolean().nullable(),
+    executable: z.boolean().nullable(),
 });
 const unavailableAnalysisFactSchema = z
     .object({ available: z.literal(false), reason: z.string() })
@@ -142,10 +142,6 @@ export const functionBodySchema = z.discriminatedUnion("available", [
             });
     }),
 ]);
-const unknownFunctionBody = () => functionBodySchema.default({
-    available: false,
-    reason: "The provider did not report complete function body ranges.",
-});
 /** Check the declared entry membership against complete, inclusive body ranges. */
 export const functionBodyEntryAgrees = (body, address) => {
     if (!body.available)
@@ -176,8 +172,8 @@ export const procedureIdentitySchema = z
     .object({
     address: z.string(),
     name: z.string(),
-    classification: procedureClassificationSchema.nullable().default(null),
-    body: unknownFunctionBody(),
+    classification: procedureClassificationSchema.nullable(),
+    body: functionBodySchema,
 })
     .strict()
     .superRefine((identity, context) => {
@@ -289,9 +285,9 @@ export const functionDossierSchema = z
         successors: z.array(z.string()),
     })
         .strict()),
-    native_api: nativeApiBoundarySchema.nullable().default(null),
-    native_value_flow: nativeValueFlowSchema.nullable().default(null),
-    limitations: z.array(z.string()).default([]),
+    native_api: nativeApiBoundarySchema.nullable(),
+    native_value_flow: nativeValueFlowSchema.nullable(),
+    limitations: z.array(z.string()),
 })
     .strict();
 /** Strictly parse a complete provider-neutral function dossier. */