rea-agents 1.7.0 → 2.1.0

package/dist/domain/javascriptReplay.js

@@ -0,0 +1,361 @@
+import { z } from "zod";
+import { evidenceEnvelopeSchema } from "./evidence.js";
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const absolutePathSchema = z.string().startsWith("/").max(4096);
+const aliasSchema = z
+    .string()
+    .min(1)
+    .max(256)
+    .regex(/^[A-Za-z0-9_./:@-]+$/u);
+const replayModuleSchema = z
+    .object({
+    alias: aliasSchema,
+    path: absolutePathSchema,
+    format: z.enum(["esm", "commonjs-factory"]),
+    role: z.enum(["module", "stub"]).default("module"),
+    dependencies: z
+        .record(z.string().min(1).max(256), aliasSchema)
+        .refine((value) => Object.keys(value).length <= 128, {
+        message: "Replay modules may declare at most 128 dependencies",
+    })
+        .default({}),
+})
+    .strict();
+const replaySideSchema = z
+    .object({
+    modules: z.array(replayModuleSchema).min(1).max(128),
+    entry_alias: aliasSchema,
+    entry_export: z.string().min(1).max(256).default("default"),
+})
+    .strict();
+const explicitCaseSchema = z
+    .object({
+    case_id: z.string().min(1).max(128),
+    arguments: z.array(z.json()).max(16),
+})
+    .strict();
+const generatorSchema = z
+    .object({
+    preset: z.enum([
+        "parser-boundaries",
+        "sanitizer-boundaries",
+        "clipboard-boundaries",
+    ]),
+    seed: z.number().int().min(0).max(0xffff_ffff),
+    count: z.number().int().min(1).max(64),
+})
+    .strict();
+const replayLimitsSchema = z
+    .object({
+    wall_time_ms: z.number().int().min(100).max(10_000).default(3_000),
+    memory_bytes: z
+        .number()
+        .int()
+        .min(16 * 1024 * 1024)
+        .max(512 * 1024 * 1024)
+        .default(128 * 1024 * 1024),
+    tasks: z.number().int().min(1).max(32).default(8),
+    cpu_quota_percent: z.number().int().min(1).max(100).default(50),
+    tmpfs_bytes: z
+        .number()
+        .int()
+        .min(1024 * 1024)
+        .max(64 * 1024 * 1024)
+        .default(16 * 1024 * 1024),
+    module_bytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(16 * 1024 * 1024)
+        .default(4 * 1024 * 1024),
+    input_bytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(1024 * 1024)
+        .default(256 * 1024),
+    protocol_bytes: z
+        .number()
+        .int()
+        .min(1024 * 1024)
+        .max(64 * 1024 * 1024)
+        .default(16 * 1024 * 1024),
+    output_bytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(4 * 1024 * 1024)
+        .default(512 * 1024),
+    stderr_bytes: z
+        .number()
+        .int()
+        .min(0)
+        .max(256 * 1024)
+        .default(32 * 1024),
+    result_depth: z.number().int().min(1).max(64).default(16),
+    result_nodes: z.number().int().min(1).max(100_000).default(10_000),
+})
+    .strict();
+const determinismSchema = z
+    .object({
+    clock_iso: z.iso.datetime().default("2000-01-01T00:00:00.000Z"),
+    random_seed: z.number().int().min(0).max(0xffff_ffff).default(0),
+    locale: z.literal("en-US").default("en-US"),
+    timezone: z.literal("UTC").default("UTC"),
+    platform: z.literal("linux").default("linux"),
+})
+    .strict();
+export const controlledReplayInputSchema = z
+    .object({
+    mode: z.enum(["plan", "execute"]),
+    left: replaySideSchema,
+    right: replaySideSchema.optional(),
+    cases: z.array(explicitCaseSchema).max(128).default([]),
+    generator: generatorSchema.optional(),
+    determinism: determinismSchema.default({
+        clock_iso: "2000-01-01T00:00:00.000Z",
+        random_seed: 0,
+        locale: "en-US",
+        timezone: "UTC",
+        platform: "linux",
+    }),
+    limits: replayLimitsSchema.default({
+        wall_time_ms: 3_000,
+        memory_bytes: 128 * 1024 * 1024,
+        tasks: 8,
+        cpu_quota_percent: 50,
+        tmpfs_bytes: 16 * 1024 * 1024,
+        module_bytes: 4 * 1024 * 1024,
+        input_bytes: 256 * 1024,
+        protocol_bytes: 16 * 1024 * 1024,
+        output_bytes: 512 * 1024,
+        stderr_bytes: 32 * 1024,
+        result_depth: 16,
+        result_nodes: 10_000,
+    }),
+    approved: z.boolean().default(false),
+    plan_digest: digestSchema.optional(),
+    reproducer_export: z
+        .object({
+        path: absolutePathSchema,
+        approved: z.boolean(),
+        include_sources: z.boolean().default(false),
+    })
+        .strict()
+        .optional(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.cases.length === 0 && value.generator === undefined)
+        context.addIssue({
+            code: "custom",
+            path: ["cases"],
+            message: "At least one explicit or generated case is required",
+        });
+    if (value.cases.length + (value.generator?.count ?? 0) > 128)
+        context.addIssue({
+            code: "custom",
+            path: ["generator", "count"],
+            message: "Explicit and generated replay cases must total at most 128",
+        });
+    if (value.mode === "execute" &&
+        (value.approved !== true || value.plan_digest === undefined))
+        context.addIssue({
+            code: "custom",
+            path: ["approved"],
+            message: "Execution requires literal approval and a plan digest",
+        });
+});
+const moduleCommitmentSchema = z
+    .object({
+    alias: aliasSchema,
+    canonical_path: z.string().min(1),
+    format: z.enum(["esm", "commonjs-factory"]),
+    role: z.enum(["module", "stub"]),
+    byte_count: z.number().int().min(0),
+    sha256: digestSchema,
+    dependencies: z.record(z.string(), aliasSchema),
+})
+    .strict();
+const runtimeIdentitySchema = z
+    .object({
+    path: z.string().min(1),
+    version: z.string().min(1),
+    sha256: digestSchema,
+})
+    .strict();
+const runtimeFileIdentitySchema = z
+    .object({
+    source_path: z.string().min(1),
+    destination_path: z.string().min(1),
+    sha256: digestSchema,
+})
+    .strict();
+const replayPlanSchema = z
+    .object({
+    schema_version: z.literal(1),
+    plan_digest: digestSchema,
+    policy_version: z.literal("linux-bwrap-systemd-v1"),
+    policy_sha256: digestSchema,
+    network: z.literal("none"),
+    filesystem: z
+        .object({
+        host_writes: z.literal(false),
+        private_tmpfs_bytes: z.number().int(),
+    })
+        .strict(),
+    runtime: z
+        .object({
+        executable: runtimeIdentitySchema,
+        worker: runtimeIdentitySchema,
+        read_only_files: z.array(runtimeFileIdentitySchema).min(1),
+    })
+        .strict(),
+    sandbox: z
+        .object({
+        bubblewrap: runtimeIdentitySchema,
+        systemd_run: runtimeIdentitySchema,
+        systemctl: runtimeIdentitySchema,
+        shell: runtimeIdentitySchema,
+        seccomp_sha256: digestSchema,
+    })
+        .strict(),
+    left: z
+        .object({
+        modules: z.array(moduleCommitmentSchema),
+        entry_alias: aliasSchema,
+        entry_export: z.string(),
+    })
+        .strict(),
+    right: z
+        .object({
+        modules: z.array(moduleCommitmentSchema),
+        entry_alias: aliasSchema,
+        entry_export: z.string(),
+    })
+        .strict()
+        .optional(),
+    cases: z.array(z
+        .object({
+        case_id: z.string(),
+        arguments: z.array(z.json()),
+        sha256: digestSchema,
+    })
+        .strict()),
+    determinism: determinismSchema,
+    limits: replayLimitsSchema,
+    effects: z.array(z.string()),
+    reproducer_export: z
+        .object({
+        path: z.string().min(1),
+        include_sources: z.boolean(),
+        authority: z.literal("evidence_write"),
+    })
+        .strict()
+        .nullable(),
+})
+    .strict();
+const replayOutcomeSchema = z
+    .object({
+    case_id: z.string(),
+    outcome: z.enum([
+        "return",
+        "exception",
+        "serialization_error",
+        "denied",
+        "timeout",
+        "oom",
+        "crash",
+        "cancelled",
+        "protocol_error",
+    ]),
+    value: z.json().optional(),
+    exception: z
+        .object({
+        name: z.string(),
+        message: z.string(),
+        stack: z.string().nullable(),
+    })
+        .strict()
+        .optional(),
+    input_sha256: digestSchema,
+    output_sha256: digestSchema.nullable(),
+    truncated: z.boolean(),
+})
+    .strict();
+export const replayExecutionResultSchema = z
+    .object({
+    schema_version: z.literal(1),
+    plan_digest: digestSchema,
+    outcomes: z.array(replayOutcomeSchema),
+    comparison: z
+        .array(z
+        .object({
+        case_id: z.string(),
+        status: z.enum(["equal", "changed", "unknown"]),
+        left_index: z.number().int(),
+        right_index: z.number().int(),
+    })
+        .strict())
+        .optional(),
+    stderr: z.string(),
+    termination: z.enum([
+        "completed",
+        "timeout",
+        "oom",
+        "crash",
+        "cancelled",
+        "protocol_error",
+    ]),
+    cleanup: z
+        .object({
+        state: z.enum(["complete", "incomplete"]),
+        residual_resources: z.array(z.string()),
+    })
+        .strict(),
+    limitations: z.array(z.string()),
+    reproducer: z
+        .discriminatedUnion("state", [
+        z
+            .object({
+            state: z.literal("written"),
+            path: z.string(),
+            sha256: digestSchema,
+        })
+            .strict(),
+        z
+            .object({
+            state: z.literal("failed"),
+            path: z.string(),
+            error: z.string(),
+        })
+            .strict(),
+    ])
+        .nullable(),
+})
+    .strict();
+export const replayEvidenceSchema = evidenceEnvelopeSchema
+    .omit({ normalized_result: true })
+    .extend({ normalized_result: replayExecutionResultSchema });
+export const controlledReplayOutputSchema = z
+    .object({
+    phase: z.enum(["plan", "execute"]),
+    plan: replayPlanSchema.nullable(),
+    source_evidence: z.array(replayEvidenceSchema),
+    evidence: replayEvidenceSchema.nullable(),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.phase === "plan" &&
+        (value.plan === null ||
+            value.evidence !== null ||
+            value.source_evidence.length !== 0)) ||
+        (value.phase === "execute" &&
+            (value.plan !== null ||
+                value.evidence === null ||
+                value.source_evidence.length === 0)))
+        context.addIssue({
+            code: "custom",
+            message: "Replay output phase does not match its payload",
+        });
+});

