rea-agents 0.2.1 → 0.4.0

package/dist/contracts/toolOutputSchemas.js

@@ -1,21 +1,90 @@
 import { z } from "zod";
 import { evidenceSchema } from "../domain/evidence.js";
-import { processCaptureSchema } from "../domain/processCapture.js";
+import { processCaptureComparisonSchema, processCaptureSchema, } from "../domain/processCapture.js";
 import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
-const resultOf = (schema) => evidenceSchema.omit({ result: true }).extend({ result: schema });
+import { residualUnknownSchema } from "../domain/residualUnknown.js";
+import { functionDossierSchema } from "../domain/hopperValues.js";
+import { demangleSwiftSchema, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/nativeInspection.js";
+import { artifactExtractionResultSchema, artifactInventoryResultSchema, } from "../domain/artifactGraph.js";
+import { artifactComparisonResultSchema } from "../domain/artifactComparison.js";
+import { functionComparisonResultSchema } from "../domain/functionComparison.js";
+import { bundleComparisonResultSchema } from "../domain/bundleComparison.js";
+import { changedBehaviorResultSchema } from "../domain/changedBehavior.js";
+import { callPathResultSchema } from "../domain/callPath.js";
+import { staticRuntimeCorrelationResultSchema } from "../domain/staticRuntimeCorrelation.js";
+import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerification.js";
+const resultOf = (schema) => evidenceSchema
+    .omit({ normalized_result: true })
+    .extend({ normalized_result: schema });
 const lifecycleResultOf = (schema) => z.object({ result: schema });
-const comparisonStatus = z.enum([
-    "unchanged",
-    "added",
-    "removed",
-    "changed",
-    "truncated",
-    "unknown",
+/** Resolve a required named output schema or reject contract drift. */
+export const requireOutputSchema = (schemas, name) => {
+    const schema = schemas[name];
+    if (schema === undefined)
+        throw new Error(`Missing output schema for ${name}`);
+    return schema;
+};
+const targetFormatSchema = z.enum([
+    "hopper",
+    "mach-o",
+    "elf",
+    "pe",
+    "zip",
+    "ipa",
+    "apk",
+    "asar",
+    "dmg",
+    "pkg",
+    "plist",
+    "javascript",
+    "source-map",
+]);
+const targetKindSchema = z.enum([
+    "executable",
+    "database",
+    "archive",
+    "artifact",
 ]);
+const providerCapability = z.object({
+    operation: z.string(),
+    available: z.boolean(),
+    reason: z.string().nullable(),
+    input_contract_version: z.number().int().min(1),
+    output_contract_version: z.number().int().min(1),
+    pagination: z.enum(["none", "offset", "cursor"]),
+    exhaustive: z.boolean(),
+    effects: z.object({
+        mutates_artifact: z.boolean(),
+        launches_process: z.boolean(),
+        may_show_ui: z.boolean(),
+        may_access_network: z.boolean(),
+        may_write_filesystem: z.boolean(),
+        changes_permissions: z.boolean(),
+        requires_root: z.boolean(),
+    }),
+    limits: z.object({
+        max_results: z.number().int().min(0).nullable(),
+        max_payload_bytes: z.number().int().min(0).nullable(),
+        timeout_ms: z.number().int().min(0).nullable(),
+    }),
+    limitations: z.array(z.string()),
+});
+const sessionProvider = z.object({
+    provider: z.object({
+        id: z.string(),
+        name: z.string(),
+        version: z.string().nullable(),
+    }),
+    capabilities: z.array(providerCapability),
+});
 const nullableText = z.string().nullable();
 const addressList = z.array(z.string());
 const addressedEntry = z.object({ address: z.string(), name: z.string() });
 const procedureIdentity = z.object({ address: z.string(), name: z.string() });
+const localVariable = z.object({
+    description: z.string(),
+    provenance: z.literal("hopper-public-python-api"),
+});
 const containingProcedureResolution = z.discriminatedUnion("found", [
     z.object({
         query_address: z.string(),
@@ -48,22 +117,31 @@ const pageOutput = z.object({
     next_offset: z.number().int().min(0).nullable(),
     has_more: z.boolean(),
 });
-const segmentOutput = resultOf(z.array(z.object({
+const searchPageOutput = pageOutput.extend({
+    items: z.array(z.object({
+        address: z.string(),
+        value: z.string(),
+        value_truncated: z.boolean(),
+    })),
+});
+const memoryRegionOutput = z.object({
     name: z.string(),
     start: z.string(),
     end: z.string(),
+    readable: z.boolean().nullable(),
     writable: z.boolean().nullable(),
     executable: z.boolean().nullable(),
     permissions: unavailable,
-    sections: z.array(z.object({ name: z.string(), start: z.string(), end: z.string() })),
-})));
+    provenance: z.literal("hopper-public-python-api"),
+});
+const segmentOutput = resultOf(z.array(memoryRegionOutput.extend({ sections: z.array(memoryRegionOutput) })));
 const procedureInfoOutput = resultOf(z.object({
     name: z.string(),
     entrypoint: z.string(),
     basicblock_count: z.number().int().min(0),
     length: z.number().min(0),
     signature: nullableText,
-    locals: z.array(z.json()),
+    locals: z.array(localVariable),
 }));
 const symbolDiscoveryOutput = (property) => resultOf(z.object({
     count: z.number().int().min(0),
@@ -73,54 +151,7 @@ const graphNode = z.union([
     z.object({ address: z.string(), calls: z.array(z.string()) }),
     z.object({ address: z.string(), error: z.string() }),
 ]);
-const referenceEdge = z.object({
-    source_address: z.string(),
-    target_address: z.string(),
-    source_procedure: procedureIdentity.nullable(),
-    target_procedure: procedureIdentity.nullable(),
-    kind: unavailable,
-});
-const referencedValue = z.object({
-    address: z.string(),
-    value: z.string(),
-    source_address: z.string(),
-});
-const functionDossierOutput = resultOf(z.object({
-    procedure: z.object({
-        address: z.string(),
-        name: z.string(),
-        signature: nullableText,
-        locals: z.array(z.json()),
-    }),
-    pseudocode: z.object({
-        text: z.string(),
-        total_chars: z.number().int().min(0),
-        returned_chars: z.number().int().min(0),
-        truncated: z.boolean(),
-        next_offset: z.number().int().min(0).nullable(),
-    }),
-    assembly: bounded(z.string()),
-    comments: bounded(z.object({
-        address: z.string(),
-        kind: z.enum(["comment", "inline"]),
-        text: z.string(),
-    })),
-    callers: bounded(procedureIdentity),
-    callees: bounded(procedureIdentity),
-    incoming_references: bounded(referenceEdge),
-    outgoing_references: bounded(referenceEdge),
-    referenced_strings: bounded(referencedValue),
-    referenced_names: bounded(referencedValue),
-    basic_blocks: bounded(z.object({
-        start: z.string(),
-        end: z.string(),
-        successors: z.array(z.string()),
-    })),
-    instruction_scan: z.object({
-        scanned: z.number().int().min(0),
-        truncated: z.boolean(),
-    }),
-}));
+const functionDossierOutput = resultOf(functionDossierSchema);
 /** Exact structured-content schemas for the direct Hopper operations. */
 export const officialOutputSchemas = {
     address_name: resultOf(nullableText),
@@ -158,8 +189,8 @@ export const officialOutputSchemas = {
     })),
     procedure_pseudo_code: resultOf(nullableText),
     resolve_containing_procedure: resultOf(containingProcedureResolution),
-    search_procedures: resultOf(z.record(z.string(), z.string())),
-    search_strings: resultOf(z.record(z.string(), z.string())),
+    search_procedures: resultOf(searchPageOutput),
+    search_strings: resultOf(searchPageOutput),
     set_address_name: resultOf(z.boolean()),
     set_addresses_names: resultOf(z.record(z.string(), z.boolean())),
     set_bookmark: resultOf(z.boolean()),
@@ -223,45 +254,86 @@ export const enhancedOutputSchemas = {
         residual_unknowns: z.array(z.string()),
     })),
 };
+/** Exact Evidence v2 schemas for provider-neutral native inspection. */
+export const nativeOutputSchemas = {
+    inspect_macho: resultOf(inspectMachoSchema),
+    inspect_signature: resultOf(inspectSignatureSchema),
+    inspect_plist: resultOf(inspectPlistSchema),
+    list_architectures: resultOf(listArchitecturesSchema),
+    demangle_swift: resultOf(demangleSwiftSchema),
+};
+/** Exact Evidence v2 schemas for provider-neutral artifact graph operations. */
+export const artifactOutputSchemas = {
+    inventory_artifact: resultOf(artifactInventoryResultSchema),
+    extract_artifact: resultOf(artifactExtractionResultSchema),
+};
 /** Exact structured-content schemas for target lifecycle operations. */
 export const sessionOutputSchemas = {
     open_binary: lifecycleResultOf(z.object({
         path: z.string(),
-        format: z.enum(["hopper", "mach-o", "elf", "pe"]),
-        kind: z.enum(["executable", "database"]),
+        format: targetFormatSchema,
+        kind: targetKindSchema,
         loaderArgs: z.array(z.string()),
         sha256: z.string().regex(/^[a-f0-9]{64}$/u),
         architecture: z.enum(["x86", "x86_64", "arm", "arm64"]).nullable(),
     })),
     close_binary: lifecycleResultOf(z.null()),
     binary_session: lifecycleResultOf(z.union([
-        z.object({ open: z.literal(false) }),
-        z.object({
+        sessionProvider.extend({ open: z.literal(false) }),
+        sessionProvider.extend({
             open: z.literal(true),
             path: z.string(),
-            format: z.enum(["hopper", "mach-o", "elf", "pe"]),
-            kind: z.enum(["executable", "database"]),
+            format: targetFormatSchema,
+            kind: targetKindSchema,
             sha256: z.string().regex(/^[a-f0-9]{64}$/u),
             architecture: z.enum(["x86", "x86_64", "arm", "arm64"]).nullable(),
         }),
     ])),
-    export_evidence_bundle: lifecycleResultOf(evidenceBundleSchema),
+    export_evidence_bundle: lifecycleResultOf(z.union([
+        evidenceBundleSchema,
+        z.object({
+            path: z.string(),
+            bytes: z.number().int().min(0),
+            records: z.number().int().min(0),
+        }),
+    ])),
     import_evidence_bundle: lifecycleResultOf(z.object({
         imported: z.number().int().min(0),
         total: z.number().int().min(0),
     })),
     capture_process_scenario: lifecycleResultOf(evidenceSchema
-        .omit({ result: true })
-        .extend({ result: processCaptureSchema })),
-    compare_process_captures: lifecycleResultOf(evidenceSchema.omit({ result: true }).extend({
-        result: z.object({
-            status: comparisonStatus,
-            terminal: comparisonStatus,
-            exit: comparisonStatus,
-            filesystem: comparisonStatus,
-            protocol: comparisonStatus,
-            process: comparisonStatus,
-            limitations: z.array(z.string()),
-        }),
+        .omit({ normalized_result: true })
+        .extend({ normalized_result: processCaptureSchema })),
+    compare_process_captures: lifecycleResultOf(evidenceSchema.omit({ normalized_result: true }).extend({
+        normalized_result: processCaptureComparisonSchema,
+    })),
+    compare_artifacts: lifecycleResultOf(evidenceSchema.omit({ normalized_result: true }).extend({
+        normalized_result: artifactComparisonResultSchema,
+    })),
+    compare_functions: lifecycleResultOf(evidenceSchema.omit({ normalized_result: true }).extend({
+        normalized_result: functionComparisonResultSchema,
+    })),
+    compare_bundles: lifecycleResultOf(evidenceSchema.omit({ normalized_result: true }).extend({
+        normalized_result: bundleComparisonResultSchema,
+    })),
+    find_changed_behavior: lifecycleResultOf(evidenceSchema.omit({ normalized_result: true }).extend({
+        normalized_result: changedBehaviorResultSchema,
+    })),
+    build_call_path: lifecycleResultOf(evidenceSchema.omit({ normalized_result: true }).extend({
+        normalized_result: callPathResultSchema,
+    })),
+    correlate_static_and_runtime: lifecycleResultOf(evidenceSchema.omit({ normalized_result: true }).extend({
+        normalized_result: staticRuntimeCorrelationResultSchema,
+    })),
+    verify_reconstruction: lifecycleResultOf(evidenceSchema.omit({ normalized_result: true }).extend({
+        normalized_result: reconstructionVerificationResultSchema,
+    })),
+    list_unknowns: lifecycleResultOf(z.array(residualUnknownSchema)),
+    record_unknown: lifecycleResultOf(residualUnknownSchema),
+    update_unknown: lifecycleResultOf(residualUnknownSchema),
+    verify_unknown_resolution: lifecycleResultOf(z.object({
+        valid: z.boolean(),
+        truthVerified: z.boolean(),
+        unknown: residualUnknownSchema,
     })),
 };

package/dist/contracts/unknownContractExamples.js

@@ -0,0 +1,33 @@
+/** Exact example inputs for residual-unknown lifecycle contracts. */
+export const UNKNOWN_CONTRACT_EXAMPLES = {
+    list_unknowns: {},
+    record_unknown: {
+        approved: true,
+        question: "Does this branch require an unavailable external service?",
+        severity: "medium",
+        domain: "protocol",
+        required_authority: "controlled-replay",
+        required_confidence: "observed",
+        required_environment: null,
+        recommended_probes: [
+            { operation: "capture_process_scenario", rationale: "Replay branch." },
+        ],
+        relationships: [],
+    },
+    update_unknown: {
+        approved: true,
+        unknown_id: `unk_${"0".repeat(64)}`,
+        expected_revision: 1,
+        status: "investigating",
+        severity: "medium",
+        supporting_evidence_ids: [],
+        contradicting_evidence_ids: [],
+        required_authority: "controlled-replay",
+        required_confidence: "observed",
+        required_environment: null,
+        recommended_probes: [],
+        relationships: [],
+        resolution: null,
+    },
+    verify_unknown_resolution: { unknown_id: `unk_${"0".repeat(64)}` },
+};

package/dist/domain/artifactComparison.js

@@ -0,0 +1,273 @@
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import {} from "./artifactGraph.js";
+import { evidenceSchema } from "./evidence.js";
+import { parseArtifactInventoryEvidence, } from "./artifactInventoryEvidence.js";
+const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+const comparisonStatusSchema = z.enum([
+    "unchanged",
+    "added",
+    "removed",
+    "changed",
+    "truncated",
+    "unknown",
+]);
+const changeKindSchema = z.enum(["added", "removed", "changed", "unknown"]);
+const comparisonDimensionSchema = z.enum([
+    "content",
+    "kind",
+    "format",
+    "size",
+    "executable",
+    "relations",
+    "metadata",
+    "availability",
+]);
+/** Strict Evidence-backed input for deterministic artifact comparison. */
+export const artifactComparisonInputSchema = z.object({
+    left: z.union([evidenceSchema, z.array(evidenceSchema).min(1).max(100)]),
+    right: z.union([evidenceSchema, z.array(evidenceSchema).min(1).max(100)]),
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(500).default(100),
+    unknown_registry_approved: z
+        .literal(true)
+        .optional()
+        .describe("Explicit approval to record incomplete or differing evidence"),
+});
+/** One path-classified artifact change with citations to both observations. */
+const artifactChangeSchema = z.object({
+    classification: changeKindSchema,
+    logical_path: z.string().min(1).max(4_096),
+    dimensions: z.array(comparisonDimensionSchema).min(1).max(8),
+    left_occurrence_id: z
+        .string()
+        .regex(/^occ_[a-f0-9]{64}$/u)
+        .nullable(),
+    right_occurrence_id: z
+        .string()
+        .regex(/^occ_[a-f0-9]{64}$/u)
+        .nullable(),
+    left_artifact_id: z
+        .string()
+        .regex(/^art_[a-f0-9]{64}$/u)
+        .nullable(),
+    right_artifact_id: z
+        .string()
+        .regex(/^art_[a-f0-9]{64}$/u)
+        .nullable(),
+    evidence_links: z.array(evidenceIdSchema).min(2).max(200),
+});
+/** Bounded deterministic artifact comparison with an independently paged delta. */
+export const artifactComparisonResultSchema = z.object({
+    status: comparisonStatusSchema,
+    left_manifest_id: z.string().regex(/^agm_[a-f0-9]{64}$/u),
+    right_manifest_id: z.string().regex(/^agm_[a-f0-9]{64}$/u),
+    summary: z.object({
+        unchanged: z.number().int().min(0),
+        added: z.number().int().min(0),
+        removed: z.number().int().min(0),
+        changed: z.number().int().min(0),
+        unknown: z.number().int().min(0),
+    }),
+    changes: z.object({
+        items: z.array(artifactChangeSchema).max(500),
+        offset: z.number().int().min(0),
+        limit: z.number().int().min(1).max(500),
+        total: z.number().int().min(0),
+        next_offset: z.number().int().min(0).nullable(),
+    }),
+    limitations: z.array(z.string()),
+});
+/** Compare complete inventory pages without treating missing evidence as equality. */
+export const compareArtifacts = (leftEvidence, rightEvidence, offset, limit) => {
+    const left = parseArtifactInventoryEvidence(leftEvidence);
+    const right = parseArtifactInventoryEvidence(rightEvidence);
+    const leftComplete = left.inventory.complete;
+    const rightComplete = right.inventory.complete;
+    const leftCovered = leftComplete && left.inventory.limitations.length === 0;
+    const rightCovered = rightComplete && right.inventory.limitations.length === 0;
+    const limitations = [
+        ...left.inventory.limitations.map((item) => `Left: ${item}`),
+        ...right.inventory.limitations.map((item) => `Right: ${item}`),
+        ...(leftComplete ? [] : ["Left artifact inventory is incomplete."]),
+        ...(rightComplete ? [] : ["Right artifact inventory is incomplete."]),
+    ];
+    const changes = compareOccurrences(left.inventory, right.inventory, [
+        ...left.evidence.map(({ evidence_id: id }) => id),
+        ...right.evidence.map(({ evidence_id: id }) => id),
+    ], leftCovered && rightCovered);
+    const summary = summarize(left.inventory, right.inventory, changes, leftCovered && rightCovered);
+    const page = changes.slice(offset, offset + limit);
+    return artifactComparisonResultSchema.parse({
+        status: !leftComplete || !rightComplete
+            ? "truncated"
+            : !leftCovered || !rightCovered
+                ? "unknown"
+                : changes.some(({ classification }) => classification === "unknown")
+                    ? "unknown"
+                    : changes.length === 0
+                        ? "unchanged"
+                        : "changed",
+        left_manifest_id: left.inventory.manifest.manifest_id,
+        right_manifest_id: right.inventory.manifest.manifest_id,
+        summary,
+        changes: {
+            items: page,
+            offset,
+            limit,
+            total: changes.length,
+            next_offset: offset + page.length < changes.length ? offset + page.length : null,
+        },
+        limitations: [...new Set(limitations)].sort((a, b) => a.localeCompare(b)),
+    });
+};
+const compareOccurrences = (left, right, evidenceLinks, complete) => {
+    const leftByPath = new Map(left.occurrences.map((item) => [item.logical_path, item]));
+    const rightByPath = new Map(right.occurrences.map((item) => [item.logical_path, item]));
+    const leftNodes = new Map(left.nodes.map((item) => [item.artifact_id, item]));
+    const rightNodes = new Map(right.nodes.map((item) => [item.artifact_id, item]));
+    const leftRelations = relationsByPath(left);
+    const rightRelations = relationsByPath(right);
+    const paths = [
+        ...new Set([...leftByPath.keys(), ...rightByPath.keys()]),
+    ].sort((a, b) => a.localeCompare(b, "en"));
+    const output = [];
+    for (const path of paths) {
+        const leftOccurrence = leftByPath.get(path);
+        const rightOccurrence = rightByPath.get(path);
+        const change = classifyPath({
+            path,
+            leftOccurrence,
+            rightOccurrence,
+            leftNode: nodeFor(leftOccurrence, leftNodes),
+            rightNode: nodeFor(rightOccurrence, rightNodes),
+            leftRelations: leftRelations.get(path) ?? [],
+            rightRelations: rightRelations.get(path) ?? [],
+            complete,
+            evidenceLinks,
+        });
+        if (change !== null)
+            output.push(change);
+    }
+    return output;
+};
+const classifyPath = (input) => {
+    const base = {
+        logical_path: input.path,
+        left_occurrence_id: input.leftOccurrence?.occurrence_id ?? null,
+        right_occurrence_id: input.rightOccurrence?.occurrence_id ?? null,
+        left_artifact_id: input.leftOccurrence?.artifact_id ?? null,
+        right_artifact_id: input.rightOccurrence?.artifact_id ?? null,
+        evidence_links: [...input.evidenceLinks],
+    };
+    if (input.leftOccurrence === undefined)
+        return {
+            ...base,
+            classification: input.complete ? "added" : "unknown",
+            dimensions: [input.complete ? "content" : "availability"],
+        };
+    if (input.rightOccurrence === undefined)
+        return {
+            ...base,
+            classification: input.complete ? "removed" : "unknown",
+            dimensions: [input.complete ? "content" : "availability"],
+        };
+    if (input.leftOccurrence.hash_status !== "verified" ||
+        input.rightOccurrence.hash_status !== "verified" ||
+        input.leftNode === undefined ||
+        input.rightNode === undefined)
+        return { ...base, classification: "unknown", dimensions: ["availability"] };
+    const dimensions = changedDimensions(input);
+    return dimensions.length === 0
+        ? null
+        : { ...base, classification: "changed", dimensions };
+};
+const changedDimensions = (input) => {
+    const left = input.leftNode;
+    const right = input.rightNode;
+    if (left === undefined || right === undefined)
+        return ["availability"];
+    const checks = [
+        ["content", left.sha256 !== right.sha256],
+        ["kind", left.kind !== right.kind],
+        ["format", left.format !== right.format],
+        ["size", left.size !== right.size],
+        [
+            "executable",
+            input.leftOccurrence?.executable !== input.rightOccurrence?.executable,
+        ],
+        [
+            "relations",
+            JSON.stringify(input.leftRelations) !==
+                JSON.stringify(input.rightRelations),
+        ],
+        ["metadata", metadataChanged(input, left, right)],
+    ];
+    return checks
+        .filter(([, changed]) => changed)
+        .map(([dimension]) => dimension);
+};
+const metadataChanged = (input, left, right) => left.media_type !== right.media_type ||
+    left.architecture !== right.architecture ||
+    left.executable !== right.executable ||
+    left.content_state !== right.content_state ||
+    input.leftOccurrence?.entry_kind !== input.rightOccurrence?.entry_kind ||
+    input.leftOccurrence?.encrypted !== input.rightOccurrence?.encrypted ||
+    JSON.stringify(left.limitations) !== JSON.stringify(right.limitations) ||
+    JSON.stringify(input.leftOccurrence?.limitations) !==
+        JSON.stringify(input.rightOccurrence?.limitations);
+const canonicalJson = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Artifact comparison could not canonicalize graph data");
+    return encoded;
+};
+const nodeFor = (occurrence, nodes) => occurrence?.artifact_id === null || occurrence?.artifact_id === undefined
+    ? undefined
+    : nodes.get(occurrence.artifact_id);
+const relationsByPath = (inventory) => {
+    const output = new Map();
+    const occurrences = new Map(inventory.occurrences.map((item) => [item.occurrence_id, item]));
+    for (const edge of inventory.edges) {
+        const path = edge.logical_path ?? ".";
+        const values = output.get(path);
+        const occurrence = occurrences.get(edge.occurrence_id);
+        const projection = {
+            parent_logical_path: occurrence?.parent_occurrence_id === null ||
+                occurrence?.parent_occurrence_id === undefined
+                ? null
+                : (occurrences.get(occurrence.parent_occurrence_id)?.logical_path ??
+                    null),
+            child_artifact_id: edge.child_artifact_id,
+            relation: edge.relation,
+            logical_path: edge.logical_path,
+            producer: edge.producer,
+        };
+        if (values === undefined)
+            output.set(path, [projection]);
+        else
+            values.push(projection);
+    }
+    for (const values of output.values())
+        values.sort((left, right) => canonicalJson(left).localeCompare(canonicalJson(right)));
+    return output;
+};
+const summarize = (left, right, changes, covered) => {
+    const counts = { added: 0, removed: 0, changed: 0, unknown: 0 };
+    for (const change of changes)
+        counts[change.classification] += 1;
+    return {
+        unchanged: covered
+            ? Math.max(0, Math.min(left.occurrences.length, right.occurrences.length) -
+                counts.changed -
+                counts.unknown)
+            : 0,
+        ...counts,
+        unknown: covered
+            ? counts.unknown
+            : Math.max(counts.unknown, Math.max(left.manifest.occurrence_count, right.manifest.occurrence_count) -
+                counts.added -
+                counts.removed -
+                counts.changed),
+    };
+};