rea-agents 3.1.0 → 3.2.1

package/dist/domain/electronStaticAnalysisIpc.js

@@ -21,29 +21,53 @@ const inspectIpcCall = (node, context) => {
     const channel = channelValue.status === "literal" && typeof channelValue.value === "string"
         ? channelValue.value
         : null;
-    const channelExpression = channel === null
-        ? channelValue.status === "dynamic"
-            ? channelValue.expression
-            : boundedExpression(context.source, channelNode)
-        : null;
-    const hasHandler = descriptor.mode === "listen" || descriptor.mode === "handle";
-    const handlerNode = hasHandler ? argumentNode(node.arguments[1]) : undefined;
+    const channelReference = channel === null
+        ? {
+            channel: null,
+            channel_expression: channelValue.status === "dynamic"
+                ? channelValue.expression
+                : boundedExpression(context.source, channelNode),
+        }
+        : { channel, channel_expression: null };
+    const handlerNode = descriptor.mode === "listen" || descriptor.mode === "handle"
+        ? argumentNode(node.arguments[1])
+        : undefined;
+    const findingState = descriptor.mode === "send"
+        ? {
+            ...descriptor,
+            handler_kind: null,
+            handler_location: null,
+        }
+        : descriptor.mode === "invoke"
+            ? {
+                ...descriptor,
+                handler_kind: null,
+                handler_location: null,
+            }
+            : handlerNode === undefined
+                ? {
+                    ...descriptor,
+                    handler_kind: "missing",
+                    handler_location: null,
+                }
+                : {
+                    ...descriptor,
+                    handler_kind: handlerKind(handlerNode),
+                    handler_location: range(handlerNode),
+                };
     if (channel === null)
         context.accumulator.unknownFindings += 1;
-    if (hasHandler && handlerNode === undefined)
+    if (findingState.handler_kind === "missing")
         context.accumulator.unknownFindings += 1;
     const finding = {
-        ...descriptor,
-        channel,
-        channel_expression: channelExpression,
-        handler_kind: hasHandler ? handlerKind(handlerNode) : null,
-        handler_location: handlerNode === undefined ? null : range(handlerNode),
+        ...findingState,
+        ...channelReference,
         module_key: null,
         location: range(node),
     };
     addLocatedFinding(context, {
         collection: context.accumulator.ipc,
-        key: `electron-ipc\0${descriptor.side}\0${descriptor.operation}\0${channel ?? channelExpression ?? "[missing]"}`,
+        key: `electron-ipc\0${descriptor.side}\0${descriptor.operation}\0${channelReference.channel ?? channelReference.channel_expression}`,
         node,
         value: finding,
     });

package/dist/domain/electronStaticAnalysisNative.js

@@ -1,7 +1,6 @@
 import * as t from "@babel/types";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
 import { argumentNode, calleeName, compareCodePoints, propertyName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
-const MAX_NATIVE_MEMBERS = 64;
 /** Inspect JavaScript-side imports and re-exports of native .node addons. */
 export const inspectElectronNativeNode = (node, context) => {
     if (t.isImportDeclaration(node))
@@ -91,12 +90,7 @@ const addBinding = (input) => {
     const unique = [
         ...new Set(input.members.filter((member) => member !== "")),
     ].sort(compareCodePoints);
-    const members = (unique.length === 0 ? ["*"] : unique).slice(0, MAX_NATIVE_MEMBERS);
-    const omitted = Math.max(0, unique.length - MAX_NATIVE_MEMBERS);
-    if (omitted > 0) {
-        context.accumulator.structuralTruncation = true;
-        context.accumulator.droppedFindings += omitted;
-    }
+    const members = unique.length === 0 ? ["*"] : unique;
     addLocatedFinding(context, {
         collection: context.accumulator.nativeAddonBindings,
         key: `native-addon-binding\0${kind}\0${specifier}\0${members.join("\0")}`,
@@ -105,7 +99,6 @@ const addBinding = (input) => {
             specifier,
             binding_kind: kind,
             members,
-            members_truncated: omitted > 0,
             module_key: null,
             location: range(node),
         },

package/dist/domain/electronStaticAnalysisValues.js

@@ -1,7 +1,6 @@
 import * as t from "@babel/types";
 import { compareCodePoints, propertyName, sourceSlice, } from "./javascriptStaticAnalysisHelpers.js";
-const MAX_EXPRESSION_CHARACTERS = 4_096;
-/** Preserve one literal value or the exact bounded inert expression. */
+/** Preserve one literal value or the exact inert expression. */
 export const electronStaticValue = (source, node) => {
     const literal = literalValue(node);
     return literal.found
@@ -12,17 +11,16 @@ export const electronStaticValue = (source, node) => {
             expression: boundedExpression(source, node),
         };
 };
-/** Return an actionable bounded expression without evaluating it. */
+/** Return an actionable expression without evaluating it. */
 export const boundedExpression = (source, node) => {
     if (node === null || node === undefined)
         return "[missing-expression]";
     const expression = sourceSlice(source, node).trim();
-    return (expression === "" ? `[${node.type}]` : expression).slice(0, MAX_EXPRESSION_CHARACTERS);
+    return expression === "" ? `[${node.type}]` : expression;
 };
 /** Read one named object property without following spreads or bindings. */
 export const objectProperty = (object, name) => object.properties.find((property) => t.isObjectProperty(property) && propertyName(property.key) === name);
-/** Classify a handler argument while retaining its exact source range. */
-export const handlerKind = (node) => {
+export function handlerKind(node) {
     if (node === null || node === undefined)
         return "missing";
     if (t.isArrowFunctionExpression(node) ||
@@ -34,22 +32,20 @@ export const handlerKind = (node) => {
     if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
         return "member-expression";
     return "dynamic-expression";
-};
-/** Collect bounded dotted keys from one literal contextBridge API object. */
-export const collectContextBridgeMembers = (node, maximum = 128) => {
+}
+/** Collect statically visible dotted keys from one literal contextBridge API object. */
+export const collectContextBridgeMembers = (node) => {
     if (node === null || node === undefined)
         return {
             status: "missing",
             members: [],
             unknown: 0,
-            omitted: 0,
         };
     if (!t.isObjectExpression(node))
         return {
             status: "dynamic",
             members: [],
             unknown: 1,
-            omitted: 0,
         };
     const state = {
         members: [],
@@ -59,9 +55,8 @@ export const collectContextBridgeMembers = (node, maximum = 128) => {
     const members = [...new Set(state.members)].sort(compareCodePoints);
     return {
         status: "object-literal",
-        members: members.slice(0, maximum),
+        members,
         unknown: state.unknown,
-        omitted: Math.max(0, members.length - maximum),
     };
 };
 const collectMembersAt = (object, prefix, depth, state) => {
@@ -79,7 +74,7 @@ const collectMembersAt = (object, prefix, depth, state) => {
             state.unknown += 1;
             continue;
         }
-        const path = (prefix === "" ? name : `${prefix}.${name}`).slice(0, MAX_EXPRESSION_CHARACTERS);
+        const path = prefix === "" ? name : `${prefix}.${name}`;
         state.members.push(path);
         if (t.isObjectProperty(property) && t.isObjectExpression(property.value))
             collectMembersAt(property.value, path, depth + 1, state);
@@ -95,9 +90,7 @@ const literalValue = (node) => {
     if (t.isTemplateLiteral(node) && node.expressions.length === 0)
         return {
             found: true,
-            value: (node.quasis[0]?.value.cooked ??
-                node.quasis[0]?.value.raw ??
-                "").slice(0, MAX_EXPRESSION_CHARACTERS),
+            value: node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? "",
         };
     if (t.isUnaryExpression(node, { operator: "-" }) &&
         t.isNumericLiteral(node.argument))

package/dist/domain/errors.js

@@ -15,9 +15,7 @@ const ANALYSIS_ERROR_TAGS = [
     "ArtifactOperationError",
     "ProcessCaptureError",
     "EvidenceIntegrityError",
-    "EvidenceLimitError",
     "EvidenceFileError",
-    "InvestigationWorkspaceError",
     "UnknownRegistryError",
     "HopperTimeoutError",
     "HopperCancelledError",
@@ -109,20 +107,9 @@ export class ProviderSelectionError extends AnalysisError {
     candidateIds;
     rejections;
     userMessage;
-    constructor(input) {
-        const legacy = typeof input === "string";
-        const options = legacy
-            ? {
-                operation: input,
-                reason: "provider_unavailable",
-                requestedProviderId: "auto",
-                candidateIds: [],
-            }
-            : input;
+    constructor(options) {
         const operation = options.operation ?? "open_binary";
-        super(legacy
-            ? `No configured provider can execute ${operation}`
-            : providerSelectionDiagnostic(options));
+        super(providerSelectionDiagnostic(options));
         this.operation = operation;
         this.reason = options.reason;
         this.requestedProviderId = options.requestedProviderId;
@@ -214,17 +201,6 @@ export class EvidenceReferenceError extends EvidenceIntegrityError {
         this.actual = actual;
     }
 }
-/** A bounded evidence ledger cannot accept more records or serialized bytes. */
-export class EvidenceLimitError extends AnalysisError {
-    limit;
-    maximum;
-    _tag = "EvidenceLimitError";
-    constructor(limit, maximum) {
-        super(`Evidence ledger ${limit} limit exceeded (${String(maximum)})`);
-        this.limit = limit;
-        this.maximum = maximum;
-    }
-}
 /** Evidence bundle filesystem access failed within the configured policy. */
 export class EvidenceFileError extends AnalysisError {
     operation;
@@ -236,17 +212,6 @@ export class EvidenceFileError extends AnalysisError {
         this.reason = reason;
     }
 }
-/** Persistent investigation workspace access or CAS validation failed. */
-export class InvestigationWorkspaceError extends AnalysisError {
-    operation;
-    reason;
-    _tag = "InvestigationWorkspaceError";
-    constructor(operation, reason, options) {
-        super(`Investigation workspace ${operation} failed: ${reason}`, options);
-        this.operation = operation;
-        this.reason = reason;
-    }
-}
 /** Residual-unknown mutation failed a lifecycle, reference, or CAS invariant. */
 export class UnknownRegistryError extends AnalysisError {
     reason;
@@ -259,10 +224,16 @@ export class UnknownRegistryError extends AnalysisError {
 /** Hopper did not respond within the configured operation deadline. */
 export class HopperTimeoutError extends HopperError {
     timeoutMs;
+    operation;
+    requestId;
+    providerState;
     _tag = "HopperTimeoutError";
-    constructor(timeoutMs) {
-        super(`Hopper did not respond within ${String(timeoutMs)}ms`);
+    constructor(timeoutMs, operation, requestId, providerState = "not_started") {
+        super(`Hopper ${operation === undefined ? "startup" : operation} timed out after ${String(timeoutMs)}ms`);
         this.timeoutMs = timeoutMs;
+        this.operation = operation;
+        this.requestId = requestId;
+        this.providerState = providerState;
     }
 }
 /** The caller cancelled a Hopper operation before it completed. */
@@ -276,30 +247,37 @@ export class HopperCancelledError extends HopperError {
 export class HopperProtocolError extends HopperError {
     _tag = "HopperProtocolError";
 }
-/** Hopper's JSON-RPC endpoint returned an expected remote error response. */
 export class HopperRemoteError extends HopperError {
     code;
     safeMessage;
-    diagnosticType;
     _tag = "HopperRemoteError";
-    constructor(code, safeMessage, diagnosticType = "remote") {
+    diagnosticType;
+    operation;
+    requestId;
+    constructor(code, safeMessage, context = {}) {
         super(`Hopper request failed (${String(code)}): ${safeMessage}`);
         this.code = code;
         this.safeMessage = safeMessage;
-        this.diagnosticType = diagnosticType;
+        this.diagnosticType = context.diagnosticType ?? "remote";
+        this.operation = context.operation;
+        this.requestId = context.requestId;
     }
 }
 /** The owned Hopper bridge stopped before its client was closed. */
 export class HopperProcessError extends HopperError {
     exitCode;
     diagnostic;
+    operation;
+    requestId;
     _tag = "HopperProcessError";
     failureCode;
     userMessage;
-    constructor(exitCode, diagnostic) {
+    constructor(exitCode, diagnostic, operation, requestId) {
         super(`Hopper bridge stopped unexpectedly with code ${String(exitCode)}`);
         this.exitCode = exitCode;
         this.diagnostic = diagnostic;
+        this.operation = operation;
+        this.requestId = requestId;
         const failure = hopperStartupFailure(exitCode);
         this.failureCode = failure?.code;
         this.userMessage = failure?.message;
@@ -308,8 +286,12 @@ export class HopperProcessError extends HopperError {
 /** Hopper or the repository bridge could not be started. */
 export class HopperStartError extends HopperError {
     _tag = "HopperStartError";
+    userMessage;
+    ownerRunId;
     constructor(options) {
         super("Hopper application bridge could not be started", options);
+        this.userMessage = options?.userMessage;
+        this.ownerRunId = options?.ownerRunId;
     }
 }
 /** Runtime configuration could not be parsed safely. */
@@ -338,16 +320,13 @@ export class PermissionRequiredError extends AnalysisError {
     requested;
     missing;
     ceiling;
-    elicitationSupported;
-    restartRequired;
-    constructor(...args) {
-        const [requested, missing, ceiling, elicitationSupported, restartRequired] = args;
-        super(`Permission required for ${requested.capability}`);
-        this.requested = requested;
-        this.missing = missing;
-        this.ceiling = ceiling;
-        this.elicitationSupported = elicitationSupported;
-        this.restartRequired = restartRequired;
+    remediation;
+    constructor(context) {
+        super(`Permission required for ${context.requested.capability}`);
+        this.requested = context.requested;
+        this.missing = context.missing;
+        this.ceiling = context.ceiling;
+        this.remediation = context.remediation;
     }
 }
 /** Approved replay commitment no longer matches the immediately rebuilt plan. */

package/dist/domain/eventProcessTree.js

@@ -59,7 +59,7 @@ export const processTreeReconstructionSchema = z.strictObject({
     /** Root PID of the process tree. */
     root_pid: z.number().int().positive(),
     /** All reconstructed process nodes. */
-    processes: z.array(processNodeSchema).min(0).max(10_000),
+    processes: z.array(processNodeSchema).min(0),
     /** Events that were consumed. */
     events_consumed: z.number().int().nonnegative(),
     /** Events that could not be matched. */
@@ -178,10 +178,10 @@ export function getDescendants(processes, rootPid) {
     const visited = new Set();
     const result = [];
     const queue = [rootPid];
-    while (queue.length > 0) {
-        const pid = queue.shift();
+    for (let head = 0; head < queue.length; head += 1) {
+        const pid = queue[head];
         if (pid === undefined)
-            break;
+            continue;
         if (visited.has(pid))
             continue;
         visited.add(pid);
@@ -204,14 +204,22 @@ export function containsProcess(processes, pid) {
 /** Get the maximum tree depth from the root. */
 export function maxTreeDepth(processes, rootPid) {
     const byPid = new Map(processes.map((p) => [p.pid, p]));
-    function depth(pid, visited) {
-        if (visited.has(pid))
-            return 0;
-        visited.add(pid);
-        const node = byPid.get(pid);
+    const pending = [{ pid: rootPid, depth: 0 }];
+    const visited = new Set();
+    let maximumDepth = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current || visited.has(current.pid))
+            continue;
+        visited.add(current.pid);
+        const node = byPid.get(current.pid);
         if (!node || node.children.length === 0)
-            return 0;
-        return 1 + Math.max(...node.children.map((c) => depth(c, visited)));
+            continue;
+        const childDepth = current.depth + 1;
+        maximumDepth = Math.max(maximumDepth, childDepth);
+        for (const childPid of node.children)
+            if (!visited.has(childPid))
+                pending.push({ pid: childPid, depth: childDepth });
     }
-    return depth(rootPid, new Set());
+    return maximumDepth;
 }

package/dist/domain/evidence.js

@@ -72,7 +72,6 @@ const executionEnvironmentSchema = z.object({
 });
 const evidenceBaseSchema = z
     .object({
-    schema_version: z.literal(2),
     evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
     subject: subjectSchema.nullable(),
     provider: providerSchema,
@@ -124,7 +123,6 @@ const canonicalJson = (value) => {
     return serialized;
 };
 const semanticProjection = (evidence) => ({
-    schema_version: evidence.schema_version,
     subject: evidence.subject === null
         ? null
         : {
@@ -152,18 +150,13 @@ const semanticProjection = (evidence) => ({
 const computeEvidenceId = (evidence) => `ev_${sha256(canonicalJson(semanticProjection(evidence)))}`;
 /** Parse evidence and reject a syntactically valid but tampered semantic ID. */
 export const parseEvidence = (input) => {
-    if (typeof input === "object" &&
-        input !== null &&
-        "schema_version" in input &&
-        input.schema_version !== 2)
-        throw new TypeError(`Unsupported evidence schema_version ${String(input.schema_version)}; Evidence v1 is not accepted. Produce Evidence v2.`);
     const evidence = evidenceRecordSchema.parse(input);
     const { evidence_id: evidenceId, ...withoutId } = evidence;
     if (computeEvidenceId(withoutId) !== evidenceId)
         throw new TypeError("Evidence semantic identifier does not match its record");
     return evidence;
 };
-/** Build deterministic Evidence v2 from an immutable artifact subject. */
+/** Build deterministic Evidence from an immutable artifact subject. */
 export const createEvidence = (target, provider, observation) => {
     const subject = target === undefined
         ? null
@@ -175,7 +168,6 @@ export const createEvidence = (target, provider, observation) => {
             local_path: target.path,
         };
     const semantic = {
-        schema_version: 2,
         subject: subject === null
             ? null
             : {
@@ -191,7 +183,7 @@ export const createEvidence = (target, provider, observation) => {
         ...(observation.analysisProfile === undefined
             ? {}
             : { analysis_profile: observation.analysisProfile }),
-        predicate_type: observation.predicateType ?? "rea.analysis/v2",
+        predicate_type: observation.predicateType ?? "rea.analysis",
         operation: observation.operation,
         parameters: observation.parameters,
         raw_result: observation.rawResult ?? null,

package/dist/domain/evidenceBundle.js

@@ -21,7 +21,6 @@ const captureManifestSchema = z.object({
     predicate_type: z.string().min(1),
 });
 export const evidenceBundleSchema = z.object({
-    bundle_version: z.literal(2),
     artifacts: z.array(artifactManifestSchema),
     providers: z.array(providerManifestSchema),
     environments: z.array(environmentManifestSchema),
@@ -34,7 +33,6 @@ export const evidenceBundleSchema = z.object({
 export const createEvidenceBundle = (records, unknowns = []) => {
     const sortedRecords = [...records].sort((left, right) => left.evidence_id.localeCompare(right.evidence_id));
     return {
-        bundle_version: 2,
         artifacts: uniqueSorted(sortedRecords.flatMap(({ subject }) => subject === null
             ? []
             : [
@@ -55,7 +53,7 @@ export const createEvidenceBundle = (records, unknowns = []) => {
                 },
             ]
             : []),
-        captures: sortedRecords.flatMap((evidence) => evidence.predicate_type.startsWith("rea.process-capture/")
+        captures: sortedRecords.flatMap((evidence) => evidence.predicate_type === "rea.process-capture"
             ? [
                 {
                     evidence_id: evidence.evidence_id,
@@ -81,7 +79,7 @@ export const evidenceBundleForTarget = (bundle, sha256) => {
                 return (record?.subject?.digest.sha256 === sha256 ||
                     (unknown.mutation_evidence_ids.includes(id) &&
                         record?.subject === null &&
-                        record.predicate_type === "rea.residual-unknown-mutation/v1"));
+                        record.predicate_type === "rea.residual-unknown-mutation"));
             }));
         changed = retained.length !== unknowns.length;
         unknowns = retained;
@@ -157,7 +155,7 @@ const validateVerifiedResolution = (unknown, evidenceById) => {
         const evidence = evidenceById.get(evidenceId);
         return (unknown.supporting_evidence_ids.includes(evidenceId) &&
             evidence !== undefined &&
-            evidence.predicate_type !== "rea.residual-unknown-mutation/v1" &&
+            evidence.predicate_type !== "rea.residual-unknown-mutation" &&
             evidenceQualifies(unknown, evidence));
     });
     if (qualifies !== true)

package/dist/domain/evidenceCompletionLedger.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]{0,99}$/u);
+const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
 /** Terminal outcome recorded for one verifier claim. */
 export const evidenceCompletionStatusSchema = z.enum([
     "pass",
@@ -15,10 +15,10 @@ export const evidenceCompletionStatusSchema = z.enum([
 export const evidenceCompletionRecordSchema = z.strictObject({
     claim_id: claimIdSchema,
     status: evidenceCompletionStatusSchema,
-    evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+    evidence_ids: z.array(evidenceIdSchema).min(1),
 });
 const completionSummarySchema = z.strictObject({
-    total: z.number().int().min(1).max(10_000),
+    total: z.number().int().min(1),
     pass: z.number().int().nonnegative(),
     fail: z.number().int().nonnegative(),
     unsupported: z.number().int().nonnegative(),
@@ -27,9 +27,8 @@ const completionSummarySchema = z.strictObject({
     complete: z.boolean(),
 });
 const completionLedgerObjectSchema = z.strictObject({
-    schema_version: z.literal(1),
     ledger_id: z.string().regex(/^ecl_[a-f0-9]{64}$/u),
-    records: z.array(evidenceCompletionRecordSchema).min(1).max(10_000),
+    records: z.array(evidenceCompletionRecordSchema).min(1),
     summary: completionSummarySchema,
 });
 const compareIdentifiers = (left, right) => left < right ? -1 : left > right ? 1 : 0;
@@ -57,7 +56,7 @@ const canonicalJson = (value) => {
     return serialized;
 };
 const computeLedgerId = (records) => `ecl_${createHash("sha256")
-    .update(canonicalJson({ schema_version: 1, records }))
+    .update(canonicalJson({ records }))
     .digest("hex")}`;
 const ledgerIssues = (ledger, context) => {
     if (!isSortedUnique(ledger.records.map((record) => record.claim_id)))
@@ -86,7 +85,7 @@ const ledgerIssues = (ledger, context) => {
             message: "Completion ledger identifier does not match its records",
         });
 };
-/** Strict path-free Evidence v2 completion ledger. */
+/** Strict path-free Evidence completion ledger. */
 export const evidenceCompletionLedgerSchema = completionLedgerObjectSchema.superRefine(ledgerIssues);
 /** Build a canonical path-independent ledger from verifier claim outcomes. */
 export const createEvidenceCompletionLedger = (input) => {
@@ -103,7 +102,6 @@ export const createEvidenceCompletionLedger = (input) => {
         if (!isSortedUnique(record.evidence_ids))
             throw new TypeError("Completion Evidence IDs must be unique per claim");
     return evidenceCompletionLedgerSchema.parse({
-        schema_version: 1,
         ledger_id: computeLedgerId(records),
         records,
         summary: summarize(records),

package/dist/domain/functionComparison.js

@@ -4,19 +4,15 @@ import { functionComparisonResultSchema, } from "./functionComparisonSchemas.js"
 import { overallStatus, summarize, canonicalJson, } from "./functionComparisonResults.js";
 import { compareDimensions } from "./functionComparisonDimensions.js";
 export { functionComparisonInputSchema, functionComparisonResultSchema, } from "./functionComparisonSchemas.js";
-/** Compare two explicit function Evidence page sets without fuzzy matching. */
-export const compareFunctions = (leftInput, rightInput, offset, limit) => {
+/** 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.map(({ evidence_id: id }) => id),
-        ...right.evidence.map(({ evidence_id: id }) => id),
-    ];
+    const links = [left.evidence[0].evidence_id, right.evidence[0].evidence_id];
     const providersDiffer = canonicalJson(left.provider) !== canonicalJson(right.provider);
     const dimensions = compareDimensions(left, right, links, providersDiffer);
     const match = functionMatch(left, right);
     const changes = dimensions.filter(({ status }) => status !== "unchanged");
-    const page = changes.slice(offset, offset + limit);
     return functionComparisonResultSchema.parse({
         status: overallStatus(dimensions, match.status),
         function_match: match,
@@ -24,13 +20,7 @@ export const compareFunctions = (leftInput, rightInput, offset, limit) => {
         right_subject_sha256: right.subject.digest.sha256,
         summary: summarize(dimensions),
         dimensions,
-        changes: {
-            items: page,
-            offset,
-            limit,
-            total: changes.length,
-            next_offset: offset + page.length < changes.length ? offset + page.length : null,
-        },
+        changes,
         limitations: [
             ...new Set([
                 ...left.limitations.map((item) => `Left: ${item}`),

package/dist/domain/functionComparisonNormalization.js

@@ -124,19 +124,12 @@ export const stringAndNameProjection = (snapshot) => {
 };
 export const sorted = (values) => [...values].sort((left, right) => canonicalJson(left).localeCompare(canonicalJson(right)));
 export const combineCoverage = (left, right) => {
-    const base = {
+    return {
         items: [...left.items, ...right.items],
-        total: left.total === null || right.total === null
-            ? null
-            : left.total + right.total,
+        total: left.total + right.total,
+        complete: true,
+        truncated: false,
     };
-    return left.complete && right.complete
-        ? { ...base, complete: true, truncated: false }
-        : {
-            ...base,
-            complete: false,
-            truncated: left.truncated || right.truncated,
-        };
 };
 export const project = (collection, mapper) => collection.items.map(mapper);
 export const isAutoName = (name) => /^(?:sub_[0-9a-f]+|fcn\.)/iu.test(name);