rea-agents 3.0.0 → 3.2.0

package/dist/domain/javascriptSemanticQuery.js

@@ -1,142 +1,68 @@
 import { compareCodePoints } from "./javascriptApplicationGraph.js";
 import { isJavaScriptSemanticOwnershipRelation as ownershipRelation } from "./javascriptSemanticQueryRelations.js";
 import { javaScriptSemanticQueryInputSchema, javaScriptSemanticQueryResultSchema, } from "./javascriptSemanticQuerySchemas.js";
-import { assessJavaScriptSemanticQuery, } from "./javascriptSemanticQueryAssessment.js";
-import { canonicalJavaScriptSemanticQueryJson as canonicalJson, createJavaScriptSemanticQueryCursor as createCursor, JavaScriptSemanticQueryCursorError, javaScriptSemanticQueryIdentifier as queryIdentifier, parseJavaScriptSemanticQueryCursor as parseCursor, resolveJavaScriptSemanticQuerySeeds as resolveSeeds, } from "./javascriptSemanticQueryIdentity.js";
-/** Run one deterministic bounded traversal over a verified semantic graph. */
+import { assessJavaScriptSemanticQuery } from "./javascriptSemanticQueryAssessment.js";
+import { javaScriptSemanticQueryIdentifier as queryIdentifier, resolveJavaScriptSemanticQuerySeeds as resolveSeeds, } from "./javascriptSemanticQueryIdentity.js";
+/** Run one deterministic traversal over a verified semantic graph. */
 export const queryJavaScriptSemanticGraph = (graph, rawInput) => {
     const input = javaScriptSemanticQueryInputSchema.parse(rawInput);
     const queryId = queryIdentifier(graph, input);
-    const offset = parseCursor(input.cursor, queryId);
     const seeds = resolveSeeds(graph, input);
-    const admission = admitSeeds(graph, seeds, input);
+    const admission = admitSeeds(graph, seeds);
     const retainedSeeds = admission.nodeIds;
     const adjacency = buildAdjacency(graph.relations, input);
-    const traversal = traverse(graph, retainedSeeds, adjacency, input);
-    const frontier = uniqueFrontier([
-        ...traversal.frontier,
-        ...admission.frontier,
-    ]);
-    const page = createQueryPage({
-        graph,
-        traversal,
-        query: input,
-        queryId,
-        offset,
-        retainedSeeds,
-    });
+    const traversal = traverse(graph, retainedSeeds, adjacency);
+    const result = createQueryResult(graph, traversal);
     const allRelevantUnknowns = relevantUnknownFrontiers(graph, traversal.nodeIds, input);
-    const relevantUnknowns = allRelevantUnknowns.slice(0, input.limits.max_unknowns);
+    const relevantUnknowns = allRelevantUnknowns;
     const candidateRelations = relevantCandidateRelationCount(graph, traversal.nodeIds, input);
-    const expectedMatches = expectedMatchesFor(page.retainedNodes, page.retainedRelations, input);
+    const expectedMatches = expectedMatchesFor(result.retainedNodes, result.retainedRelations, input);
     const assessment = assessJavaScriptSemanticQuery({
         graph,
         totalSeeds: seeds.length,
-        retainedSeeds: retainedSeeds.length,
         expectedMatches: expectedMatches.length,
         hasExpectation: input.expected !== null,
-        frontier,
         unknowns: relevantUnknowns,
         candidateRelations,
-        unknownsTruncated: allRelevantUnknowns.length > relevantUnknowns.length,
     });
     return javaScriptSemanticQueryResultSchema.parse({
-        schema_version: 1,
         query_id: queryId,
         source_graph_id: graph.graph_id,
         seed: input.seed,
         direction: input.direction,
         status: assessment.status,
         seed_node_ids: retainedSeeds,
-        nodes: page.pageNodes,
-        relations: page.pageRelations,
+        nodes: result.retainedNodes,
+        relations: result.retainedRelations,
         unknowns: relevantUnknowns,
         expected_match_node_ids: expectedMatches.map(({ node_id }) => node_id),
         summary: {
             total_seed_matches: seeds.length,
-            retained_seed_matches: retainedSeeds.length,
             traversed_nodes: traversal.nodeIds.size,
             traversed_relations: traversal.relationIds.size,
             traversed_functions: traversal.functionIds.size,
             traversed_modules: traversal.modules.size,
             relevant_unknowns: allRelevantUnknowns.length,
-            retained_unknowns: relevantUnknowns.length,
         },
         coverage: assessment.coverage,
-        page: {
-            offset,
-            size: page.pageRelations.length,
-            next_cursor: page.nextCursor,
-        },
-        applied_limits: input.limits,
-        accepted_limit_ranges: assessment.acceptedLimitRanges,
         limitations: assessment.limitations,
     });
 };
