rea-agents 0.2.1 → 0.4.0

package/dist/domain/callPath.js

@@ -0,0 +1,346 @@
+import { DirectedGraph } from "graphology";
+import { bidirectional } from "graphology-shortest-path/unweighted.js";
+import { z } from "zod";
+import { evidenceSchema } from "./evidence.js";
+import { parseFunctionEvidence, } from "./functionDossierEvidence.js";
+const addressSchema = z.string().regex(/^0x(?:0|[1-9a-f][0-9a-f]*)$/u);
+const inputAddressSchema = z
+    .string()
+    .regex(/^0[xX][0-9a-fA-F]+$/u)
+    .transform((address) => `0x${BigInt(address).toString(16)}`);
+const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+const evidenceGroupSchema = z.union([
+    evidenceSchema,
+    z.array(evidenceSchema).min(1).max(100),
+]);
+const MAX_EVIDENCE_PAGES = 2_000;
+const MAX_GRAPH_EDGES = 10_000;
+const MAX_PATH_EXPANSIONS = 100_000;
+/** Strict, bounded input for explicit call-path reconstruction. */
+export const callPathInputSchema = z
+    .object({
+    functions: z.array(evidenceGroupSchema).min(1).max(500),
+    start: z.object({ address: inputAddressSchema }).strict(),
+    goal: z.object({ address: inputAddressSchema }).strict(),
+    max_depth: z.number().int().min(0).max(32).default(8),
+    max_paths: z.number().int().min(1).max(100).default(10),
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(100).default(100),
+    unknown_registry_approved: z.literal(true).optional(),
+})
+    .superRefine(({ functions }, context) => {
+    const pages = functions.reduce((total, group) => total + (Array.isArray(group) ? group.length : 1), 0);
+    if (pages > MAX_EVIDENCE_PAGES)
+        context.addIssue({
+            code: "custom",
+            message: `Call-path Evidence exceeds ${MAX_EVIDENCE_PAGES} pages`,
+            path: ["functions"],
+        });
+});
+const citedNodeSchema = z.object({
+    address: addressSchema,
+    name: z.string().nullable(),
+    evidence_links: z.array(evidenceIdSchema).min(1).max(100),
+});
+const citedEdgeSchema = z.object({
+    source: addressSchema,
+    target: addressSchema,
+    evidence_links: z.array(evidenceIdSchema).min(1).max(100),
+});
+const pathSchema = z.object({
+    hops: z.number().int().min(0),
+    nodes: z.array(citedNodeSchema).min(1).max(33),
+    edges: z.array(citedEdgeSchema).max(32),
+    evidence_links: z.array(evidenceIdSchema).min(1).max(3_300),
+});
+/** Evidence-cited, bounded directed call-path result. */
+export const callPathResultSchema = z.object({
+    status: z.enum(["found", "not_found", "unknown", "truncated"]),
+    start: addressSchema,
+    goal: addressSchema,
+    shortest_hops: z.number().int().min(0).nullable(),
+    search_scope: z.object({
+        max_depth: z.number().int().min(0).max(32),
+        max_paths: z.number().int().min(1).max(100),
+        exhaustive: z.boolean(),
+    }),
+    explored: z.object({
+        nodes: z.number().int().min(0),
+        edges: z.number().int().min(0),
+        depth_reached: z.number().int().min(0),
+    }),
+    paths: z.object({
+        items: z.array(pathSchema).max(100),
+        offset: z.number().int().min(0),
+        limit: z.number().int().min(1).max(100),
+        total: z.number().int().min(0).nullable(),
+        returned: z.number().int().min(0).max(100),
+        truncated: z.boolean(),
+        lower_bound: z.number().int().min(0),
+        next_offset: z.number().int().min(0).nullable(),
+    }),
+    evidence_links: z.array(evidenceIdSchema).min(1).max(50_000),
+    limitations: z.array(z.string()),
+});
+/** Reconstruct bounded direct-callee paths from explicit analyze_function Evidence. */
+export const buildCallPath = (input) => {
+    const parsed = callPathInputSchema.parse(input);
+    const snapshots = parseSnapshots(parsed.functions);
+    assertCompatible(snapshots);
+    if (!snapshots.has(parsed.start.address))
+        throw new TypeError(`No analyze_function Evidence was supplied for start ${parsed.start.address}`);
+    const graph = createGraph(snapshots);
+    const search = inspectSearch({
+        graph,
+        snapshots,
+        start: parsed.start.address,
+        goal: parsed.goal.address,
+        maxDepth: parsed.max_depth,
+    });
+    const shortest = graph.hasNode(parsed.start.address) && graph.hasNode(parsed.goal.address)
+        ? bidirectional(graph, parsed.start.address, parsed.goal.address)
+        : null;
+    const enumeration = shortest === null || shortest.length - 1 > parsed.max_depth
+        ? { paths: [], budgetExhausted: false }
+        : enumeratePaths({
+            graph,
+            start: parsed.start.address,
+            goal: parsed.goal.address,
+            shortestDepth: shortest.length - 1,
+            maxDepth: parsed.max_depth,
+            limit: parsed.max_paths + 1,
+        });
+    const hasKnownExtraPath = enumeration.paths.length > parsed.max_paths;
+    const capped = hasKnownExtraPath || enumeration.budgetExhausted;
+    const retained = enumeration.paths.slice(0, parsed.max_paths);
+    const paths = retained.map((path) => citePath(path, snapshots));
+    const total = paths.length;
+    const items = paths.slice(parsed.offset, parsed.offset + parsed.limit);
+    const found = paths.length > 0;
+    const exhaustive = search.exhaustive && !capped;
+    const status = callPathStatus({ capped, found, exhaustive });
+    const limitations = [...search.limitations];
+    if (capped)
+        limitations.push(enumeration.budgetExhausted
+            ? `Path enumeration stopped at ${MAX_PATH_EXPANSIONS} expansions`
+            : `Path enumeration stopped at max_paths=${parsed.max_paths}`);
+    if (!found && shortest !== null && shortest.length - 1 > parsed.max_depth)
+        limitations.push(`The shortest observed path exceeds max_depth=${parsed.max_depth}`);
+    return callPathResultSchema.parse({
+        status,
+        start: parsed.start.address,
+        goal: parsed.goal.address,
+        shortest_hops: found ? (paths[0]?.hops ?? null) : null,
+        search_scope: {
+            max_depth: parsed.max_depth,
+            max_paths: parsed.max_paths,
+            exhaustive,
+        },
+        explored: {
+            nodes: search.reached.size,
+            edges: [...search.reached.keys()].reduce((count, node) => count + (graph.hasNode(node) ? graph.outDegree(node) : 0), 0),
+            depth_reached: Math.max(0, ...search.reached.values()),
+        },
+        paths: {
+            items,
+            offset: parsed.offset,
+            limit: parsed.limit,
+            total: capped ? null : total,
+            returned: items.length,
+            truncated: capped,
+            lower_bound: total + (hasKnownExtraPath ? 1 : 0),
+            next_offset: parsed.offset + items.length < total
+                ? parsed.offset + items.length
+                : null,
+        },
+        evidence_links: uniqueEvidence(snapshots.values()),
+        limitations: [...new Set(limitations)].sort((left, right) => left.localeCompare(right)),
+    });
+};
+const callPathStatus = ({ capped, found, exhaustive, }) => {
+    if (capped)
+        return "truncated";
+    if (found)
+        return "found";
+    return exhaustive ? "not_found" : "unknown";
+};
+const parseSnapshots = (groups) => {
+    const snapshots = new Map();
+    for (const group of groups) {
+        const snapshot = parseFunctionEvidence(group);
+        const address = normalizeAddress(snapshot.procedure.address);
+        for (const callee of snapshot.collections.callees.items)
+            normalizeAddress(callee.address);
+        if (snapshots.has(address))
+            throw new TypeError(`Duplicate function Evidence for ${address}`);
+        snapshots.set(address, snapshot);
+    }
+    return snapshots;
+};
+const assertCompatible = (snapshots) => {
+    const first = snapshots.values().next().value;
+    if (first === undefined)
+        return;
+    for (const snapshot of snapshots.values()) {
+        if (snapshot.subject.digest.sha256 !== first.subject.digest.sha256 ||
+            snapshot.subject.format !== first.subject.format ||
+            snapshot.subject.architecture !== first.subject.architecture)
+            throw new TypeError("Call-path Evidence mixes artifact subjects");
+        if (snapshot.provider.id !== first.provider.id ||
+            snapshot.provider.name !== first.provider.name ||
+            snapshot.provider.version !== first.provider.version)
+            throw new TypeError("Call-path Evidence mixes providers");
+    }
+};
+const createGraph = (snapshots) => {
+    const graph = new DirectedGraph({ allowSelfLoops: true, multi: false });
+    for (const [address, snapshot] of snapshots) {
+        graph.mergeNode(address);
+        for (const callee of snapshot.collections.callees.items) {
+            const calleeAddress = normalizeAddress(callee.address);
+            graph.mergeNode(calleeAddress);
+            graph.mergeDirectedEdge(address, calleeAddress);
+            if (graph.size > MAX_GRAPH_EDGES)
+                throw new TypeError(`Call graph exceeds ${MAX_GRAPH_EDGES} directed edges`);
+        }
+    }
+    return graph;
+};
+const inspectSearch = ({ graph, snapshots, start, goal, maxDepth, }) => {
+    if (!graph.hasNode(start))
+        return {
+            graph,
+            snapshots,
+            reached: new Map(),
+            exhaustive: false,
+            limitations: [
+                `No analyze_function Evidence was supplied for start ${start}`,
+            ],
+        };
+    const reached = new Map([[start, 0]]);
+    const queue = [start];
+    const limitations = [];
+    for (let index = 0; index < queue.length; index += 1) {
+        const node = queue[index];
+        if (node === undefined)
+            continue;
+        const depth = reached.get(node) ?? 0;
+        if (node === goal)
+            continue;
+        const snapshot = snapshots.get(node);
+        if (snapshot === undefined) {
+            limitations.push(`No analyze_function Evidence covers reachable function ${node}`);
+            continue;
+        }
+        if (!snapshot.collections.callees.complete)
+            limitations.push(`Callee coverage is incomplete for reachable function ${node}`);
+        const neighbors = graph
+            .outNeighbors(node)
+            .sort((left, right) => left.localeCompare(right));
+        if (depth === maxDepth) {
+            if (neighbors.length > 0)
+                limitations.push(`Search reached max_depth=${maxDepth} at ${node}`);
+            continue;
+        }
+        for (const neighbor of neighbors)
+            if (!reached.has(neighbor)) {
+                reached.set(neighbor, depth + 1);
+                queue.push(neighbor);
+            }
+    }
+    return {
+        graph,
+        snapshots,
+        reached,
+        exhaustive: limitations.length === 0,
+        limitations,
+    };
+};
+const enumeratePaths = ({ graph, start, goal, shortestDepth, maxDepth, limit, }) => {
+    const output = [];
+    const state = {
+        graph,
+        goal,
+        path: [start],
+        visited: new Set([start]),
+        output,
+        limit,
+        expansions: 0,
+        budgetExhausted: false,
+    };
+    for (let depth = shortestDepth; depth <= maxDepth && output.length < limit; depth += 1)
+        enumerateAtDepth(state, depth);
+    return { paths: output, budgetExhausted: state.budgetExhausted };
+};
+const enumerateAtDepth = (state, remaining) => {
+    const { graph, goal, path, visited, output, limit } = state;
+    state.expansions += 1;
+    if (state.expansions > MAX_PATH_EXPANSIONS) {
+        state.budgetExhausted = true;
+        return;
+    }
+    const current = path.at(-1);
+    if (current === undefined || output.length >= limit)
+        return;
+    if (remaining === 0) {
+        if (current === goal)
+            output.push([...path]);
+        return;
+    }
+    if (current === goal)
+        return;
+    for (const neighbor of graph
+        .outNeighbors(current)
+        .sort((left, right) => left.localeCompare(right))) {
+        if (visited.has(neighbor))
+            continue;
+        visited.add(neighbor);
+        path.push(neighbor);
+        enumerateAtDepth(state, remaining - 1);
+        path.pop();
+        visited.delete(neighbor);
+        if (output.length >= limit || state.budgetExhausted)
+            return;
+    }
+};
+const citePath = (addresses, snapshots) => {
+    const edges = addresses.slice(0, -1).map((source, index) => {
+        const target = addresses[index + 1];
+        if (target === undefined)
+            throw new TypeError("Call path has an invalid edge");
+        return {
+            source,
+            target,
+            evidence_links: snapshotLinks(snapshots.get(source)),
+        };
+    });
+    const nodes = addresses.map((address, index) => {
+        const snapshot = snapshots.get(address);
+        const supporting = snapshot ??
+            (index > 0 ? snapshots.get(addresses[index - 1] ?? "") : undefined);
+        return {
+            address,
+            name: snapshot?.procedure.name ?? null,
+            evidence_links: snapshotLinks(supporting),
+        };
+    });
+    return {
+        hops: edges.length,
+        nodes,
+        edges,
+        evidence_links: [
+            ...new Set(edges
+                .flatMap(({ evidence_links: links }) => links)
+                .concat(nodes.flatMap(({ evidence_links: links }) => links))),
+        ],
+    };
+};
+const snapshotLinks = (snapshot) => {
+    if (snapshot === undefined)
+        throw new TypeError("Every call-path claim requires supporting Evidence");
+    return snapshot.evidence.map(({ evidence_id }) => evidence_id);
+};
+const uniqueEvidence = (snapshots) => [
+    ...new Set([...snapshots].flatMap((snapshot) => snapshotLinks(snapshot))),
+].sort((left, right) => left.localeCompare(right));
+const normalizeAddress = (input) => inputAddressSchema.parse(input);