package/dist/domain/javascriptRuntimeLoadState.js

@@ -0,0 +1,106 @@
+import { compareCodePoints, } from "./javascriptApplicationGraph.js";
+import { createStaticRuntimeScope, mappedRuntimePaths, staticNodeWithinRuntimeScope, } from "./javascriptRuntimeStaticCandidates.js";
+/** Classify static code presence without claiming bundled module execution. */
+export const classifyStaticLoadStates = (layers, runtimeEntities, matches, options) => {
+    const states = [];
+    let totalStates = 0;
+    for (const layer of layers) {
+        const projection = classifyLayer(layer, runtimeEntities, matches, {
+            reconciliationComplete: options.reconciliationComplete,
+            maximumStates: Math.max(0, options.maximumStates - states.length),
+        });
+        totalStates += projection.total;
+        states.push(...projection.states);
+    }
+    return { states, omittedStates: totalStates - states.length };
+};
+const classifyLayer = (layer, runtimeEntities, matches, options) => {
+    const nodes = layer.graph.nodes.filter(isLoadStateNode);
+    if (options.maximumStates === 0)
+        return { states: [], total: nodes.length };
+    const direct = new Map();
+    for (const match of matches)
+        if (match.status === "matched" &&
+            match.static_layer_id === layer.layerId &&
+            match.static_node_id !== null)
+            append(direct, match.static_node_id, match.runtime_node_id);
+    const resident = residentNodes(layer, new Set(direct.keys()));
+    const runtimeScope = createStaticRuntimeScope(layer, runtimeEntities);
+    const scopedEntities = runtimeEntities.filter((entity) => mappedRuntimePaths(layer, entity).length > 0);
+    const layerComplete = options.reconciliationComplete &&
+        layer.graph.coverage.status === "complete" &&
+        scopedEntities.length > 0 &&
+        scopedEntities.every(({ capture }) => captureScriptsComplete(capture.evidence.evidence_id, runtimeEntities));
+    const states = nodes.slice(0, options.maximumStates).map((node) => {
+        const runtimeNodeIds = uniqueSorted(direct.get(node.node_id) ?? []);
+        if (runtimeNodeIds.length > 0)
+            return state(layer, node, {
+                status: "loaded",
+                runtimeNodeIds,
+                reason: "runtime-script-correspondence",
+            });
+        if (resident.has(node.node_id))
+            return state(layer, node, {
+                status: "resident-in-loaded-asset",
+                runtimeNodeIds: [],
+                reason: "containing-asset-was-loaded",
+            });
+        const nodeWithinScope = staticNodeWithinRuntimeScope(node, runtimeScope);
+        if (layerComplete && nodeWithinScope)
+            return state(layer, node, {
+                status: "not-observed-in-capture",
+                runtimeNodeIds: [],
+                reason: "not-observed-in-bounded-capture",
+            });
+        return state(layer, node, {
+            status: "unknown",
+            runtimeNodeIds: [],
+            reason: !nodeWithinScope
+                ? "layer-outside-runtime-scope"
+                : "static-or-runtime-coverage-incomplete",
+        });
+    });
+    return { states, total: nodes.length };
+};
+const residentNodes = (layer, directlyLoaded) => {
+    const nodeKinds = new Map(layer.graph.nodes.map(({ node_id: id, kind }) => [id, kind]));
+    const children = new Map();
+    for (const edge of layer.graph.edges)
+        if (edge.relation === "contains")
+            append(children, edge.source_node_id, edge.target_node_id);
+    const pending = [...directlyLoaded].filter((nodeId) => nodeKinds.get(nodeId) === "javascript-asset");
+    const resident = new Set();
+    for (let index = 0; index < pending.length; index += 1) {
+        const current = pending[index];
+        if (current === undefined)
+            break;
+        for (const child of children.get(current) ?? []) {
+            if (resident.has(child))
+                continue;
+            resident.add(child);
+            pending.push(child);
+        }
+    }
+    return resident;
+};
+const append = (values, key, value) => {
+    const current = values.get(key);
+    if (current === undefined)
+        values.set(key, [value]);
+    else
+        current.push(value);
+};
+const captureScriptsComplete = (evidenceId, entities) => entities.find(({ capture }) => capture.evidence.evidence_id === evidenceId)
+    ?.capture.scriptsCompleteWithinScope === true;
+const isLoadStateNode = (node) => node.kind === "javascript-asset" ||
+    node.kind === "javascript-chunk" ||
+    node.kind === "javascript-module";
+const state = (layer, node, input) => ({
+    static_layer_id: layer.layerId,
+    static_node_id: node.node_id,
+    kind: node.kind,
+    status: input.status,
+    runtime_node_ids: [...input.runtimeNodeIds],
+    reason: input.reason,
+});
+const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);

