rea-agents 6.1.0 → 6.2.0

package/dist/domain/evidence.js

@@ -79,6 +79,7 @@ const evidenceBaseSchema = z
     evidence_id: prefixedDigestSchema("ev"),
     subject: subjectSchema.nullable(),
     provider: providerSchema,
+    analysis_profile: analysisProfileSchema.nullable(),
     predicate_type: z.string().min(1),
     operation: z.string().min(1),
     parameters: jsonObjectSchema,
@@ -92,13 +93,10 @@ const evidenceBaseSchema = z
     evidence_links: z.array(prefixedDigestSchema("ev")),
 })
     .strict();
-/** Object envelope used to specialize caller-visible Evidence result schemas. */
-export const evidenceEnvelopeSchema = evidenceBaseSchema.extend({
-    analysis_profile: analysisProfileSchema.optional(),
-});
-const validateAnalysisProfileProvider = (evidence, context) => {
+/** Require a reported analysis profile to identify the observation provider. */
+export const validateAnalysisProfileProvider = (evidence, context) => {
     const profile = evidence.analysis_profile;
-    if (profile !== undefined &&
+    if (profile !== null &&
         (profile.provider.id !== evidence.provider.id ||
             profile.provider.name !== evidence.provider.name ||
             profile.provider.version !== evidence.provider.version))
@@ -109,15 +107,7 @@ const validateAnalysisProfileProvider = (evidence, context) => {
         });
 };
 /** Strict, provider-neutral record for one successful public observation. */
-export const evidenceSchema = evidenceEnvelopeSchema.superRefine(validateAnalysisProfileProvider);
-const profiledEvidenceSchema = evidenceBaseSchema
-    .extend({ analysis_profile: analysisProfileSchema })
-    .superRefine(validateAnalysisProfileProvider);
-/** JSON-exact union used where Evidence participates in larger schemas. */
-export const evidenceRecordSchema = z.union([
-    profiledEvidenceSchema,
-    evidenceBaseSchema,
-]);
+export const evidenceSchema = evidenceBaseSchema.superRefine(validateAnalysisProfileProvider);
 const immutableEvidenceSnapshots = new WeakMap();
 const immutableResultSchema = z
     .custom(isImmutableJsonSnapshot)
@@ -135,9 +125,7 @@ const semanticProjection = (evidence) => ({
             architecture: evidence.subject.architecture,
         },
     provider: evidence.provider,
-    ...(!("analysis_profile" in evidence)
-        ? {}
-        : { analysis_profile: evidence.analysis_profile }),
+    analysis_profile: evidence.analysis_profile,
     predicate_type: evidence.predicate_type,
     operation: evidence.operation,
     parameters: evidence.parameters,
@@ -159,13 +147,7 @@ export const parseEvidence = (input) => {
         : undefined;
     if (immutable !== undefined)
         return immutable;
-    // Select the producer's envelope before traversing its payload. A legacy
-    // record cannot satisfy the required-profile branch, whose failed parse
-    // would otherwise clone the entire normalized result before trying legacy.
-    const schema = typeof input === "object" && input !== null && "analysis_profile" in input
-        ? profiledEvidenceSchema
-        : evidenceBaseSchema;
-    const evidence = schema.parse(input);
+    const evidence = evidenceSchema.parse(input);
     const { evidence_id: evidenceId, ...withoutId } = evidence;
     if (computeEvidenceId(withoutId) !== evidenceId)
         throw new TypeError("Evidence semantic identifier does not match its record");
@@ -226,9 +208,7 @@ const normalizeEvidenceObservation = (target, provider, observation) => {
             name: provider.name,
             version: provider.version,
         },
-        ...(observation.analysisProfile === undefined
-            ? {}
-            : { analysis_profile: observation.analysisProfile }),
+        analysis_profile: observation.analysisProfile ?? null,
         predicate_type: observation.predicateType ?? "rea.analysis",
         operation: observation.operation,
         parameters: observation.parameters,
@@ -249,18 +229,12 @@ const normalizeEvidenceObservation = (target, provider, observation) => {
         locations: [...(observation.locations ?? [])],
         evidence_links: [...(observation.evidenceLinks ?? [])],
     };
-    // Select the known envelope before parsing. A union otherwise traverses and
-    // clones a legacy result for the profiled branch before rejecting its absent
-    // profile and trying the legacy branch.
-    const schema = observation.analysisProfile === undefined
-        ? evidenceBaseSchema
-        : profiledEvidenceSchema;
     const sharedResult = typeof observation.result === "object" &&
         observation.result !== null &&
         isImmutableJsonSnapshot(observation.result);
     const selectedSchema = sharedResult
-        ? schema.safeExtend({ normalized_result: immutableResultSchema })
-        : schema;
+        ? evidenceSchema.safeExtend({ normalized_result: immutableResultSchema })
+        : evidenceSchema;
     const normalized = selectedSchema.parse({
         ...semantic,
         evidence_id: `ev_${"0".repeat(64)}`,

package/dist/domain/evidenceBundle.js

@@ -1,24 +1,22 @@
 import { z } from "zod";
 import canonicalize from "canonicalize";
-import { evidenceEnvelopeSchema, evidenceRecordSchema, immutableEvidence, parseEvidence, providerSchema, } from "./evidence.js";
+import { evidenceSchema, immutableEvidence, parseEvidence, providerSchema, } from "./evidence.js";
 import { residualUnknownSchema, } from "./residualUnknown.js";
 import { freezeJsonSnapshot } from "./immutableJson.js";
-const artifactManifestSchema = evidenceEnvelopeSchema.shape.subject
-    .unwrap()
-    .pick({
+const artifactManifestSchema = evidenceSchema.shape.subject.unwrap().pick({
     digest: true,
     format: true,
     architecture: true,
 });
 const providerManifestSchema = providerSchema;
-const environmentManifestSchema = evidenceEnvelopeSchema.shape.environment.unwrap();
+const environmentManifestSchema = evidenceSchema.shape.environment.unwrap();
 const scenarioManifestSchema = z.object({
-    evidence_id: evidenceEnvelopeSchema.shape.evidence_id,
+    evidence_id: evidenceSchema.shape.evidence_id,
     operation: z.string().min(1),
     authority: z.literal("controlled-replay"),
 });
 const captureManifestSchema = z.object({
-    evidence_id: evidenceEnvelopeSchema.shape.evidence_id,
+    evidence_id: evidenceSchema.shape.evidence_id,
     predicate_type: z.string().min(1),
 });
 export const evidenceBundleSchema = z.object({
@@ -28,7 +26,7 @@ export const evidenceBundleSchema = z.object({
     scenarios: z.array(scenarioManifestSchema),
     captures: z.array(captureManifestSchema),
     unknowns: z.array(residualUnknownSchema),
-    records: z.array(evidenceRecordSchema),
+    records: z.array(evidenceSchema),
 });
 const immutableBundles = new WeakMap();
 /** Build and authenticate a sealed bundle while reusing immutable Evidence records. */
@@ -139,7 +137,7 @@ const referencedEvidenceIds = (unknown) => [
  * Evidence record, such as one command result, is not a bundle.
  */
 export const describeEvidenceBundleFailure = (input, cause) => {
-    const record = evidenceRecordSchema.safeParse(input);
+    const record = evidenceSchema.safeParse(input);
     if (record.success)
         return `Expected an Evidence bundle with records and manifest arrays, but this JSON is one Evidence record (${record.data.evidence_id}). Export a session bundle with the MCP export_evidence_bundle tool and supply that file.`;
     return cause instanceof z.ZodError

package/dist/domain/evidenceCompletionLedger.js

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
+import { IDENTIFIER_PATTERN } from "./stringPatterns.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
-const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
+const claimIdSchema = z.string().regex(IDENTIFIER_PATTERN);
 /** Terminal outcome recorded for one verifier claim. */
 export const evidenceCompletionStatusSchema = z.enum([
     "pass",

package/dist/domain/functionComparison.js

@@ -4,15 +4,14 @@ import { functionMatch } from "./functionComparisonNormalization.js";
 import { functionComparisonResultSchema, } from "./functionComparisonSchemas.js";
 import { overallStatus, summarize } from "./functionComparisonResults.js";
 import { compareDimensions } from "./functionComparisonDimensions.js";
-export { functionComparisonInputSchema, functionComparisonResultSchema, } from "./functionComparisonSchemas.js";
 /** Compare two complete function Evidence records without fuzzy matching. */
 export const compareFunctions = (leftInput, rightInput) => {
     const left = parseFunctionEvidence(leftInput);
     const right = parseFunctionEvidence(rightInput);
-    const links = [left.evidence[0].evidence_id, right.evidence[0].evidence_id];
-    const providersDiffer = canonicalJson(left.provider, "Function comparison") !==
-        canonicalJson(right.provider, "Function comparison");
-    const dimensions = compareDimensions(left, right, links, providersDiffer);
+    const links = [left.evidence.evidence_id, right.evidence.evidence_id];
+    const providersDiffer = canonicalJson(left.evidence.provider, "Function comparison") !==
+        canonicalJson(right.evidence.provider, "Function comparison");
+    const dimensions = compareDimensions(left, right, { links, providersDiffer });
     const match = functionMatch(left, right);
     const changes = dimensions.filter(({ status }) => status !== "unchanged");
     return functionComparisonResultSchema.parse({

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";
 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,21 +136,8 @@ 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) => compareCodePoints(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);
 const parseAddress = (value) => /^0x[0-9a-f]+$/iu.test(value) ? BigInt(value) : null;
 const relativeAddress = (value, base) => {

package/dist/domain/functionComparisonResults.js

@@ -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");

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),