rea-agents 3.1.0 → 3.2.1

package/dist/domain/javascriptFeatureTrace.js

@@ -5,24 +5,21 @@ import { applicationFeatureTraceResultSchema, } from "./javascriptFeatureTraceSc
 import { findApplicationFeatureSeeds, } from "./javascriptFeatureSeed.js";
 import { traverseApplicationFeature, } from "./javascriptFeatureTraversal.js";
 import { buildJavaScriptNativeHandoffs } from "./javascriptNativeHandoff.js";
-/** Trace a literal feature through a bounded, authority-preserving JAG. */
+/** Trace a literal feature through its complete reachable, authority-preserving JAG. */
 export const traceApplicationFeature = (input) => {
     const allSeedMatches = findApplicationFeatureSeeds(input.graph.nodes, input.seed);
-    const seedMatches = allSeedMatches.slice(0, input.limits.max_seed_matches);
+    const seedMatches = allSeedMatches;
     if (seedMatches.length === 0)
         return noMatchResult(input);
-    const traversal = traverseApplicationFeature(input.graph, seedMatches.map(({ node_id: id }) => id), input.direction, input.limits);
-    const graph = traceGraph(input, seedMatches, traversal, allSeedMatches.length);
-    const allPaths = terminalPaths(traversal, seedMatches);
-    const paths = allPaths.slice(0, input.limits.max_paths);
+    const traversal = traverseApplicationFeature(input.graph, seedMatches.map(({ node_id: id }) => id), input.direction);
+    const graph = traceGraph(input, seedMatches, traversal);
+    const paths = terminalPaths(traversal, seedMatches);
     const nativeHandoffs = buildJavaScriptNativeHandoffs(traversal.nodes, traversal.edges, input.nativeEvidence);
     const evidenceLinks = uniqueSorted([
         input.sourceEvidenceId,
         ...nativeHandoffs.flatMap(({ evidence_ids: ids }) => ids),
     ]);
-    const omissions = traceOmissions(input, traversal, allSeedMatches.length, allPaths.length);
     const semantic = {
-        schema_version: 1,
         source_evidence_id: input.sourceEvidenceId,
         source_graph_id: input.graph.graph_id,
         seed: input.seed,
@@ -40,15 +37,12 @@ export const traceApplicationFeature = (input) => {
             ...factSummary(traversal.nodes, traversal.edges),
         },
         coverage: {
-            status: traceCoverageStatus(input.graph, omissions),
+            status: traceCoverageStatus(input.graph),
             source_graph_status: input.graph.coverage.status,
-            scanned_nodes: input.graph.nodes.length,
             total_seed_matches: allSeedMatches.length,
-            ...omissions,
-            frontier_node_ids: traversal.frontierNodeIds,
         },
         evidence_links: evidenceLinks,
-        limitations: traceLimitations(input.graph, omissions),
+        limitations: traceLimitations(input.graph),
     };
     return applicationFeatureTraceResultSchema.parse({
         ...semantic,
@@ -57,7 +51,6 @@ export const traceApplicationFeature = (input) => {
 };
 const noMatchResult = (input) => {
     const semantic = {
-        schema_version: 1,
         source_evidence_id: input.sourceEvidenceId,
         source_graph_id: input.graph.graph_id,
         seed: input.seed,
@@ -80,13 +73,7 @@ const noMatchResult = (input) => {
         coverage: {
             status: "no-match",
             source_graph_status: input.graph.coverage.status,
-            scanned_nodes: input.graph.nodes.length,
             total_seed_matches: 0,
-            omitted_seed_matches: 0,
-            omitted_nodes: 0,
-            omitted_edges: 0,
-            omitted_paths: 0,
-            frontier_node_ids: [],
         },
         evidence_links: [input.sourceEvidenceId],
         limitations: uniqueSorted([
@@ -99,51 +86,23 @@ const noMatchResult = (input) => {
         trace_id: `jatr_${digestCanonical(semantic)}`,
     });
 };
-const traceGraph = (input, seedMatches, traversal, totalSeedMatches) => {
-    const omitted = traversal.omittedNodeCount +
-        traversal.omittedEdgeCount +
-        (totalSeedMatches - seedMatches.length);
+const traceGraph = (input, seedMatches, traversal) => {
     return createJavaScriptApplicationGraph({
         schema: "JavaScriptApplicationGraph",
-        schema_version: 1,
         root_node_ids: uniqueSorted(seedMatches.map(({ node_id: id }) => id)),
         nodes: traversal.nodes,
         edges: traversal.edges,
-        coverage: traceGraphCoverage(input.graph, input.limits, omitted),
+        coverage: traceGraphCoverage(input.graph),
         limitations: uniqueSorted([
             ...input.graph.limitations,
             "Trace edges retain their source authority; graph connectivity does not prove runtime execution or reachability.",
-            ...(omitted === 0
-                ? []
-                : ["Trace output stopped at explicit caller bounds."]),
         ]),
     });
 };
-const traceGraphCoverage = (source, limits, omitted) => {
-    if (omitted > 0)
-        return {
-            status: "partial",
-            truncated: true,
-            omitted_count: omitted,
-            limits: [
-                {
-                    name: "max-seed-matches",
-                    value: limits.max_seed_matches,
-                    unit: "items",
-                },
-                { name: "max-depth", value: limits.max_depth, unit: "depth" },
-                { name: "max-nodes", value: limits.max_nodes, unit: "items" },
-                { name: "max-edges", value: limits.max_edges, unit: "items" },
-            ],
-        };
+const traceGraphCoverage = (source) => {
     return source.coverage.status === "complete"
         ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
-        : {
-            status: source.coverage.status,
-            truncated: source.coverage.truncated,
-            omitted_count: source.coverage.omitted_count,
-            limits: source.coverage.limits,
-        };
+        : source.coverage;
 };
 const terminalPaths = (traversal, seeds) => {
     const seedIds = new Set(seeds.map(({ node_id: id }) => id));
@@ -198,25 +157,12 @@ const factSummary = (nodes, edges) => {
         unavailable_facts: states.filter((state) => state === "unavailable").length,
     };
 };
-const traceOmissions = (input, traversal, seedMatches, paths) => ({
-    omitted_seed_matches: Math.max(0, seedMatches - input.limits.max_seed_matches),
-    omitted_nodes: traversal.omittedNodeCount,
-    omitted_edges: traversal.omittedEdgeCount,
-    omitted_paths: Math.max(0, paths - input.limits.max_paths),
-});
-const traceCoverageStatus = (graph, omissions) => Object.values(omissions).some((value) => value > 0)
-    ? "truncated"
-    : graph.coverage.status === "complete"
-        ? "complete-within-source"
-        : "partial";
-const traceLimitations = (graph, omissions) => uniqueSorted([
+const traceCoverageStatus = (graph) => graph.coverage.status === "complete" ? "complete-within-source" : "partial";
+const traceLimitations = (graph) => uniqueSorted([
     "A trace reports graph relationships, not proof that code executed or that a feature is reachable in every state.",
     "Static, native, passive-runtime, inferred, and unknown facts retain their original authority in the returned graph.",
     "Native handoffs never open a binary or invoke a provider automatically; snapshot reuse remains provider/profile/target exact.",
     ...sourceCoverageLimitations(graph),
-    ...(Object.values(omissions).some((value) => value > 0)
-        ? ["Trace results were truncated at explicit caller limits."]
-        : []),
 ]);
 const sourceCoverageLimitations = (graph) => graph.coverage.status === "complete"
     ? []

package/dist/domain/javascriptFeatureTraceSchemas.js

@@ -5,8 +5,8 @@ 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 edgeIdSchema = z.string().regex(/^jag_edge_[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
-/** Literal starting point for one bounded application trace. */
+const boundedTextSchema = z.string().min(1);
+/** Literal starting point for one application feature trace. */
 const applicationFeatureSeedSchema = z.strictObject({
     kind: z.enum([
         "node-id",
@@ -21,27 +21,13 @@ const applicationFeatureSeedSchema = z.strictObject({
     match: z.enum(["exact", "contains"]).nullable().default(null),
     case_sensitive: z.boolean().default(false),
 });
-const featureTraceLimitsSchema = z.strictObject({
-    max_seed_matches: z.number().int().min(1).max(1_000).default(25),
-    max_depth: z.number().int().min(0).max(64).default(12),
-    max_nodes: z.number().int().min(1).max(50_000).default(2_000),
-    max_edges: z.number().int().min(1).max(100_000).default(4_000),
-    max_paths: z.number().int().min(1).max(1_000).default(100),
-});
-/** Evidence-backed application graph and explicit trace bounds. */
+/** Evidence-backed application graph and feature seed. */
 export const traceApplicationFeatureInputSchema = z
     .strictObject({
     application: evidenceSchema,
-    native_observations: z.array(evidenceSchema).max(64).default([]),
+    native_observations: z.array(evidenceSchema).default([]),
     seed: applicationFeatureSeedSchema,
     direction: z.enum(["outgoing", "incoming", "both"]).default("both"),
-    limits: featureTraceLimitsSchema.default({
-        max_seed_matches: 25,
-        max_depth: 12,
-        max_nodes: 2_000,
-        max_edges: 4_000,
-        max_paths: 100,
-    }),
 })
     .superRefine((input, context) => {
     const ids = input.native_observations.map(({ evidence_id: id }) => id);
@@ -54,51 +40,48 @@ export const traceApplicationFeatureInputSchema = z
 });
 const seedMatchSchema = z.strictObject({
     node_id: nodeIdSchema,
-    kind: z.string().min(1).max(128),
+    kind: z.string().min(1),
     basis: z.enum(["node-id", "label", "identity", "property"]),
-    field: z.string().min(1).max(256),
+    field: z.string().min(1),
 });
 const tracePathSchema = z.strictObject({
     path_id: z.string().regex(/^jatp_[a-f0-9]{64}$/u),
     start_node_id: nodeIdSchema,
     end_node_id: nodeIdSchema,
-    end_kind: z.string().min(1).max(128),
-    node_ids: z.array(nodeIdSchema).min(1).max(65),
-    edge_ids: z.array(edgeIdSchema).max(64),
-    authorities: z.array(z.string().min(1).max(128)).max(16),
+    end_kind: z.string().min(1),
+    node_ids: z.array(nodeIdSchema).min(1),
+    edge_ids: z.array(edgeIdSchema),
+    authorities: z.array(z.string().min(1)),
     contains_inference: z.boolean(),
 });
 const nativeHandoffSchema = z.strictObject({
     native_node_id: nodeIdSchema,
     artifact_sha256: digestSchema,
-    artifact_path: z.string().min(1).max(4_096).nullable(),
-    export_node_ids: z.array(nodeIdSchema).max(1_000),
-    requested_exports: z.array(boundedTextSchema).max(1_000),
+    artifact_path: z.string().min(1).nullable(),
+    export_node_ids: z.array(nodeIdSchema),
+    requested_exports: z.array(boundedTextSchema),
     status: z.enum(["evidence-linked", "requires-provider-analysis"]),
-    providers: z.array(providerSchema).max(64),
-    evidence_ids: z.array(evidenceIdSchema).max(64),
-    recommended_tools: z
-        .array(z.enum([
+    providers: z.array(providerSchema),
+    evidence_ids: z.array(evidenceIdSchema),
+    recommended_tools: z.array(z.enum([
         "open_binary",
         "binary_overview",
         "search_procedures",
         "analyze_function",
         "xrefs",
-    ]))
-        .max(5),
+    ])),
 });
-/** Evidence-preserving bounded subgraph and native-analysis frontiers. */
+/** Evidence-preserving complete reachable subgraph and native-analysis handoffs. */
 export const applicationFeatureTraceResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     trace_id: z.string().regex(/^jatr_[a-f0-9]{64}$/u),
     source_evidence_id: evidenceIdSchema,
     source_graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
     seed: applicationFeatureSeedSchema,
     direction: z.enum(["outgoing", "incoming", "both"]),
-    seed_matches: z.array(seedMatchSchema).max(1_000),
+    seed_matches: z.array(seedMatchSchema),
     graph: javascriptApplicationGraphSchema.nullable(),
-    paths: z.array(tracePathSchema).max(1_000),
-    native_handoffs: z.array(nativeHandoffSchema).max(10_000),
+    paths: z.array(tracePathSchema),
+    native_handoffs: z.array(nativeHandoffSchema),
     summary: z.strictObject({
         matched_seeds: z.number().int().min(0),
         traced_nodes: z.number().int().min(0),
@@ -111,26 +94,15 @@ export const applicationFeatureTraceResultSchema = z.strictObject({
         unavailable_facts: z.number().int().min(0),
     }),
     coverage: z.strictObject({
-        status: z.enum([
-            "complete-within-source",
-            "partial",
-            "truncated",
-            "no-match",
-        ]),
+        status: z.enum(["complete-within-source", "partial", "no-match"]),
         source_graph_status: z.enum([
             "complete",
             "partial",
             "unknown",
             "unavailable",
         ]),
-        scanned_nodes: z.number().int().min(0),
         total_seed_matches: z.number().int().min(0),
-        omitted_seed_matches: z.number().int().min(0),
-        omitted_nodes: z.number().int().min(0),
-        omitted_edges: z.number().int().min(0),
-        omitted_paths: z.number().int().min(0),
-        frontier_node_ids: z.array(nodeIdSchema).max(50_000),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(65),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+    limitations: z.array(boundedTextSchema),
 });

package/dist/domain/javascriptFeatureTraversal.js

@@ -1,56 +1,23 @@
 import { compareCodePoints, } from "./javascriptApplicationGraph.js";
 /** Traverse a JAG without treating edge inference as observed reachability. */
-export const traverseApplicationFeature = (graph, seedNodeIds, direction, limits) => {
+export const traverseApplicationFeature = (graph, seedNodeIds, direction) => {
     const nodeById = new Map(graph.nodes.map((node) => [node.node_id, node]));
     const adjacency = buildAdjacency(graph.edges, direction);
     const visited = new Set(seedNodeIds);
     const retainedEdges = new Map();
-    const omittedNodes = new Set();
-    const omittedEdges = new Set();
-    const frontier = new Set();
-    const depths = new Map(seedNodeIds.map((nodeId) => [nodeId, 0]));
     const predecessors = new Map();
     const queue = [...seedNodeIds];
     for (let offset = 0; offset < queue.length; offset += 1) {
         const current = queue[offset];
         if (current === undefined)
             continue;
-        const depth = depths.get(current) ?? 0;
         for (const entry of adjacency.get(current) ?? []) {
-            if (depth >= limits.max_depth) {
-                recordOmission({
-                    entry,
-                    current,
-                    omittedNodes,
-                    omittedEdges,
-                    frontier,
-                });
-                continue;
-            }
-            if (!visited.has(entry.nextNodeId) && visited.size >= limits.max_nodes) {
-                recordOmission({
-                    entry,
-                    current,
-                    omittedNodes,
-                    omittedEdges,
-                    frontier,
-                });
-                continue;
-            }
-            if (!retainedEdges.has(entry.edge.edge_id) &&
-                retainedEdges.size >= limits.max_edges) {
-                omittedEdges.add(entry.edge.edge_id);
-                frontier.add(current);
-                frontier.add(entry.nextNodeId);
-                continue;
-            }
             retainedEdges.set(entry.edge.edge_id, entry.edge);
             if (visited.has(entry.nextNodeId))
                 continue;
             if (!nodeById.has(entry.nextNodeId))
                 continue;
             visited.add(entry.nextNodeId);
-            depths.set(entry.nextNodeId, depth + 1);
             predecessors.set(entry.nextNodeId, {
                 previousNodeId: current,
                 edgeId: entry.edge.edge_id,
@@ -64,11 +31,7 @@ export const traverseApplicationFeature = (graph, seedNodeIds, direction, limits
             .filter((node) => node !== undefined)
             .sort((left, right) => compareCodePoints(left.node_id, right.node_id)),
         edges: [...retainedEdges.values()].sort((left, right) => compareCodePoints(left.edge_id, right.edge_id)),
-        depths,
         predecessors,
-        frontierNodeIds: [...frontier].sort(compareCodePoints),
-        omittedNodeCount: omittedNodes.size,
-        omittedEdgeCount: omittedEdges.size,
     };
 };
 const buildAdjacency = (edges, direction) => {
@@ -92,9 +55,3 @@ const buildAdjacency = (edges, direction) => {
 const addAdjacency = (adjacency, nodeId, entry) => {
     adjacency.set(nodeId, [...(adjacency.get(nodeId) ?? []), entry]);
 };
-const recordOmission = (context) => {
-    context.omittedNodes.add(context.entry.nextNodeId);
-    context.omittedEdges.add(context.entry.edge.edge_id);
-    context.frontier.add(context.current);
-    context.frontier.add(context.entry.nextNodeId);
-};

package/dist/domain/javascriptNativeHandoff.js

@@ -72,7 +72,7 @@ const requestedExports = (nodes) => {
         ...stringArray(observation.properties.requested_members),
         ...stringArray(observation.properties.members),
     ]));
-    return [...new Set(values)].sort(compareCodePoints).slice(0, 1_000);
+    return [...new Set(values)].sort(compareCodePoints);
 };
 const stringArray = (value) => Array.isArray(value)
     ? value.filter((item) => typeof item === "string")

package/dist/domain/javascriptReplay.js

@@ -1,11 +1,10 @@
 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 absolutePathSchema = z.string().startsWith("/");
 const aliasSchema = z
     .string()
     .min(1)
-    .max(256)
     .regex(/^[A-Za-z0-9_./:@-]+$/u);
 const replayModuleSchema = z
     .object({
@@ -13,25 +12,20 @@ const replayModuleSchema = z
     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({}),
+    dependencies: z.record(z.string().min(1), aliasSchema).default({}),
 })
     .strict();
 const replaySideSchema = z
     .object({
-    modules: z.array(replayModuleSchema).min(1).max(128),
+    modules: z.array(replayModuleSchema).min(1),
     entry_alias: aliasSchema,
-    entry_export: z.string().min(1).max(256).default("default"),
+    entry_export: z.string().min(1).default("default"),
 })
     .strict();
 const explicitCaseSchema = z
     .object({
-    case_id: z.string().min(1).max(128),
-    arguments: z.array(z.json()).max(16),
+    case_id: z.string().min(1),
+    arguments: z.array(z.json()),
 })
     .strict();
 const generatorSchema = z
@@ -42,58 +36,58 @@ const generatorSchema = z
         "clipboard-boundaries",
     ]),
     seed: z.number().int().min(0).max(0xffff_ffff),
-    count: z.number().int().min(1).max(64),
+    count: z.number().int().safe().min(1),
 })
     .strict();
 const replayLimitsSchema = z
     .object({
-    wall_time_ms: z.number().int().min(100).max(10_000).default(3_000),
+    wall_time_ms: z.number().int().safe().min(1).default(3_000),
     memory_bytes: z
         .number()
         .int()
-        .min(16 * 1024 * 1024)
-        .max(512 * 1024 * 1024)
+        .safe()
+        .positive()
         .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),
+    tasks: z.number().int().safe().min(1).default(8),
+    cpu_quota_percent: z.number().int().safe().min(1).default(50),
     tmpfs_bytes: z
         .number()
         .int()
-        .min(1024 * 1024)
-        .max(64 * 1024 * 1024)
+        .safe()
+        .min(1)
         .default(16 * 1024 * 1024),
     module_bytes: z
         .number()
         .int()
+        .safe()
         .min(1)
-        .max(16 * 1024 * 1024)
         .default(4 * 1024 * 1024),
     input_bytes: z
         .number()
         .int()
+        .safe()
         .min(1)
-        .max(1024 * 1024)
         .default(256 * 1024),
     protocol_bytes: z
         .number()
         .int()
-        .min(1024 * 1024)
-        .max(64 * 1024 * 1024)
+        .safe()
+        .min(1)
         .default(16 * 1024 * 1024),
     output_bytes: z
         .number()
         .int()
+        .safe()
         .min(1)
-        .max(4 * 1024 * 1024)
         .default(512 * 1024),
     stderr_bytes: z
         .number()
         .int()
+        .safe()
         .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),
+    result_depth: z.number().int().safe().min(1).default(16),
+    result_nodes: z.number().int().safe().min(1).default(10_000),
 })
     .strict();
 const determinismSchema = z
@@ -108,7 +102,7 @@ const determinismSchema = z
 const controlledReplayInputShape = {
     left: replaySideSchema,
     right: replaySideSchema.optional(),
-    cases: z.array(explicitCaseSchema).max(128).default([]),
+    cases: z.array(explicitCaseSchema).default([]),
     generator: generatorSchema.optional(),
     determinism: determinismSchema.default({
         clock_iso: "2000-01-01T00:00:00.000Z",
@@ -134,7 +128,6 @@ const controlledReplayInputShape = {
     reproducer_export: z
         .strictObject({
         path: absolutePathSchema,
-        approved: z.literal(true),
         include_sources: z.boolean().default(false),
     })
         .optional(),
@@ -144,11 +137,10 @@ export const controlledReplayPlanInputSchema = z.strictObject({
     ...controlledReplayInputShape,
     mode: z.literal("plan"),
 });
-/** Parse a replay request carrying literal approval for one exact plan. */
+/** Parse a replay request carrying the digest for one exact plan. */
 export const controlledReplayExecutionInputSchema = z.strictObject({
     ...controlledReplayInputShape,
     mode: z.literal("execute"),
-    approved: z.literal(true),
     plan_digest: digestSchema,
 });
 /** Parse a controlled replay request into its legal plan or execution state. */
@@ -164,12 +156,6 @@ export const controlledReplayInputSchema = z
             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",
-        });
 });
 const moduleCommitmentSchema = z
     .object({
@@ -198,7 +184,6 @@ const runtimeFileIdentitySchema = z
     .strict();
 const replayPlanSchema = z
     .object({
-    schema_version: z.literal(1),
     plan_digest: digestSchema,
     policy_version: z.literal("linux-bwrap-systemd-v1"),
     policy_sha256: digestSchema,
@@ -254,7 +239,6 @@ const replayPlanSchema = z
         .object({
         path: z.string().min(1),
         include_sources: z.boolean(),
-        authority: z.literal("evidence_write"),
     })
         .strict()
         .nullable(),
@@ -301,7 +285,6 @@ const replayOutcomeSchema = z.discriminatedUnion("outcome", [
 ]);
 export const replayExecutionResultSchema = z
     .object({
-    schema_version: z.literal(1),
     plan_digest: digestSchema,
     outcomes: z.array(replayOutcomeSchema),
     comparison: z

package/dist/domain/javascriptRuntimeLoadState.js

@@ -3,21 +3,16 @@ import { createStaticRuntimeScope, mappedRuntimePaths, staticNodeWithinRuntimeSc
 /** 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 };
+    return { states, omittedStates: 0 };
 };
 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" &&
@@ -31,7 +26,7 @@ const classifyLayer = (layer, runtimeEntities, matches, options) => {
         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 states = nodes.map((node) => {
         const runtimeNodeIds = uniqueSorted(direct.get(node.node_id) ?? []);
         if (runtimeNodeIds.length > 0)
             return state(layer, node, {
@@ -60,7 +55,7 @@ const classifyLayer = (layer, runtimeEntities, matches, options) => {
                 : "static-or-runtime-coverage-incomplete",
         });
     });
-    return { states, total: nodes.length };
+    return { states };
 };
 const residentNodes = (layer, directlyLoaded) => {
     const nodeKinds = new Map(layer.graph.nodes.map(({ node_id: id, kind }) => [id, kind]));