package/dist/domain/javascriptRuntimeReconciliation.js

@@ -0,0 +1,42 @@
+import { classifyStaticLoadStates } from "./javascriptRuntimeLoadState.js";
+import { buildReconciledApplicationGraph } from "./javascriptRuntimeReconciliationGraph.js";
+import { reconcileRuntimeEntities } from "./javascriptRuntimeReconciliationMatching.js";
+import { parseRuntimeCaptures, parseStaticLayers, } from "./javascriptRuntimeReconciliationParsing.js";
+import { createJavaScriptRuntimeReconciliationResult } from "./javascriptRuntimeReconciliationResult.js";
+import { reconcileJavaScriptRuntimeInputSchema } from "./javascriptRuntimeReconciliationSchemas.js";
+import { projectRuntimeCaptures } from "./javascriptRuntimeReconciliationRuntime.js";
+import { collectStaticRuntimeCandidates } from "./javascriptRuntimeStaticCandidates.js";
+/** Reconcile static JAG layers with authorized passive CDP Evidence. */
+export const reconcileJavaScriptRuntime = (input) => {
+    const parsed = reconcileJavaScriptRuntimeInputSchema.parse(input);
+    const layers = parseStaticLayers(parsed.static_layers);
+    const captures = parseRuntimeCaptures(parsed.runtime_observations);
+    const runtime = projectRuntimeCaptures(captures, parsed.limits.max_runtime_entities);
+    const candidates = collectStaticRuntimeCandidates(layers);
+    const matching = reconcileRuntimeEntities({
+        entities: runtime.entities,
+        candidates,
+        layers,
+        maximumItems: parsed.limits.max_reconciliation_items,
+    });
+    const loadStates = classifyStaticLoadStates(layers, runtime.entities, matching.items, {
+        maximumStates: parsed.limits.max_static_load_states,
+        reconciliationComplete: runtime.omittedEntities === 0 && matching.omittedItems === 0,
+    });
+    const graph = buildReconciledApplicationGraph({
+        layers,
+        captures,
+        runtime,
+        reconciliationEdges: matching.edges,
+        omittedReconciliationItems: matching.omittedItems,
+    });
+    return createJavaScriptRuntimeReconciliationResult({
+        layers,
+        captures,
+        runtime,
+        matching,
+        loadStates,
+        graph: graph.graph,
+        omittedGraphItems: graph.omittedGraphItems,
+    });
+};