package/dist/domain/changedBehavior.js

@@ -0,0 +1,294 @@
+import { z } from "zod";
+import { artifactComparisonResultSchema } from "./artifactComparison.js";
+import { evidenceSchema, parseEvidence } from "./evidence.js";
+import { functionComparisonResultSchema } from "./functionComparison.js";
+import { comparisonStatusSchema, processCaptureComparisonSchema, } from "./processCapture.js";
+const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+/** Strict bounded input for aggregating existing comparison Evidence. */
+export const changedBehaviorInputSchema = z.object({
+    comparisons: z.array(evidenceSchema).min(1).max(100),
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(100).default(100),
+    unknown_registry_approved: z.literal(true).optional(),
+});
+const findingSchema = z.object({
+    scope: z.enum(["runtime", "protocol", "resource", "static_candidate"]),
+    dimension: z.string().min(1),
+    classification: z.enum([
+        "observed_change",
+        "derived_relationship",
+        "contradiction",
+        "unresolved_branch",
+    ]),
+    status: comparisonStatusSchema,
+    source_comparison_id: evidenceIdSchema,
+    evidence_links: z.array(evidenceIdSchema).min(3).max(201),
+    limitations: z.array(z.string()),
+});
+/** Truthful aggregate: runtime observations remain separate from static candidates. */
+export const changedBehaviorResultSchema = z.object({
+    behavior_status: z.enum([
+        "observed_changed",
+        "observed_unchanged",
+        "unknown",
+        "truncated",
+    ]),
+    summary: z.object({
+        observed_changes: z.number().int().min(0),
+        static_candidates: z.number().int().min(0),
+        contradictions: z.number().int().min(0),
+        unresolved: z.number().int().min(0),
+    }),
+    findings: z.object({
+        items: z.array(findingSchema).max(100),
+        offset: z.number().int().min(0),
+        limit: z.number().int().min(1).max(100),
+        total: z.number().int().min(0),
+        next_offset: z.number().int().min(0).nullable(),
+    }),
+    evidence_links: z.array(evidenceIdSchema).min(3).max(20_100),
+    limitations: z.array(z.string()),
+});
+const EXPECTED_PROVIDERS = {
+    compare_process_captures: {
+        predicate: "rea.process-comparison/v1",
+        id: "rea-process",
+        name: "REA deterministic process harness",
+        version: "1",
+    },
+    compare_artifacts: {
+        predicate: "rea.artifact-comparison/v1",
+        id: "rea-artifact-comparison",
+        name: "REA artifact comparison",
+        version: "1",
+    },
+    compare_functions: {
+        predicate: "rea.function-comparison/v1",
+        id: "rea-function-comparison",
+        name: "REA function comparison",
+        version: "1",
+    },
+};
+/** Find observed runtime changes and separately report static change candidates. */
+export const findChangedBehavior = (comparisonsInput, offset, limit) => {
+    const parsedInput = changedBehaviorInputSchema.parse({
+        comparisons: comparisonsInput,
+        offset,
+        limit,
+    });
+    const comparisons = parsedInput.comparisons;
+    const evidence = comparisons.map(parseComparisonEvidence);
+    assertUnique(evidence.map(({ evidence_id: id }) => id), "comparison Evidence");
+    const findings = evidence.flatMap(findingsFor).sort(compareFindings);
+    const runtimeStatuses = evidence.flatMap(runtimeStatus);
+    const links = uniqueSorted(evidence.flatMap((item) => [item.evidence_id, ...item.evidence_links]));
+    if (links.length > 20_100)
+        throw new TypeError("Changed-behavior Evidence closure exceeds limit");
+    const page = findings.slice(parsedInput.offset, parsedInput.offset + parsedInput.limit);
+    return changedBehaviorResultSchema.parse({
+        behavior_status: behaviorStatus(runtimeStatuses),
+        summary: {
+            observed_changes: count(findings, "observed_change"),
+            static_candidates: count(findings, "derived_relationship"),
+            contradictions: count(findings, "contradiction"),
+            unresolved: count(findings, "unresolved_branch"),
+        },
+        findings: {
+            items: page,
+            offset: parsedInput.offset,
+            limit: parsedInput.limit,
+            total: findings.length,
+            next_offset: parsedInput.offset + page.length < findings.length
+                ? parsedInput.offset + page.length
+                : null,
+        },
+        evidence_links: links,
+        limitations: uniqueSorted([
+            ...evidence.flatMap(({ limitations }) => limitations),
+            ...(evidence.some(({ operation }) => operation !== "compare_process_captures")
+                ? [
+                    "Static differences are behavior candidates, not runtime observations.",
+                ]
+                : []),
+            ...(runtimeStatuses.length === 0
+                ? ["No process comparison Evidence was supplied."]
+                : []),
+        ]),
+    });
+};
+const parseComparisonEvidence = (input) => {
+    const evidence = parseEvidence(input);
+    if (!(evidence.operation in EXPECTED_PROVIDERS))
+        throw new TypeError("Changed-behavior analysis requires process, artifact, or function comparison Evidence");
+    const operation = z
+        .enum([
+        "compare_process_captures",
+        "compare_artifacts",
+        "compare_functions",
+    ])
+        .parse(evidence.operation);
+    const expected = EXPECTED_PROVIDERS[operation];
+    if (evidence.predicate_type !== expected.predicate ||
+        evidence.provider.id !== expected.id ||
+        evidence.provider.name !== expected.name ||
+        evidence.provider.version !== expected.version ||
+        evidence.confidence !== "derived" ||
+        evidence.authority !== "analyst-inference" ||
+        evidence.subject !== null)
+        throw new TypeError("Comparison Evidence operation, predicate, and provider disagree");
+    if (evidence.evidence_links.length < 2)
+        throw new TypeError("Comparison Evidence must cite both source observations");
+    assertUnique(evidence.evidence_links, "source Evidence links");
+    parseResult(evidence);
+    return evidence;
+};
+const parseResult = (evidence) => {
+    if (evidence.operation === "compare_process_captures") {
+        const result = processCaptureComparisonSchema.parse(evidence.normalized_result);
+        const dimensions = [
+            result.terminal,
+            result.exit,
+            result.filesystem,
+            result.protocol,
+            result.process,
+        ];
+        const expected = dimensions.includes("truncated")
+            ? "truncated"
+            : dimensions.some(isChange)
+                ? "changed"
+                : dimensions.includes("unknown")
+                    ? "unknown"
+                    : "unchanged";
+        if (result.status !== expected)
+            throw new TypeError("Process comparison status contradicts its dimensions");
+        return;
+    }
+    if (evidence.operation === "compare_functions") {
+        const result = functionComparisonResultSchema.parse(evidence.normalized_result);
+        assertNestedLinks(evidence, result.dimensions.flatMap(({ evidence_links: links }) => links));
+        return;
+    }
+    const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
+    if (result.changes.offset !== 0 ||
+        result.changes.next_offset !== null ||
+        result.changes.items.length !== result.changes.total)
+        throw new TypeError("Changed-behavior analysis requires complete artifact comparison pagination");
+    assertNestedLinks(evidence, result.changes.items.flatMap(({ evidence_links: links }) => links));
+};
+const assertNestedLinks = (evidence, nestedLinks) => {
+    const topLevel = new Set(evidence.evidence_links);
+    if (nestedLinks.some((evidenceId) => !topLevel.has(evidenceId)))
+        throw new TypeError("Comparison finding cites Evidence outside its top-level closure");
+};
+const findingsFor = (evidence) => {
+    if (evidence.operation === "compare_process_captures")
+        return processFindings(evidence);
+    if (evidence.operation === "compare_functions")
+        return functionFindings(evidence);
+    return artifactFindings(evidence);
+};
+const processFindings = (evidence) => {
+    const result = processCaptureComparisonSchema.parse(evidence.normalized_result);
+    const dimensions = [
+        ["terminal", result.terminal, "runtime"],
+        ["exit", result.exit, "runtime"],
+        ["filesystem", result.filesystem, "resource"],
+        ["protocol", result.protocol, "protocol"],
+        ["process", result.process, "runtime"],
+    ];
+    return dimensions.flatMap(([dimension, status, scope]) => status === "unchanged"
+        ? []
+        : [
+            makeFinding({
+                evidence,
+                dimension,
+                scope,
+                status,
+                classification: isChange(status)
+                    ? "observed_change"
+                    : "unresolved_branch",
+                limitations: result.limitations,
+            }),
+        ]);
+};
+const functionFindings = (evidence) => {
+    const result = functionComparisonResultSchema.parse(evidence.normalized_result);
+    return result.dimensions.flatMap((dimension) => dimension.status === "unchanged"
+        ? []
+        : [
+            makeFinding({
+                evidence,
+                dimension: dimension.dimension,
+                scope: "static_candidate",
+                status: dimension.status,
+                classification: dimension.status === "unknown" || dimension.status === "truncated"
+                    ? "unresolved_branch"
+                    : dimension.conclusion_kind,
+                limitations: dimension.limitations,
+                links: dimension.evidence_links,
+            }),
+        ]);
+};
+const artifactFindings = (evidence) => {
+    const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
+    const changes = result.changes.items.map((change) => makeFinding({
+        evidence,
+        dimension: `artifact:${change.logical_path}`,
+        scope: "static_candidate",
+        status: change.classification,
+        classification: change.classification === "unknown"
+            ? "unresolved_branch"
+            : "derived_relationship",
+        limitations: result.limitations,
+        links: change.evidence_links,
+    }));
+    return (result.status === "unknown" || result.status === "truncated") &&
+        !changes.some(({ classification }) => classification === "unresolved_branch")
+        ? [
+            ...changes,
+            makeFinding({
+                evidence,
+                dimension: "artifact:coverage",
+                scope: "static_candidate",
+                status: result.status,
+                classification: "unresolved_branch",
+                limitations: result.limitations,
+            }),
+        ]
+        : changes;
+};
+const makeFinding = (input) => findingSchema.parse({
+    scope: input.scope,
+    dimension: input.dimension,
+    classification: input.classification,
+    status: input.status,
+    source_comparison_id: input.evidence.evidence_id,
+    evidence_links: uniqueSorted([
+        input.evidence.evidence_id,
+        ...(input.links ?? input.evidence.evidence_links),
+    ]),
+    limitations: uniqueSorted(input.limitations),
+});
+const runtimeStatus = (evidence) => evidence.operation === "compare_process_captures"
+    ? [processCaptureComparisonSchema.parse(evidence.normalized_result).status]
+    : [];
+const behaviorStatus = (statuses) => {
+    if (statuses.length === 0)
+        return "unknown";
+    if (statuses.includes("truncated"))
+        return "truncated";
+    if (statuses.includes("unknown"))
+        return "unknown";
+    return statuses.some(isChange) ? "observed_changed" : "observed_unchanged";
+};
+const isChange = (status) => status === "added" || status === "removed" || status === "changed";
+const count = (findings, classification) => findings.filter((finding) => finding.classification === classification)
+    .length;
+const compareFindings = (left, right) => [left.scope, left.dimension, left.source_comparison_id]
+    .join("\0")
+    .localeCompare([right.scope, right.dimension, right.source_comparison_id].join("\0"), "en");
+const uniqueSorted = (values) => [...new Set(values)].sort((left, right) => left.localeCompare(right, "en"));
+const assertUnique = (values, label) => {
+    if (new Set(values).size !== values.length)
+        throw new TypeError(`Changed-behavior analysis rejects duplicate ${label}`);
+};