rea-agents 3.0.0 → 3.2.0

package/dist/domain/sourceToBundleComparison.js

@@ -8,15 +8,12 @@ export const compareSourceToBundle = (input) => {
     const mappings = compareMappings(input, projection);
     const factors = {
         ...projection.factors,
-        omittedCandidateEvaluations: mappings.omittedCandidateEvaluations,
-        omittedCandidateReferences: mappings.omittedCandidateReferences,
     };
     const mappedCurrentIds = new Set(mappings.items.flatMap(({ current_node_ids: nodeIds }) => nodeIds));
     const unmappedCurrentNodeIds = projection.currentNodes
         .map(({ node_id: nodeId }) => nodeId)
         .filter((nodeId) => !mappedCurrentIds.has(nodeId));
     const semanticResult = {
-        schema_version: 1,
         reference: {
             root_sha256: input.reference.root_sha256,
             inventory_state: input.reference.inventory_state,
@@ -42,10 +39,8 @@ export const compareSourceToBundle = (input) => {
 const projectComparison = (input) => {
     const allSources = historicalSourceFiles(input.reference);
     const allCurrentNodes = sourceBearingNodes(input.application.graph.nodes);
-    const sources = allSources.slice(0, input.limits.max_source_files);
-    const currentNodes = allCurrentNodes.slice(0, input.limits.max_application_nodes);
-    const omittedSourceFiles = allSources.length - sources.length;
-    const omittedApplicationNodes = allCurrentNodes.length - currentNodes.length;
+    const sources = allSources;
+    const currentNodes = allCurrentNodes;
     const index = buildSourceToBundleCandidateIndex(currentNodes);
     return {
         sources,
@@ -53,41 +48,23 @@ const projectComparison = (input) => {
         index,
         absenceComplete: input.reference.inventory_state === "complete" &&
             input.application.graph.coverage.status === "complete" &&
-            !input.application.graph.coverage.truncated &&
-            omittedSourceFiles === 0 &&
-            omittedApplicationNodes === 0 &&
-            !index.pathIndexTruncated,
+            !input.application.graph.coverage.truncated,
         factors: {
             input,
-            omittedSourceFiles,
-            omittedApplicationNodes,
-            omittedCandidateEvaluations: 0,
-            omittedCandidateReferences: 0,
-            pathIndexTruncated: index.pathIndexTruncated,
         },
     };
 };
 const compareMappings = (input, projection) => {
-    let evaluationsRemaining = input.limits.max_candidate_evaluations;
     let candidateEvaluations = 0;
-    let omittedCandidateEvaluations = 0;
-    let omittedCandidateReferences = 0;
     const provisionalItems = [];
     for (const source of projection.sources) {
         const candidateIds = candidateIdsForSource(source, projection.index);
-        const retainedIds = candidateIds.slice(0, evaluationsRemaining);
-        const omittedEvaluations = candidateIds.length - retainedIds.length;
-        evaluationsRemaining -= retainedIds.length;
-        candidateEvaluations += retainedIds.length;
-        omittedCandidateEvaluations += omittedEvaluations;
-        const scored = retainedIds
+        candidateEvaluations += candidateIds.length;
+        const scored = candidateIds
             .map((nodeId) => scoreSourceToBundleCandidate(source, nodeId, projection.index))
             .filter((candidate) => candidate !== null)
             .sort(compareCandidates);
-        const retainedCandidates = scored.slice(0, input.limits.max_candidate_nodes);
-        const omittedCandidates = omittedEvaluations + scored.length - retainedCandidates.length;
-        omittedCandidateReferences += omittedCandidates;
-        const classification = classifyMapping(retainedCandidates, omittedCandidates === 0, projection.absenceComplete);
+        const classification = classifyMapping(scored, projection.absenceComplete);
         const semantic = {
             source_path: source.path,
             source_sha256: source.sha256,
@@ -95,16 +72,10 @@ const compareMappings = (input, projection) => {
             status: classification.status,
             confidence: classification.confidence,
             current_node_ids: classification.currentNodeIds,
-            candidates: retainedCandidates,
-            omitted_candidates: omittedCandidates,
+            candidates: scored,
             limitations: uniqueSorted([
                 ...source.limitations,
                 ...classification.limitations,
-                ...(omittedCandidates > 0
-                    ? [
-                        `${String(omittedCandidates)} candidate references were omitted by comparison limits.`,
-                    ]
-                    : []),
             ]),
         };
         provisionalItems.push({
@@ -115,8 +86,6 @@ const compareMappings = (input, projection) => {
     return {
         items: markMergedMappings(input, provisionalItems),
         candidateEvaluations,
-        omittedCandidateEvaluations,
-        omittedCandidateReferences,
     };
 };
 const comparisonCoverage = (projection, mappings, factors) => ({
@@ -124,32 +93,18 @@ const comparisonCoverage = (projection, mappings, factors) => ({
     reference_inventory_state: factors.input.reference.inventory_state,
     application_graph_status: factors.input.application.graph.coverage.status,
     retained_source_files: projection.sources.length,
-    omitted_source_files: factors.omittedSourceFiles,
     retained_application_nodes: projection.currentNodes.length,
-    omitted_application_nodes: factors.omittedApplicationNodes,
     candidate_evaluations: mappings.candidateEvaluations,
-    omitted_candidate_evaluations: mappings.omittedCandidateEvaluations,
-    omitted_candidate_references: mappings.omittedCandidateReferences,
-    omitted_unmapped_current_nodes: 0,
 });
 const scoringModel = () => ({
-    algorithm: "rea-source-to-bundle-signals/v1",
+    algorithm: "rea-source-to-bundle-signals",
     minimum_candidate_score: 20,
-    weights: Object.entries(SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS).map(([signal, weight]) => ({
-        signal: signal,
+    weights: SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS.map(([signal, weight]) => ({
+        signal,
         weight,
     })),
 });
-const classifyMapping = (candidates, evaluationComplete, absenceComplete) => {
-    if (!evaluationComplete)
-        return {
-            status: "unknown",
-            confidence: "unknown",
-            currentNodeIds: [],
-            limitations: [
-                "Candidate evaluation stopped at the declared limit; a stronger match may be omitted.",
-            ],
-        };
+const classifyMapping = (candidates, absenceComplete) => {
     const exact = candidates.filter((candidate) => hasSignal(candidate, "exact-source-digest"));
     if (exact.length === 1)
         return {
@@ -271,12 +226,6 @@ const comparisonSummary = (items) => ({
 });
 const countStatus = (items, status) => items.filter((item) => item.status === status).length;
 const coverageStatus = (factors) => {
-    if (factors.omittedSourceFiles > 0 ||
-        factors.omittedApplicationNodes > 0 ||
-        factors.omittedCandidateEvaluations > 0 ||
-        factors.omittedCandidateReferences > 0 ||
-        factors.pathIndexTruncated)
-        return "truncated";
     return factors.input.reference.inventory_state === "complete" &&
         factors.input.application.graph.coverage.status === "complete"
         ? "complete-within-inputs"
@@ -296,31 +245,6 @@ const comparisonLimitations = (factors) => uniqueSorted([
         : [
             `Application graph coverage is ${factors.input.application.graph.coverage.status}; unmatched files remain unknown.`,
         ]),
-    ...(factors.omittedSourceFiles > 0
-        ? [
-            `${String(factors.omittedSourceFiles)} historical source files were omitted by max_source_files.`,
-        ]
-        : []),
-    ...(factors.omittedApplicationNodes > 0
-        ? [
-            `${String(factors.omittedApplicationNodes)} source-bearing application nodes were omitted by max_application_nodes.`,
-        ]
-        : []),
-    ...(factors.omittedCandidateEvaluations > 0
-        ? [
-            `${String(factors.omittedCandidateEvaluations)} candidate evaluations were omitted by max_candidate_evaluations.`,
-        ]
-        : []),
-    ...(factors.omittedCandidateReferences > 0
-        ? [
-            `${String(factors.omittedCandidateReferences)} candidate references were omitted from item output.`,
-        ]
-        : []),
-    ...(factors.pathIndexTruncated
-        ? [
-            "At least one current path exceeded the 128-segment suffix index bound.",
-        ]
-        : []),
 ]);
 const hasSignal = (candidate, kind) => candidate.signals.some((signal) => signal.kind === kind);
 const compareCandidates = (left, right) => right.score - left.score ||

package/dist/domain/sourceToBundleComparisonSchemas.js

@@ -5,15 +5,15 @@ import { historicalSourceGraphSchema } from "./referenceSourceGraph.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
-export const SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS = {
-    "exact-source-digest": 100,
-    "source-map-original-path": 70,
-    "current-path-exact": 60,
-    "current-path-suffix": 40,
-    "basename-match": 20,
-    "language-extension": 5,
-};
+const textSchema = z.string().min(1);
+export const SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS = [
+    ["exact-source-digest", 100],
+    ["source-map-original-path", 70],
+    ["current-path-exact", 60],
+    ["current-path-suffix", 40],
+    ["basename-match", 20],
+    ["language-extension", 5],
+];
 const sourceToBundleSignalKindSchema = z.enum([
     "exact-source-digest",
     "source-map-original-path",
@@ -22,47 +22,29 @@ const sourceToBundleSignalKindSchema = z.enum([
     "basename-match",
     "language-extension",
 ]);
-const sourceToBundleLimitsSchema = z.strictObject({
-    max_source_files: z.number().int().min(1).max(100_000).default(10_000),
-    max_application_nodes: z.number().int().min(1).max(100_000).default(20_000),
-    max_candidate_nodes: z.number().int().min(1).max(1_000).default(100),
-    max_candidate_evaluations: z
-        .number()
-        .int()
-        .min(1)
-        .max(10_000_000)
-        .default(1_000_000),
-});
-/** Historical source inventory, authenticated application Evidence, and bounds. */
+/** Historical source inventory and authenticated application Evidence. */
 export const compareSourceToBundleInputSchema = z.strictObject({
     reference: historicalSourceGraphSchema,
     application: evidenceSchema,
-    limits: sourceToBundleLimitsSchema.default({
-        max_source_files: 10_000,
-        max_application_nodes: 20_000,
-        max_candidate_nodes: 100,
-        max_candidate_evaluations: 1_000_000,
-    }),
-    unknown_registry_approved: z.literal(true).optional(),
 });
 const sourceToBundleSignalSchema = z.strictObject({
     kind: sourceToBundleSignalKindSchema,
     weight: z.number().int().min(1).max(100),
-    source_value: boundedTextSchema,
-    current_values: z.array(boundedTextSchema).min(1).max(64),
+    source_value: textSchema,
+    current_values: z.array(textSchema).min(1),
 });
 const sourceToBundleCandidateSchema = z.strictObject({
     current_node_id: nodeIdSchema,
     current_node_kind: z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS),
-    score: z.number().int().min(1).max(300),
+    score: z.number().int().min(1),
     confidence: z.enum(["exact", "high", "medium", "low"]),
-    signals: z.array(sourceToBundleSignalSchema).min(1).max(6),
+    signals: z.array(sourceToBundleSignalSchema).min(1),
 });
 const sourceToBundleItemSchema = z.strictObject({
     mapping_id: z.string().regex(/^stbc_item_[a-f0-9]{64}$/u),
-    source_path: boundedTextSchema,
+    source_path: textSchema,
     source_sha256: digestSchema.nullable(),
-    source_language: z.string().min(1).max(100).nullable(),
+    source_language: textSchema.nullable(),
     status: z.enum([
         "unchanged",
         "modified",
@@ -73,14 +55,12 @@ const sourceToBundleItemSchema = z.strictObject({
         "unknown",
     ]),
     confidence: z.enum(["exact", "high", "medium", "unknown"]),
-    current_node_ids: z.array(nodeIdSchema).max(1_000),
-    candidates: z.array(sourceToBundleCandidateSchema).max(1_000),
-    omitted_candidates: z.number().int().min(0),
-    limitations: z.array(boundedTextSchema).max(100),
+    current_node_ids: z.array(nodeIdSchema),
+    candidates: z.array(sourceToBundleCandidateSchema),
+    limitations: z.array(textSchema),
 });
 /** Deterministic, evidence-bearing historical-source to shipped-bundle comparison. */
 export const sourceToBundleComparisonResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     comparison_id: z.string().regex(/^stbc_[a-f0-9]{64}$/u),
     reference: z.strictObject({
         root_sha256: digestSchema,
@@ -92,7 +72,7 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
         root_artifact_sha256: digestSchema,
     }),
     scoring: z.strictObject({
-        algorithm: z.literal("rea-source-to-bundle-signals/v1"),
+        algorithm: z.literal("rea-source-to-bundle-signals"),
         minimum_candidate_score: z.literal(20),
         weights: z.array(z.strictObject({
             signal: sourceToBundleSignalKindSchema,
@@ -108,10 +88,10 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
         duplicated: z.number().int().min(0),
         unknown: z.number().int().min(0),
     }),
-    items: z.array(sourceToBundleItemSchema).max(100_000),
-    unmapped_current_node_ids: z.array(nodeIdSchema).max(100_000),
+    items: z.array(sourceToBundleItemSchema),
+    unmapped_current_node_ids: z.array(nodeIdSchema),
     coverage: z.strictObject({
-        status: z.enum(["complete-within-inputs", "partial", "truncated"]),
+        status: z.enum(["complete-within-inputs", "partial"]),
         reference_inventory_state: z.enum(["complete", "partial", "unknown"]),
         application_graph_status: z.enum([
             "complete",
@@ -120,14 +100,9 @@ export const sourceToBundleComparisonResultSchema = z.strictObject({
             "unavailable",
         ]),
         retained_source_files: z.number().int().min(0),
-        omitted_source_files: z.number().int().min(0),
         retained_application_nodes: z.number().int().min(0),
-        omitted_application_nodes: z.number().int().min(0),
         candidate_evaluations: z.number().int().min(0),
-        omitted_candidate_evaluations: z.number().int().min(0),
-        omitted_candidate_references: z.number().int().min(0),
-        omitted_unmapped_current_nodes: z.number().int().min(0),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(1),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    evidence_links: z.array(evidenceIdSchema).length(1),
+    limitations: z.array(textSchema),
 });

package/dist/domain/sourceToBundleSignals.js

@@ -13,7 +13,12 @@ const PATH_PROPERTIES = [
     "resolved_path",
     "declared_path",
 ];
-const MAX_PATH_SUFFIXES = 128;
+const signalWeight = (kind) => {
+    const entry = SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS.find(([signal]) => signal === kind);
+    if (entry === undefined)
+        throw new TypeError(`Missing source-to-bundle signal weight: ${kind}`);
+    return entry[1];
+};
 /** Keep source-bearing application nodes in stable identifier order. */
 export const sourceBearingNodes = (nodes) => nodes
     .filter(({ kind }) => RELEVANT_NODE_KINDS.has(kind))
@@ -22,20 +27,17 @@ export const sourceBearingNodes = (nodes) => nodes
 export const historicalSourceFiles = (graph) => graph.entries
     .filter((entry) => entry.kind === "file" && entry.classifications.includes("source"))
     .sort((left, right) => compareText(left.path, right.path));
-/** Build bounded-key indices without assigning fuzzy matches. */
+/** Build deterministic candidate indices without assigning fuzzy matches. */
 export const buildSourceToBundleCandidateIndex = (nodes) => {
     const projections = nodes.map(projectCurrentNode);
     const byDigest = new Map();
     const byPathSuffix = new Map();
     const byBasename = new Map();
-    let pathIndexTruncated = false;
     for (const projection of projections) {
         for (const digest of projection.digests)
             addIndexValue(byDigest, digest, projection.node.node_id);
         for (const path of projection.paths) {
-            const suffixes = pathSuffixes(path.value);
-            pathIndexTruncated ||= suffixes.truncated;
-            for (const suffix of suffixes.values)
+            for (const suffix of pathSuffixes(path.value))
                 addIndexValue(byPathSuffix, suffix, projection.node.node_id);
             addIndexValue(byBasename, posix.basename(path.value), projection.node.node_id);
         }
@@ -45,7 +47,6 @@ export const buildSourceToBundleCandidateIndex = (nodes) => {
         byDigest,
         byPathSuffix,
         byBasename,
-        pathIndexTruncated,
     };
 };
 /** Candidate identifiers ordered by strongest available signal, then ID. */
@@ -145,9 +146,9 @@ const candidateSignals = (source, current) => {
 };
 const signal = (kind, sourceValue, currentValues) => ({
     kind,
-    weight: SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS[kind],
+    weight: signalWeight(kind),
     source_value: sourceValue,
-    current_values: [...new Set(currentValues)].sort(compareText).slice(0, 64),
+    current_values: [...new Set(currentValues)].sort(compareText),
 });
 const candidateConfidence = (signals) => {
     const kinds = new Set(signals.map(({ kind }) => kind));
@@ -185,13 +186,7 @@ const uniquePaths = (paths) => [
 ].sort((left, right) => compareText(`${left.kind}\0${left.value}`, `${right.kind}\0${right.value}`));
 const pathSuffixes = (path) => {
     const parts = path.split("/");
-    const start = Math.max(0, parts.length - MAX_PATH_SUFFIXES);
-    return {
-        values: parts
-            .slice(start)
-            .map((_, index) => parts.slice(start + index).join("/")),
-        truncated: start > 0,
-    };
+    return parts.map((_, index) => parts.slice(index).join("/"));
 };
 const addIndexValue = (index, key, nodeId) => {
     const values = index.get(key) ?? new Set();

package/dist/domain/staticRuntimeCorrelation.js

@@ -39,7 +39,7 @@ const observedPatternSchema = z.enum([
 const artifactSelectorSchema = z
     .object({
     kind: z.literal("artifact"),
-    logical_path: z.string().min(1).max(4_096),
+    logical_path: z.string().min(1),
 })
     .strict();
 const functionSelectorSchema = z
@@ -66,21 +66,18 @@ const mappingSchema = z
     side_alignment: z.enum(["left_to_left", "left_to_right"]),
     hypothesis: z
         .object({
-        statement: z.string().trim().min(1).max(500),
+        statement: z.string().trim().min(1),
         expected_pattern: expectedPatternSchema,
     })
         .strict(),
 })
     .strict();
-/** Strict bounded input for explicit static/runtime hypothesis correlation. */
+/** Strict input for explicit static/runtime hypothesis correlation. */
 export const staticRuntimeCorrelationInputSchema = z
     .object({
-    static_comparisons: z.array(evidenceSchema).min(1).max(100),
-    runtime_comparisons: z.array(evidenceSchema).min(1).max(100),
-    mappings: z.array(mappingSchema).min(1).max(500),
-    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(),
+    static_comparisons: z.array(evidenceSchema).min(1),
+    runtime_comparisons: z.array(evidenceSchema).min(1),
+    mappings: z.array(mappingSchema).min(1),
 })
     .strict();
 const correlationItemSchema = z.object({
@@ -102,15 +99,15 @@ const correlationItemSchema = z.object({
     }),
     side_alignment: z.enum(["left_to_left", "left_to_right"]),
     hypothesis: z.object({
-        statement: z.string().min(1).max(500),
+        statement: z.string().min(1),
         expected_pattern: expectedPatternSchema,
     }),
     observed_pattern: observedPatternSchema,
     classification: z.enum(["hypothesis", "contradiction", "unresolved_branch"]),
-    evidence_links: z.array(evidenceIdSchema).min(2).max(20_100),
+    evidence_links: z.array(evidenceIdSchema).min(2),
     limitations: z.array(z.string()),
 });
-/** Deterministic, paginated static/runtime correlation payload. */
+/** Deterministic static/runtime correlation payload. */
 export const staticRuntimeCorrelationResultSchema = z.object({
     status: z.enum(["correlated", "contradicted", "unknown", "truncated"]),
     summary: z.object({
@@ -119,28 +116,24 @@ export const staticRuntimeCorrelationResultSchema = z.object({
         unresolved: z.number().int().min(0),
     }),
     correlations: z.object({
-        items: z.array(correlationItemSchema).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(),
+        items: z.array(correlationItemSchema),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(2).max(20_100),
+    evidence_links: z.array(evidenceIdSchema).min(2),
     limitations: z.array(z.string()),
 });
 const EXPECTED = {
     compare_artifacts: [
-        "rea.artifact-comparison/v1",
+        "rea.artifact-comparison",
         "rea-artifact-comparison",
         "REA artifact comparison",
     ],
     compare_functions: [
-        "rea.function-comparison/v1",
+        "rea.function-comparison",
         "rea-function-comparison",
         "REA function comparison",
     ],
     compare_process_captures: [
-        ["rea.process-comparison/v3", "rea.process-comparison/v4"],
+        "rea.process-comparison",
         "rea-process",
         "REA deterministic process harness",
     ],
@@ -160,10 +153,7 @@ export const correlateStaticAndRuntime = (input) => {
     if (new Set(correlations.map(({ correlation_id: id }) => id)).size !==
         correlations.length)
         throw new TypeError("Static/runtime correlation rejects duplicate mappings");
-    const page = correlations.slice(parsed.offset, parsed.offset + parsed.limit);
     const links = uniqueSorted(correlations.flatMap(({ evidence_links: evidenceLinks }) => evidenceLinks));
-    if (links.length > 20_100)
-        throw new TypeError("Static/runtime Evidence closure exceeds limit");
     const unresolved = correlations.filter(({ classification }) => classification === "unresolved_branch");
     const contradictions = correlations.filter(({ classification }) => classification === "contradiction");
     return staticRuntimeCorrelationResultSchema.parse({
@@ -180,13 +170,7 @@ export const correlateStaticAndRuntime = (input) => {
             unresolved: unresolved.length,
         },
         correlations: {
-            items: page,
-            offset: parsed.offset,
-            limit: parsed.limit,
-            total: correlations.length,
-            next_offset: parsed.offset + page.length < correlations.length
-                ? parsed.offset + page.length
-                : null,
+            items: correlations,
         },
         evidence_links: links,
         limitations: [
@@ -242,24 +226,22 @@ const selectStatic = (evidence, selector) => {
             throw new TypeError("Function selector requires function comparison Evidence");
         const result = functionComparisonResultSchema.parse(evidence.normalized_result);
         const matches = result.dimensions.filter(({ dimension }) => dimension === selector.dimension);
-        if (matches.length !== 1)
+        const match = matches.at(0);
+        if (matches.length !== 1 || match === undefined)
             throw new TypeError("Function selector must resolve exactly once");
         return {
-            status: matches[0].status,
-            conclusion_kind: matches[0].conclusion_kind,
+            status: match.status,
+            conclusion_kind: match.conclusion_kind,
         };
     }
     if (evidence.operation !== "compare_artifacts")
         throw new TypeError("Artifact selector requires artifact comparison Evidence");
     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("Static/runtime correlation requires complete artifact comparison pagination");
-    const matches = result.changes.items.filter(({ logical_path: path }) => path === selector.logical_path);
-    if (matches.length !== 1)
+    const matches = result.changes.filter(({ logical_path: path }) => path === selector.logical_path);
+    const match = matches.at(0);
+    if (matches.length !== 1 || match === undefined)
         throw new TypeError("Artifact selector must resolve exactly one reported delta");
-    const status = matches[0].classification;
+    const status = match.classification;
     return {
         status,
         conclusion_kind: status === "contradiction"
@@ -277,8 +259,7 @@ const parseStatic = (input) => {
     assertComparisonIdentity(evidence);
     if (evidence.operation === "compare_artifacts") {
         const result = artifactComparisonResultSchema.parse(evidence.normalized_result);
-        assertCompleteArtifactResult(result);
-        assertNestedLinks(evidence, result.changes.items.flatMap(({ evidence_links: links }) => links));
+        assertNestedLinks(evidence, result.changes.flatMap(({ evidence_links: links }) => links));
     }
     else {
         const result = functionComparisonResultSchema.parse(evidence.normalized_result);
@@ -332,21 +313,30 @@ const comparisonParameterLinks = (evidence) => {
     }
     const parameters = z
         .object({
-        left_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-        right_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+        left_evidence_id: evidenceIdSchema.optional(),
+        right_evidence_id: evidenceIdSchema.optional(),
+        left_evidence_ids: z.array(evidenceIdSchema).min(1).optional(),
+        right_evidence_ids: z.array(evidenceIdSchema).min(1).optional(),
     })
         .passthrough()
         .parse(evidence.parameters);
-    return [...parameters.left_evidence_ids, ...parameters.right_evidence_ids];
+    const left = parameters.left_evidence_id === undefined
+        ? (parameters.left_evidence_ids ?? [])
+        : [parameters.left_evidence_id];
+    const right = parameters.right_evidence_id === undefined
+        ? (parameters.right_evidence_ids ?? [])
+        : [parameters.right_evidence_id];
+    if (left.length === 0 || right.length === 0)
+        throw new TypeError("Comparison Evidence omitted its source parameters");
+    return [...left, ...right];
 };
-const sameSet = (left, right) => left.length === right.length &&
-    new Set(left).size === left.length &&
-    left.every((item) => right.includes(item));
-const assertCompleteArtifactResult = (result) => {
-    if (result.changes.offset !== 0 ||
-        result.changes.next_offset !== null ||
-        result.changes.items.length !== result.changes.total)
-        throw new TypeError("Static/runtime correlation requires complete artifact comparison pagination");
+const sameSet = (left, right) => {
+    if (left.length !== right.length)
+        return false;
+    const rightSet = new Set(right);
+    return (rightSet.size === right.length &&
+        new Set(left).size === left.length &&
+        left.every((item) => rightSet.has(item)));
 };
 const observedPattern = (staticStatus, runtimeStatus) => {
     if (staticStatus === "truncated" || runtimeStatus === "truncated")

package/dist/domain/symbolAnalysis.js

@@ -1,16 +1,3 @@
-const MAX_SCANNED_SYMBOLS = 5_000;
-const MAX_RETURNED_SYMBOLS = 100;
-/** Select Swift class symbols using the legacy `_TtC` convention. */
-export const discoverSwiftClasses = (procedures, pattern) => {
-    const classes = procedures
-        .slice(0, MAX_SCANNED_SYMBOLS)
-        .filter(({ name }) => name.includes("_TtC"))
-        .filter(({ name }) => pattern.length === 0 || name.includes(pattern));
-    return {
-        count: classes.length,
-        classes: classes.slice(0, MAX_RETURNED_SYMBOLS).map(toJsonEntry),
-    };
-};
 /** Select and deduplicate Objective-C class labels. */
 export const discoverObjcClasses = (names, pattern) => {
     const classes = uniqueByName(names
@@ -18,7 +5,7 @@ export const discoverObjcClasses = (names, pattern) => {
         .filter(({ name }) => pattern.length === 0 || name.includes(pattern)));
     return {
         count: classes.length,
-        classes: classes.slice(0, MAX_RETURNED_SYMBOLS).map(toJsonEntry),
+        classes: classes.map(toJsonEntry),
     };
 };
 /** Select and deduplicate Objective-C and Swift protocol labels. */
@@ -26,7 +13,7 @@ export const discoverObjcProtocols = (names) => {
     const protocols = uniqueByName(names.filter(({ name }) => name.includes("OBJC_PROTOCOL") || name.includes("_TtP")));
     return {
         count: protocols.length,
-        protocols: protocols.slice(0, MAX_RETURNED_SYMBOLS).map(toJsonEntry),
+        protocols: protocols.map(toJsonEntry),
     };
 };
 const SWIFT_CATEGORIES = [
@@ -37,19 +24,23 @@ const SWIFT_CATEGORIES = [
     ["extensions", "_TtE"],
 ];
 /** Categorize deduplicated Swift mangled symbols. */
-export const categorizeSwiftTypes = (procedures) => {
+export const categorizeSwiftTypes = (procedures, filter = {}) => {
     const groups = Object.fromEntries([...SWIFT_CATEGORIES.map(([category]) => category), "other"].map((category) => [category, []]));
     const seen = new Set();
-    for (const entry of procedures.slice(0, MAX_SCANNED_SYMBOLS)) {
+    for (const entry of procedures) {
         if (!entry.name.includes("_Tt") || seen.has(entry.name))
             continue;
-        seen.add(entry.name);
         const category = SWIFT_CATEGORIES.find(([, prefix]) => entry.name.startsWith(prefix))?.[0] ?? "other";
+        if (filter.category !== undefined && filter.category !== category)
+            continue;
+        if (filter.pattern !== undefined && !entry.name.includes(filter.pattern))
+            continue;
+        seen.add(entry.name);
         groups[category]?.push(entry);
     }
     const categories = Object.fromEntries(Object.entries(groups).map(([category, items]) => [
         category,
-        { count: items.length, items: items.slice(0, 50).map(toJsonEntry) },
+        { count: items.length, items: items.map(toJsonEntry) },
     ]));
     return { total: seen.size, categories };
 };

package/dist/domain/unicodeCodePointOrder.js

@@ -0,0 +1,12 @@
+/** Compare strings lexicographically by Unicode code point, independent of locale. */
+export const compareUnicodeCodePoints = (left, right) => {
+    const leftPoints = [...left].map((value) => value.codePointAt(0) ?? 0);
+    const rightPoints = [...right].map((value) => value.codePointAt(0) ?? 0);
+    const length = Math.min(leftPoints.length, rightPoints.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (leftPoints[index] ?? 0) - (rightPoints[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return leftPoints.length - rightPoints.length;
+};