package/dist/domain/javascriptRuntimeReconciliationGraph.js

@@ -0,0 +1,169 @@
+import { compareCodePoints, createJavaScriptApplicationGraph, createJavaScriptApplicationNode, } from "./javascriptApplicationGraph.js";
+/** Merge source graphs, runtime nodes, and inferred mappings into one valid JAG. */
+export const buildReconciledApplicationGraph = (input) => {
+    const merged = mergeNodes([
+        ...input.layers.flatMap(({ graph }) => graph.nodes),
+        ...input.runtime.nodes,
+    ]);
+    const allEdges = uniqueEdges([
+        ...input.layers.flatMap(({ graph }) => graph.edges),
+        ...input.runtime.edges,
+        ...input.reconciliationEdges,
+    ]);
+    const bounded = boundGraphContent(input, merged.nodes, allEdges);
+    const facts = graphCoverageFacts(input, merged.omittedObservations + bounded.omittedItems);
+    const graph = createJavaScriptApplicationGraph({
+        schema: "JavaScriptApplicationGraph",
+        schema_version: 1,
+        root_node_ids: bounded.rootNodeIds,
+        nodes: bounded.nodes,
+        edges: bounded.edges,
+        coverage: graphCoverage(input, facts, bounded.nodes.length),
+        limitations: uniqueSorted([
+            ...input.layers.flatMap(({ graph }) => graph.limitations),
+            "Runtime presence is bounded to passive capture windows and does not prove feature execution.",
+            "Cross-layer observed_as edges are inferences; digest equality proves byte identity only.",
+            "Source-map relationships retain their original static authority and are not promoted into runtime matches.",
+            ...(facts.inputTruncated
+                ? [
+                    "One or more source graphs or passive captures were incomplete or truncated.",
+                ]
+                : []),
+            ...(facts.outputTruncated
+                ? [
+                    "The reconciled graph omitted entities or classifications at caller limits.",
+                ]
+                : []),
+        ]),
+    });
+    return {
+        graph,
+        omittedGraphItems: merged.omittedObservations + bounded.omittedItems,
+    };
+};
+const boundGraphContent = (input, nodes, edges) => {
+    const allRoots = preferredRootIds(input);
+    const rootNodeIds = allRoots.slice(0, 1_000);
+    const roots = new Set(rootNodeIds);
+    const sortedNodes = [...nodes].sort((left, right) => compareCodePoints(left.node_id, right.node_id));
+    const retainedNodes = [
+        ...sortedNodes.filter(({ node_id: id }) => roots.has(id)),
+        ...sortedNodes.filter(({ node_id: id }) => !roots.has(id)),
+    ].slice(0, 100_000);
+    const retainedIds = new Set(retainedNodes.map(({ node_id: id }) => id));
+    const retainedEdges = [...edges]
+        .sort((left, right) => compareCodePoints(left.edge_id, right.edge_id))
+        .filter(({ source_node_id: source, target_node_id: target }) => retainedIds.has(source) && retainedIds.has(target))
+        .slice(0, 200_000);
+    return {
+        rootNodeIds,
+        nodes: retainedNodes,
+        edges: retainedEdges,
+        omittedItems: allRoots.length -
+            rootNodeIds.length +
+            (nodes.length - retainedNodes.length) +
+            (edges.length - retainedEdges.length),
+    };
+};
+const preferredRootIds = (input) => {
+    const runtime = [...input.runtime.targetNodeByEvidenceId.values()].map(({ node_id: id }) => id);
+    const application = input.layers
+        .filter(({ role }) => role === "application")
+        .flatMap(({ graph }) => graph.root_node_ids);
+    const supplemental = input.layers
+        .filter(({ role }) => role !== "application")
+        .flatMap(({ graph }) => graph.root_node_ids);
+    return [...new Set([...runtime, ...application, ...supplemental])];
+};
+const graphCoverageFacts = (input, omittedNodeObservations) => {
+    const projectionOmissions = input.runtime.omittedEntities +
+        input.omittedReconciliationItems +
+        omittedNodeObservations;
+    const captureTruncated = input.captures.some(({ inspection }) => inspection.completeness.conditions.includes("truncated"));
+    const captureHasUnknownOmissions = input.captures.some(({ inspection }) => inspection.completeness.unavailable_sections.length > 0);
+    const inputTruncated = input.layers.some(({ graph }) => graph.coverage.truncated) ||
+        captureTruncated;
+    const outputTruncated = projectionOmissions > 0;
+    const sourceOmissions = input.layers.reduce((total, { graph }) => total + (graph.coverage.omitted_count ?? 0), 0);
+    const omissionsKnown = !captureTruncated &&
+        !captureHasUnknownOmissions &&
+        input.layers.every(({ graph }) => graph.coverage.omitted_count !== null);
+    return {
+        projectionOmissions,
+        knownOmissions: projectionOmissions + sourceOmissions,
+        omissionsKnown,
+        inputTruncated,
+        outputTruncated,
+        truncated: inputTruncated || outputTruncated,
+        complete: !inputTruncated &&
+            !outputTruncated &&
+            input.layers.every(({ graph }) => graph.coverage.status === "complete") &&
+            input.captures.every(({ inspection }) => inspection.completeness.status === "complete_within_window"),
+    };
+};
+const graphCoverage = (input, facts, nodeCount) => facts.complete
+    ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
+    : facts.truncated
+        ? {
+            status: "partial",
+            truncated: true,
+            omitted_count: facts.omissionsKnown ? facts.knownOmissions : null,
+            limits: [
+                ...(facts.inputTruncated
+                    ? [
+                        {
+                            name: "runtime-reconciliation-input-coverage",
+                            value: input.layers.length + input.captures.length,
+                            unit: "items",
+                        },
+                    ]
+                    : []),
+                ...(facts.outputTruncated
+                    ? [
+                        {
+                            name: "runtime-reconciliation-output-limits",
+                            value: nodeCount,
+                            unit: "items",
+                        },
+                    ]
+                    : []),
+            ],
+        }
+        : {
+            status: "partial",
+            truncated: false,
+            omitted_count: facts.omissionsKnown ? facts.knownOmissions : null,
+            limits: [],
+        };
+const mergeNodes = (nodes) => {
+    const grouped = new Map();
+    for (const node of nodes)
+        grouped.set(node.node_id, [...(grouped.get(node.node_id) ?? []), node]);
+    let omittedObservations = 0;
+    const merged = [...grouped.values()].map((group) => {
+        const first = group[0];
+        if (first === undefined)
+            throw new TypeError("Empty JAG node group");
+        if (group.some(({ kind, identity }) => kind !== first.kind ||
+            JSON.stringify(identity) !== JSON.stringify(first.identity)))
+            throw new TypeError("Colliding JAG node identifiers disagree");
+        const observations = [
+            ...new Map(group
+                .flatMap(({ observations: values }) => values)
+                .map((observation) => [observation.observation_id, observation])).values(),
+        ].sort((left, right) => compareCodePoints(left.observation_id, right.observation_id));
+        omittedObservations += Math.max(0, observations.length - 64);
+        return createJavaScriptApplicationNode({
+            kind: first.kind,
+            identity: first.identity,
+            observations: observations
+                .slice(0, 64)
+                .map(({ observation_id: _id, identifier_strategy: _strategy, ...value }) => value),
+        });
+    });
+    return { nodes: merged, omittedObservations };
+};
+const uniqueEdges = (edges) => [
+    ...new Map(edges.map((edge) => [edge.edge_id, edge])).values(),
+];
+const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);