-const createQueryPage = ({ graph, traversal, query, queryId, offset, retainedSeeds, }) => {
+const createQueryResult = (graph, traversal) => {
     const retainedNodes = graph.nodes.filter(({ node_id }) => traversal.nodeIds.has(node_id));
     const retainedRelations = graph.relations.filter(({ relation_id }) => traversal.relationIds.has(relation_id));
-    if (offset > retainedRelations.length)
-        throw new JavaScriptSemanticQueryCursorError("Semantic query cursor is beyond the retained result");
-    const pageRelations = retainedRelations.slice(offset, offset + query.limits.page_size);
-    const pageNodeIds = new Set([
-        ...retainedSeeds,
-        ...pageRelations.flatMap(({ source_node_id, target_node_id }) => [
-            source_node_id,
-            target_node_id,
-        ]),
-    ]);
-    const pageNodes = graph.nodes.filter(({ node_id }) => pageNodeIds.has(node_id));
-    const nextOffset = offset + pageRelations.length;
-    return {
-        retainedNodes,
-        retainedRelations,
-        pageRelations,
-        pageNodes,
-        nextCursor: nextOffset < retainedRelations.length
-            ? createCursor(queryId, nextOffset)
-            : null,
-    };
+    return { retainedNodes, retainedRelations };
 };
-const admitSeeds = (graph, seeds, input) => {
+const admitSeeds = (graph, seeds) => {
     const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
     const retained = [];
-    const functions = new Set();
-    const modules = new Set();
-    const frontier = [];
     for (const nodeId of seeds) {
         const node = nodes.get(nodeId);
         if (node === undefined)
             continue;
-        const reason = seedBlockedReason(node, {
-            retained,
-            functions,
-            modules,
-            input,
-        });
-        if (reason !== null) {
-            frontier.push({ node_id: nodeId, depth: 0, reason });
-            continue;
-        }
         retained.push(nodeId);
-        retainOwners(node, functions, modules);
     }
-    return { nodeIds: retained, frontier: uniqueFrontier(frontier) };
-};
-const seedBlockedReason = (node, bounds) => {
-    if (bounds.retained.length >= bounds.input.limits.max_seed_matches)
-        return "max-seed-matches";
-    if (bounds.retained.length >= bounds.input.limits.max_nodes)
-        return "max-nodes";
-    const functionId = functionOwner(node);
-    if (functionId !== null &&
-        !bounds.functions.has(functionId) &&
-        bounds.functions.size >= bounds.input.limits.max_functions)
-        return "max-functions";
-    if (!bounds.modules.has(node.identity.module_path) &&
-        bounds.modules.size >= bounds.input.limits.max_modules)
-        return "max-modules";
-    return null;
+    return { nodeIds: retained };
 };
 const buildAdjacency = (relations, input) => {
     const adjacency = new Map();
@@ -178,36 +104,20 @@ const addEntry = (adjacency, from, nextNodeId, relation) => {
     entries.push({ relation, nextNodeId });
     adjacency.set(from, entries);
 };
-const traverse = (graph, seeds, adjacency, input) => {
+const traverse = (graph, seeds, adjacency) => {
     const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
     const nodeIds = new Set(seeds);
     const relationIds = new Set();
     const functionIds = new Set();
     const modules = new Set();
-    const frontier = [];
+    const queue = [...nodeIds];
     for (const nodeId of nodeIds)
         retainOwners(nodes.get(nodeId), functionIds, modules);
-    const depths = new Map([...nodeIds].map((nodeId) => [nodeId, 0]));
-    const queue = [...nodeIds];
-    const bounds = {
-        nodes,
-        nodeIds,
-        relationIds,
-        functionIds,
-        modules,
-        input,
-    };
     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) ?? []) {
-            const reason = blockedReason(entry, depth, bounds);
-            if (reason !== null) {
-                frontier.push({ node_id: current, depth, reason });
-                continue;
-            }
             relationIds.add(entry.relation.relation_id);
             if (nodeIds.has(entry.nextNodeId))
                 continue;
@@ -216,7 +126,6 @@ const traverse = (graph, seeds, adjacency, input) => {
                 continue;
             nodeIds.add(entry.nextNodeId);
             retainOwners(node, functionIds, modules);
-            depths.set(entry.nextNodeId, depth + 1);
             queue.push(entry.nextNodeId);
         }
     }
@@ -225,47 +134,16 @@ const traverse = (graph, seeds, adjacency, input) => {
         relationIds,
         functionIds,
         modules,
-        frontier: uniqueFrontier(frontier),
     };
 };
-const blockedReason = (entry, depth, bounds) => {
-    if (depth >= bounds.input.limits.max_depth)
-        return "max-depth";
-    if (!bounds.relationIds.has(entry.relation.relation_id) &&
-        bounds.relationIds.size >= bounds.input.limits.max_edges)
-        return "max-edges";
-    if (bounds.nodeIds.has(entry.nextNodeId))
-        return null;
-    if (bounds.nodeIds.size >= bounds.input.limits.max_nodes)
-        return "max-nodes";
-    const node = bounds.nodes.get(entry.nextNodeId);
-    if (node === undefined)
-        return null;
-    const functionId = functionOwner(node);
-    if (functionId !== null &&
-        !bounds.functionIds.has(functionId) &&
-        bounds.functionIds.size >= bounds.input.limits.max_functions)
-        return "max-functions";
-    if (!bounds.modules.has(node.identity.module_path) &&
-        bounds.modules.size >= bounds.input.limits.max_modules)
-        return "max-modules";
-    return null;
-};
 const retainOwners = (node, functions, modules) => {
     if (node === undefined)
         return;
-    const functionId = functionOwner(node);
+    const functionId = node.kind === "function" ? node.node_id : node.function_node_id;
     if (functionId !== null)
         functions.add(functionId);
     modules.add(node.identity.module_path);
 };
-const functionOwner = (node) => node.kind === "function" ? node.node_id : node.function_node_id;
-const uniqueFrontier = (frontier) => [
-    ...new Map(frontier.map((item) => [
-        `${item.node_id}\0${String(item.depth)}\0${item.reason}`,
-        item,
-    ])).values(),
-].sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
 const relevantUnknownFrontiers = (graph, nodeIds, input) => {
     const allowed = input.allowed_relations === undefined
         ? null

package/dist/domain/javascriptSemanticQueryAssessment.js

@@ -1,43 +1,30 @@
 import { compareCodePoints } from "./javascriptApplicationGraph.js";
-/** Classify a bounded semantic traversal without promoting unknowns to absence. */
+/** Classify a complete semantic traversal without promoting unknowns to absence. */
 export const assessJavaScriptSemanticQuery = (input) => ({
     status: queryStatus(input),
     coverage: queryCoverage(input),
     limitations: queryLimitations(input),
-    acceptedLimitRanges: {
-        max_seed_matches: { minimum: 1, maximum: 1_000 },
-        max_nodes: { minimum: 1, maximum: 50_000 },
-        max_edges: { minimum: 1, maximum: 100_000 },
-        max_depth: { minimum: 0, maximum: 64 },
-        max_functions: { minimum: 1, maximum: 10_000 },
-        max_modules: { minimum: 1, maximum: 10_000 },
-        max_unknowns: { minimum: 0, maximum: 10_000 },
-        page_size: { minimum: 1, maximum: 1_000 },
-    },
 });
 const queryCoverage = (input) => ({
     status: input.graph.coverage.status === "unavailable"
         ? "unavailable"
-        : input.frontier.length > 0 || input.unknownsTruncated
-            ? "truncated"
-            : input.unknowns.length > 0 ||
-                input.candidateRelations > 0 ||
-                input.graph.coverage.status !== "complete"
-                ? "partial"
-                : "complete",
-    frontier: [...input.frontier],
+        : input.unknowns.length > 0 ||
+            input.candidateRelations > 0 ||
+            input.graph.coverage.status !== "complete" ||
+            input.graph.coverage.truncated
+            ? "partial"
+            : "complete",
 });
 const queryStatus = (input) => {
     if (input.graph.coverage.status === "unavailable")
         return "unsupported";
-    if (input.frontier.length > 0 || input.unknownsTruncated)
-        return "truncated";
     if (input.candidateRelations > 0)
         return "ambiguous";
     if (input.totalSeeds === 0 ||
         (input.hasExpectation && input.expectedMatches === 0))
         return input.unknowns.length > 0 ||
-            input.graph.coverage.status !== "complete"
+            input.graph.coverage.status !== "complete" ||
+            input.graph.coverage.truncated
             ? "partial"
             : "no-match";
     return input.totalSeeds > 1 ? "ambiguous" : "found";
@@ -45,26 +32,11 @@ const queryStatus = (input) => {
 const queryLimitations = (input) => uniqueSorted([
     "Semantic graph reachability is a static inference and does not prove runtime execution.",
     ...input.graph.limitations,
-    ...(input.totalSeeds === input.retainedSeeds
-        ? []
-        : [
-            "Seed matches exceeded caller bounds; omitted starts remain unexplored.",
-        ]),
-    ...(input.frontier.length === 0
-        ? []
-        : [
-            "Traversal stopped at explicit caller limits; frontier facts remain unknown.",
-        ]),
     ...(input.unknowns.length === 0
         ? []
         : [
             "Relevant dynamic, unsupported, incomplete, or ambiguous semantics remain unknown.",
         ]),
-    ...(input.unknownsTruncated
-        ? [
-            "Relevant unknown frontiers exceeded the caller limit; omitted unknowns remain unresolved.",
-        ]
-        : []),
     ...(input.candidateRelations === 0
         ? []
         : [

package/dist/domain/javascriptSemanticQueryIdentity.js

@@ -1,9 +1,6 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { compareCodePoints } from "./javascriptApplicationGraph.js";
-/** Caller cursor that cannot identify a page of the current semantic query. */
-export class JavaScriptSemanticQueryCursorError extends TypeError {
-}
 /** Canonical JSON used by semantic query commitments and ordering. */
 export const canonicalJavaScriptSemanticQueryJson = (value) => {
     const encoded = canonicalize(value);
@@ -15,9 +12,9 @@ const digest = (value) => createHash("sha256")
     .update(canonicalJavaScriptSemanticQueryJson(value))
     .digest("hex");
 const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);
-/** Derive the stable identity for one graph-bound query without its cursor. */
+/** Derive the stable identity for one graph-bound query. */
 export const javaScriptSemanticQueryIdentifier = (graph, input) => {
-    const { cursor: _cursor, ...semantic } = input;
+    const semantic = input;
     return `jsrq_${digest({
         source_graph_id: graph.graph_id,
         ...semantic,
@@ -32,24 +29,6 @@ export const javaScriptSemanticQueryIdentifier = (graph, input) => {
             },
     })}`;
 };
-/** Commit one deterministic relation-page offset to a query identity. */
-export const createJavaScriptSemanticQueryCursor = (queryId, offset) => `jsrqc_${String(offset)}_${digest({ query_id: queryId, offset })}`;
-/** Parse a query-bound cursor and reject stale, malformed, or foreign values. */
-export const parseJavaScriptSemanticQueryCursor = (cursor, queryId) => {
-    if (cursor === null)
-        return 0;
-    const match = /^jsrqc_([0-9]+)_([a-f0-9]{64})$/u.exec(cursor);
-    const offsetText = match?.[1];
-    const commitment = match?.[2];
-    if (offsetText === undefined || commitment === undefined)
-        throw new JavaScriptSemanticQueryCursorError("Semantic query cursor is malformed");
-    const offset = Number(offsetText);
-    if (!Number.isSafeInteger(offset) ||
-        offset < 0 ||
-        commitment !== digest({ query_id: queryId, offset }))
-        throw new JavaScriptSemanticQueryCursorError("Semantic query cursor does not match this query");
-    return offset;
-};
 /** Resolve deterministic seed candidates without applying traversal limits. */
 export const resolveJavaScriptSemanticQuerySeeds = (graph, input) => {
     const fingerprintFunctions = new Set(input.seed.kind === "function"

package/dist/domain/javascriptSemanticQuerySchemas.js

@@ -27,32 +27,21 @@ export const javaScriptSemanticQuerySeedSchema = z.discriminatedUnion("kind", [
     }),
     z.strictObject({
         kind: z.literal("property"),
-        name: z.string().min(1).max(4_096),
+        name: z.string().min(1),
     }),
     z.strictObject({
         kind: z.literal("endpoint"),
-        value: z.string().min(1).max(16_384),
+        value: z.string().min(1),
     }),
     z.strictObject({
         kind: z.literal("event"),
-        name: z.string().min(1).max(4_096),
+        name: z.string().min(1),
     }),
     z.strictObject({
         kind: z.literal("boundary-field"),
-        field: z.string().min(1).max(4_096),
+        field: z.string().min(1),
     }),
 ]);
-/** Strict caller limits for deterministic bounded traversal. */
-export const javaScriptSemanticQueryLimitsSchema = z.strictObject({
-    max_seed_matches: z.number().int().min(1).max(1_000).default(25),
-    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_depth: z.number().int().min(0).max(64).default(12),
-    max_functions: z.number().int().min(1).max(10_000).default(500),
-    max_modules: z.number().int().min(1).max(10_000).default(500),
-    max_unknowns: z.number().int().min(0).max(10_000).default(1_000),
-    page_size: z.number().int().min(1).max(1_000).default(200),
-});
 const sourceMapAuthoritySchema = z.strictObject({
     authority: z.literal("none"),
 });
@@ -68,121 +57,39 @@ export const javaScriptSemanticQueryInputSchema = z.strictObject({
     allowed_relations: z
         .array(z.enum(JAVASCRIPT_SEMANTIC_RELATIONS))
         .min(1)
-        .max(JAVASCRIPT_SEMANTIC_RELATIONS.length)
         .optional(),
     include_ambiguous_dynamic_edges: z.boolean().default(false),
     expected: z
         .strictObject({
         role: z.enum(["source", "sink"]),
-        classes: z.array(z.enum(JAVASCRIPT_SEMANTIC_NODE_KINDS)).min(1).max(24),
+        classes: z.array(z.enum(JAVASCRIPT_SEMANTIC_NODE_KINDS)).min(1),
     })
         .nullable()
         .default(null),
     source_map_authority: sourceMapAuthoritySchema.default({ authority: "none" }),
-    limits: javaScriptSemanticQueryLimitsSchema.default({
-        max_seed_matches: 25,
-        max_nodes: 2_000,
-        max_edges: 4_000,
-        max_depth: 12,
-        max_functions: 500,
-        max_modules: 500,
-        max_unknowns: 1_000,
-        page_size: 200,
-    }),
-    cursor: z
-        .string()
-        .regex(/^jsrqc_[0-9]+_[a-f0-9]{64}$/u)
-        .nullable()
-        .default(null),
 });
-const queryFrontierSchema = z.strictObject({
-    node_id: semanticNodeIdSchema,
-    depth: z.number().int().min(0).max(65),
-    reason: z.enum([
-        "max-depth",
-        "max-edges",
-        "max-functions",
-        "max-modules",
-        "max-nodes",
-        "max-seed-matches",
-    ]),
-});
-/** Deterministic, pageable semantic trace result. */
+/** Deterministic semantic trace result. */
 export const javaScriptSemanticQueryResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     query_id: z.string().regex(/^jsrq_[a-f0-9]{64}$/u),
     source_graph_id: z.string().regex(/^jsrg_[a-f0-9]{64}$/u),
     seed: javaScriptSemanticQuerySeedSchema,
     direction: javaScriptSemanticQueryInputSchema.shape.direction,
-    status: z.enum([
-        "found",
-        "no-match",
-        "ambiguous",
-        "partial",
-        "truncated",
-        "unsupported",
-    ]),
-    seed_node_ids: z.array(semanticNodeIdSchema).max(1_000),
-    nodes: z.array(javaScriptSemanticNodeSchema).max(3_000),
-    relations: z.array(javaScriptSemanticRelationSchema).max(1_000),
-    unknowns: z.array(javaScriptSemanticUnknownSchema).max(100_000),
-    expected_match_node_ids: z.array(semanticNodeIdSchema).max(50_000),
+    status: z.enum(["found", "no-match", "ambiguous", "partial", "unsupported"]),
+    seed_node_ids: z.array(semanticNodeIdSchema),
+    nodes: z.array(javaScriptSemanticNodeSchema),
+    relations: z.array(javaScriptSemanticRelationSchema),
+    unknowns: z.array(javaScriptSemanticUnknownSchema),
+    expected_match_node_ids: z.array(semanticNodeIdSchema),
     summary: z.strictObject({
         total_seed_matches: z.number().int().min(0),
-        retained_seed_matches: z.number().int().min(0),
         traversed_nodes: z.number().int().min(0),
         traversed_relations: z.number().int().min(0),
         traversed_functions: z.number().int().min(0),
         traversed_modules: z.number().int().min(0),
         relevant_unknowns: z.number().int().min(0),
-        retained_unknowns: z.number().int().min(0).max(10_000),
     }),
     coverage: z.strictObject({
-        status: z.enum(["complete", "partial", "truncated", "unavailable"]),
-        frontier: z.array(queryFrontierSchema).max(100_000),
-    }),
-    page: z.strictObject({
-        offset: z.number().int().min(0),
-        size: z.number().int().min(0).max(1_000),
-        next_cursor: z
-            .string()
-            .regex(/^jsrqc_[0-9]+_[a-f0-9]{64}$/u)
-            .nullable(),
-    }),
-    applied_limits: javaScriptSemanticQueryLimitsSchema,
-    accepted_limit_ranges: z.strictObject({
-        max_seed_matches: z.strictObject({
-            minimum: z.literal(1),
-            maximum: z.literal(1_000),
-        }),
-        max_nodes: z.strictObject({
-            minimum: z.literal(1),
-            maximum: z.literal(50_000),
-        }),
-        max_edges: z.strictObject({
-            minimum: z.literal(1),
-            maximum: z.literal(100_000),
-        }),
-        max_depth: z.strictObject({
-            minimum: z.literal(0),
-            maximum: z.literal(64),
-        }),
-        max_functions: z.strictObject({
-            minimum: z.literal(1),
-            maximum: z.literal(10_000),
-        }),
-        max_modules: z.strictObject({
-            minimum: z.literal(1),
-            maximum: z.literal(10_000),
-        }),
-        max_unknowns: z.strictObject({
-            minimum: z.literal(0),
-            maximum: z.literal(10_000),
-        }),
-        page_size: z.strictObject({
-            minimum: z.literal(1),
-            maximum: z.literal(1_000),
-        }),
+        status: z.enum(["complete", "partial", "unavailable"]),
     }),
-    limitations: z.array(z.string().min(1).max(4_096)).max(1_000),
+    limitations: z.array(z.string().min(1)),
 });

package/dist/domain/javascriptSemanticResources.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
-import { dataEffectLimitReached, outerDataEffectBinding, traverseDataEffects, } from "./javascriptSemanticDataEffectHelpers.js";
+import { outerDataEffectBinding, traverseDataEffects, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 const ACQUIRE_METHODS = [
     "open",
@@ -34,8 +34,6 @@ const collectAcquisitions = (program, context) => {
         const method = acquisitionMethod(node.callee, context.state);
         if (method === null)
             return;
-        if (resourceLimitReached(output.length, context.state))
-            return;
         output.push({
             node,
             method,
@@ -69,8 +67,6 @@ const collectReleases = (program, context, acquisitions) => {
         const linked = binding === undefined ? [] : (byBinding.get(binding.bindingId) ?? []);
         if (linked.length === 0)
             return;
-        if (resourceLimitReached(acquisitions.length + output.length, context.state))
-            return;
         output.push({
             resourceId: `resource:release:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: "release",
@@ -129,7 +125,6 @@ const resourceModule = (specifier) => [
     "node:tls",
     "tls",
 ].includes(specifier);
-const resourceLimitReached = (retained, state) => dataEffectLimitReached(retained, state.limits.maxResourceOperations, "maxResourceOperations", state);
 const resourceCandidateId = (candidate) => `resource:acquire:${String(candidate.node.start ?? -1)}:${String(candidate.node.end ?? -1)}`;
 const memberCallee = (node) => t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)
     ? node.callee

package/dist/domain/javascriptSemanticReturns.js

@@ -1,13 +1,13 @@
 import * as t from "@babel/types";
-import { reachSemanticLimit, semanticCallableIdForNode, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { evaluateSemanticExpression } from "./javascriptSemanticValues.js";
 import { compareCodePoints, range } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticReturnCoverage } from "./javascriptSemanticCoverage.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-/** Evaluate bounded direct returns while excluding every nested callable. */
+/** Evaluate direct returns while excluding every nested callable. */
 export const collectSemanticReturns = (program, state, parserPartial) => {
     const nodes = callableNodes(program);
-    let retained = 0;
     return state.callables.map((callable) => {
         const node = nodes.get(callable.callableId);
         if (node === undefined)
@@ -17,19 +17,11 @@ export const collectSemanticReturns = (program, state, parserPartial) => {
                     status: "partial",
                     retainedCount: 0,
                     omittedCount: null,
-                    limitsReached: [],
                 },
             };
         const expressions = directReturnExpressions(node);
         const sites = [];
-        let omitted = 0;
         for (const expression of expressions) {
-            if (retained >= state.limits.maxReturnSites) {
-                omitted += 1;
-                reachSemanticLimit(state, "maxReturnSites");
-                continue;
-            }
-            retained += 1;
             sites.push({
                 returnSiteId: semanticReturnSiteId(callable.callableId, expression.location),
                 location: expression.location,
@@ -44,12 +36,7 @@ export const collectSemanticReturns = (program, state, parserPartial) => {
         return {
             ...callable,
             returnSites: sites,
-            returnCoverage: {
-                status: omitted > 0 ? "truncated" : parserPartial ? "partial" : "complete",
-                retainedCount: sites.length,
-                omittedCount: omitted,
-                limitsReached: omitted > 0 ? ["maxReturnSites"] : [],
-            },
+            returnCoverage: semanticReturnCoverage(sites.length, parserPartial),
         };
     });
 };
@@ -164,21 +151,17 @@ const flattenValue = (value, path, fields, coverage) => {
         return;
     }
     if (value.status === "object") {
-        coverage.push({
-            path,
-            status: value.unknownProperties ? "partial" : "complete",
-            omitted: value.omittedProperties,
-        });
+        coverage.push(value.unknownProperties
+            ? { path, status: "partial", omitted: value.omittedProperties }
+            : { path, status: "complete", omitted: 0 });
         for (const property of value.properties)
             flattenValue(property.value, `${path}/${escapePointer(property.name)}`, fields, coverage);
         return;
     }
     if (value.status === "array") {
-        coverage.push({
-            path,
-            status: value.unknownItems ? "partial" : "complete",
-            omitted: value.omittedItems,
-        });
+        coverage.push(value.unknownItems
+            ? { path, status: "partial", omitted: value.omittedItems }
+            : { path, status: "complete", omitted: 0 });
         value.items.forEach((item, index) => flattenValue(item, `${path}/${String(index)}`, fields, coverage));
         return;
     }

package/dist/domain/javascriptSemanticValueTypes.js

@@ -0,0 +1 @@
+export {};