rea-agents 3.0.0 → 3.2.0

package/dist/domain/javascriptRuntimeReconciliationRuntime.js

@@ -1,12 +1,8 @@
 import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "./javascriptApplicationGraph.js";
 /** Project authorized passive capture metadata into capture-scoped JAG nodes. */
-export const projectRuntimeCaptures = (captures, maximumEntities) => {
-    if (maximumEntities < captures.length)
-        throw new TypeError("Runtime entity limit must admit one target for every capture");
+export const projectRuntimeCaptures = (captures) => {
     const all = captures.flatMap(projectCapture);
-    const targets = all.filter(({ kind }) => kind === "target");
-    const nonTargets = all.filter(({ kind }) => kind !== "target");
-    const retained = [...targets, ...nonTargets].slice(0, maximumEntities);
+    const retained = all;
     const retainedIds = new Set(retained.map(({ node }) => node.node_id));
     const nodes = retained.map(({ node }) => node);
     const edges = captures
@@ -20,7 +16,7 @@ export const projectRuntimeCaptures = (captures, maximumEntities) => {
         nodes,
         edges,
         targetNodeByEvidenceId,
-        omittedEntities: all.length - retained.length,
+        omittedEntities: 0,
     };
 };
 const projectCapture = (capture) => {
@@ -50,7 +46,7 @@ const targetEntity = (capture) => {
         label: target.title,
         properties: {
             runtime_type: target.type,
-            location: location.value.slice(0, 4_096),
+            location: location.value,
             attached: target.attached,
         },
         section: "target",
@@ -73,7 +69,7 @@ const frameEntities = (capture) => capture.inspection.frames.map((frame) => {
         label: location.value,
         properties: {
             parent_frame_id: frame.parent_frame_id,
-            location: location.value.slice(0, 4_096),
+            location: location.value,
         },
         section: "frames",
     });
@@ -96,7 +92,7 @@ const scriptEntities = (capture) => capture.inspection.scripts.items.map((script
             : null,
         label: location.value,
         properties: {
-            location: location.value.slice(0, 4_096),
+            location: location.value,
             cdp_hash: script.cdp_hash,
             length: script.length,
             is_module: script.is_module,
@@ -132,7 +128,7 @@ const workerEntities = (capture) => capture.inspection.workers.map((worker) => {
         label: location.value,
         properties: {
             runtime_type: worker.type,
-            location: location.value.slice(0, 4_096),
+            location: location.value,
             attached: worker.attached,
             opener_target_id: worker.opener_target_id,
             parent_frame_id: worker.parent_frame_id,
@@ -159,7 +155,7 @@ const runtimeEntity = (capture, input) => ({
         },
         observations: [
             {
-                label: input.label.slice(0, 1_024) || null,
+                label: input.label || null,
                 properties: input.properties,
                 evidence: runtimeEvidence(capture, input),
             },

package/dist/domain/javascriptRuntimeReconciliationSchemas.js

@@ -5,10 +5,9 @@ import { compareCodePoints, javascriptApplicationGraphSchema, } from "./javascri
 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);
+const boundedTextSchema = z.string().min(1);
 const safePrefixSchema = z
     .string()
-    .max(4_096)
     .refine((value) => value === "" ||
     (!value.startsWith("/") &&
         !value.includes("\\") &&
@@ -18,7 +17,6 @@ const runtimeFileMappingSchema = z.strictObject({
     root: z
         .string()
         .min(1)
-        .max(16_384)
         .refine(isAbsolute, "Runtime file mapping root must be absolute")
         .overwrite((value) => resolve(value)),
     artifact_prefix: safePrefixSchema.default(""),
@@ -28,7 +26,6 @@ const runtimeUrlMappingSchema = z.strictObject({
     prefix: z
         .string()
         .min(1)
-        .max(16_384)
         .refine((value) => normalizeRuntimeUrlPrefix(value) !== null, "Runtime URL prefix must be HTTP(S) without credentials, query, or fragment")
         .overwrite((value) => normalizeRuntimeUrlPrefix(value) ?? value),
     artifact_prefix: safePrefixSchema.default(""),
@@ -61,7 +58,6 @@ const staticLayerSchema = z.strictObject({
     analysis: evidenceSchema,
     runtime_mappings: z
         .array(runtimeLocationMappingSchema)
-        .max(32)
         .overwrite(normalizeRuntimeMappings)
         .default([]),
 });
@@ -75,21 +71,11 @@ function runtimeMappingKey(mapping) {
         ? `file-root\0${mapping.root}\0${mapping.artifact_prefix}`
         : `url-prefix\0${mapping.prefix}\0${mapping.artifact_prefix}`;
 }
-const reconciliationLimitsSchema = z.strictObject({
-    max_runtime_entities: z.number().int().min(1).max(50_000).default(10_000),
-    max_reconciliation_items: z.number().int().min(1).max(50_000).default(20_000),
-    max_static_load_states: z.number().int().min(1).max(50_000).default(20_000),
-});
 /** Evidence-backed static layers and passive captures to reconcile. */
 export const reconcileJavaScriptRuntimeInputSchema = z
     .strictObject({
-    static_layers: z.array(staticLayerSchema).min(1).max(8),
-    runtime_observations: z.array(evidenceSchema).min(1).max(32),
-    limits: reconciliationLimitsSchema.default({
-        max_runtime_entities: 10_000,
-        max_reconciliation_items: 20_000,
-        max_static_load_states: 20_000,
-    }),
+    static_layers: z.array(staticLayerSchema).min(1),
+    runtime_observations: z.array(evidenceSchema).min(1),
 })
     .superRefine((input, context) => {
     if (input.static_layers.filter(({ role }) => role === "application")
@@ -113,12 +99,6 @@ export const reconcileJavaScriptRuntimeInputSchema = z
             path: ["runtime_observations"],
             message: "Runtime observation Evidence must be unique",
         });
-    if (input.limits.max_runtime_entities < input.runtime_observations.length)
-        context.addIssue({
-            code: "custom",
-            path: ["limits", "max_runtime_entities"],
-            message: "Runtime entity limit must retain one target per observation",
-        });
 });
 const layerSummarySchema = z.strictObject({
     layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
@@ -126,17 +106,17 @@ const layerSummarySchema = z.strictObject({
     evidence_id: evidenceIdSchema,
     graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
     root_artifact_sha256: digestSchema,
-    input_path: z.string().min(1).max(16_384),
+    input_path: z.string().min(1),
     format: z.enum(["asar", "directory"]),
-    runtime_mappings: z.array(runtimeLocationMappingSchema).max(32),
+    runtime_mappings: z.array(runtimeLocationMappingSchema),
 });
 const captureSummarySchema = z.strictObject({
     evidence_id: evidenceIdSchema,
     capture_sha256: digestSchema,
-    kind: z.enum(["browser", "electron", "v8-inspector"]),
+    kind: z.enum(["browser", "electron", "v8-inspector", "electron-active"]),
     target_node_id: nodeIdSchema,
     target_key: boundedTextSchema,
-    target_location: boundedTextSchema,
+    target_location: z.string().min(1),
     frames: z.number().int().min(0),
     scripts: z.number().int().min(0),
     workers: z.number().int().min(0),
@@ -154,17 +134,11 @@ const reconciliationReasonSchema = z.enum([
     "static-or-runtime-coverage-incomplete",
     "reconciliation-limit-reached",
 ]);
-const reconciliationItemSchema = z.strictObject({
+const reconciliationItemShape = {
     reconciliation_id: z.string().regex(/^jrr_item_[a-f0-9]{64}$/u),
     entity_kind: z.enum(["target", "frame", "script", "worker"]),
     runtime_evidence_id: evidenceIdSchema,
     runtime_node_id: nodeIdSchema,
-    static_layer_id: z
-        .string()
-        .regex(/^jrl_[a-f0-9]{64}$/u)
-        .nullable(),
-    static_node_id: nodeIdSchema.nullable(),
-    status: z.enum(["matched", "ambiguous", "unmatched", "unknown"]),
     basis: z.enum([
         "content-and-location",
         "content-sha256",
@@ -176,14 +150,26 @@ const reconciliationItemSchema = z.strictObject({
     ]),
     confidence: z.enum(["exact", "high", "medium", "low", "unknown"]),
     reason: reconciliationReasonSchema,
-    candidate_static_count: z.number().int().min(0).max(800_000),
-    candidate_static_nodes: z
-        .array(z.strictObject({
+    candidate_static_count: z.number().int().min(0),
+    candidate_static_nodes: z.array(z.strictObject({
         static_layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
         static_node_id: nodeIdSchema,
-    }))
-        .max(1_000),
-});
+    })),
+};
+const reconciliationItemSchema = z.union([
+    z.strictObject({
+        ...reconciliationItemShape,
+        static_layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
+        static_node_id: nodeIdSchema,
+        status: z.literal("matched"),
+    }),
+    z.strictObject({
+        ...reconciliationItemShape,
+        static_layer_id: z.null(),
+        static_node_id: z.null(),
+        status: z.enum(["ambiguous", "unmatched", "unknown"]),
+    }),
+]);
 const staticLoadStateSchema = z.strictObject({
     static_layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
     static_node_id: nodeIdSchema,
@@ -194,7 +180,7 @@ const staticLoadStateSchema = z.strictObject({
         "not-observed-in-capture",
         "unknown",
     ]),
-    runtime_node_ids: z.array(nodeIdSchema).max(10_000),
+    runtime_node_ids: z.array(nodeIdSchema),
     reason: z.enum([
         "runtime-script-correspondence",
         "containing-asset-was-loaded",
@@ -205,10 +191,9 @@ const staticLoadStateSchema = z.strictObject({
 });
 /** Deterministic static/passive-runtime reconciliation with a combined JAG. */
 export const javascriptRuntimeReconciliationResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     reconciliation_id: z.string().regex(/^jrr_[a-f0-9]{64}$/u),
-    static_layers: z.array(layerSummarySchema).min(1).max(8),
-    runtime_captures: z.array(captureSummarySchema).min(1).max(32),
+    static_layers: z.array(layerSummarySchema).min(1),
+    runtime_captures: z.array(captureSummarySchema).min(1),
     graph: javascriptApplicationGraphSchema,
     summary: z.strictObject({
         runtime_targets: z.number().int().min(0),
@@ -224,11 +209,11 @@ export const javascriptRuntimeReconciliationResultSchema = z.strictObject({
         static_not_observed: z.number().int().min(0),
         static_unknown: z.number().int().min(0),
     }),
-    reconciliations: z.array(reconciliationItemSchema).max(50_000),
-    static_load_states: z.array(staticLoadStateSchema).max(50_000),
+    reconciliations: z.array(reconciliationItemSchema),
+    static_load_states: z.array(staticLoadStateSchema),
     source_map_authority: z.strictObject({
         used_for_primary_matching: z.literal(false),
-        static_layers_with_read_approval: z.number().int().min(0),
+        static_layer_count: z.number().int().min(0),
         runtime_script_declarations: z.number().int().min(0),
         limitation: boundedTextSchema,
     }),
@@ -240,6 +225,6 @@ export const javascriptRuntimeReconciliationResultSchema = z.strictObject({
         omitted_static_load_states: z.number().int().min(0),
         omitted_graph_items: z.number().int().min(0),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(2).max(40),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    evidence_links: z.array(evidenceIdSchema).min(2),
+    limitations: z.array(boundedTextSchema),
 });

package/dist/domain/javascriptRuntimeStaticCandidates.js

@@ -1,4 +1,5 @@
-import { isAbsolute, posix, relative } from "node:path";
+import { posix, relative } from "node:path";
+import { isPathWithinRoot } from "./localPath.js";
 import { compareCodePoints, } from "./javascriptApplicationGraph.js";
 /** Index statically reconstructed entities that can receive runtime matches. */
 export const collectStaticRuntimeCandidates = (layers) => layers
@@ -131,8 +132,7 @@ const candidateDigests = (node) => {
 const pathBelowRoot = (root, value) => {
     const remainder = relative(root, value);
     if (remainder === "" ||
-        remainder.startsWith("..") ||
-        isAbsolute(remainder) ||
+        !isPathWithinRoot(root, value) ||
         remainder.includes("\\"))
         return null;
     return normalizeArtifactPath(remainder);

package/dist/domain/javascriptSemanticAnalysis.js

@@ -1,23 +1,23 @@
 import * as t from "@babel/types";
-import { DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS, failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
-import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, reachSemanticLimit, semanticModuleOrigin, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
+import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, semanticModuleOrigin, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { currentSemanticScope, resolveSemanticBindingFromScope, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { collectSemanticReturns, resolveSemanticModuleCallables, } from "./javascriptSemanticReturns.js";
 import { collectJavaScriptDerivedSemantics } from "./javascriptSemanticDerivedAnalysis.js";
-import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
+import { propertyName, range } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticCoverage } from "./javascriptSemanticCoverage.js";
 import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
-/** Recover bounded lexical bindings, aliases, constants, and module links. */
-export const analyzeJavaScriptSemantics = (source, inputLimits = {}) => {
+/** Recover lexical bindings, aliases, constants, and module links. */
+export const analyzeJavaScriptSemantics = (source) => {
     const file = parseJavaScriptSource(source);
     return file === null
         ? failedJavaScriptSemanticIr()
-        : analyzeParsedJavaScriptSemantics(file, inputLimits);
+        : analyzeParsedJavaScriptSemantics(file);
 };
 /** Recover semantics from an already parsed JavaScript artifact. */
-export const analyzeParsedJavaScriptSemantics = (file, inputLimits = {}) => {
-    const limits = { ...DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS, ...inputLimits };
-    const state = createState(file.program, limits);
+export const analyzeParsedJavaScriptSemantics = (file) => {
+    const state = createState(file.program);
     collectDefinitions(file.program, state);
     const references = collectSemanticReferences(file.program, state);
     const parserPartial = file.errors.length > 0;
@@ -27,31 +27,19 @@ export const analyzeParsedJavaScriptSemantics = (file, inputLimits = {}) => {
     const derived = collectJavaScriptDerivedSemantics(file.program, state, callables, parserPartial);
     return {
         schema: "JavaScriptSemanticIR",
-        schemaVersion: 4,
         scopes: immutableSemanticScopes(state),
         bindings,
         callables,
         references,
         moduleLinks,
         ...derived,
-        coverage: {
-            status: state.limitsReached.size > 0
-                ? "truncated"
-                : parserPartial
-                    ? "partial"
-                    : "complete",
-            omittedCount: state.limitsReached.size > 0 ? state.omittedCount : 0,
-            limitsReached: [...state.limitsReached].sort(compareCodePoints),
-        },
+        coverage: semanticCoverage(parserPartial),
         limitations: [
             ...(parserPartial
                 ? [
                     "The parser recovered from syntax errors; affected bindings are partial.",
                 ]
                 : []),
-            ...(state.limitsReached.size === 0
-                ? []
-                : ["Semantic recovery stopped retaining facts at explicit limits."]),
             "Values and aliases were recovered from inert syntax only; no JavaScript was executed.",
             "Return sites include only direct callable returns; nested callable returns remain separate.",
             "Local call, argument, return, and closure relations are static candidates and do not prove runtime invocation.",
@@ -60,7 +48,7 @@ export const analyzeParsedJavaScriptSemantics = (file, inputLimits = {}) => {
         ],
     };
 };
-const createState = (program, limits) => {
+const createState = (program) => {
     const root = {
         scopeId: semanticScopeId("program", program),
         parentScopeId: null,
@@ -70,7 +58,6 @@ const createState = (program, limits) => {
         bindings: new Map(),
     };
     return {
-        limits,
         scopes: [root],
         scopesById: new Map([[root.scopeId, root]]),
         scopeByNode: new WeakMap([[program, root]]),
@@ -78,8 +65,6 @@ const createState = (program, limits) => {
         callables: [],
         callableNodesById: new Map(),
         moduleLinks: [],
-        limitsReached: new Set(),
-        omittedCount: 0,
     };
 };
 const collectDefinitions = (program, state) => {
@@ -167,17 +152,6 @@ const nestedScope = (node, parent, parentScope, state) => {
     const kind = scopeKind(node, parent);
     if (kind === undefined)
         return undefined;
-    if (state.scopes.length >= state.limits.maxScopes) {
-        reachSemanticLimit(state, "maxScopes");
-        return {
-            scopeId: `${semanticScopeId(kind, node)}:omitted`,
-            parentScopeId: parentScope.scopeId,
-            kind,
-            location: range(node),
-            bindingsComplete: false,
-            bindings: new Map(),
-        };
-    }
     const scope = {
         scopeId: semanticScopeId(kind, node),
         parentScopeId: parentScope.scopeId,
@@ -324,15 +298,8 @@ const addBinding = (input) => {
     const { state, scope, name, kind, mutable, definitionNode, initializer, directOrigin, projection = [], } = input;
     let binding = scope.bindings.get(name);
     if (binding === undefined) {
-        if (!scope.bindingsComplete) {
-            state.omittedCount += 1;
+        if (!scope.bindingsComplete)
             return;
-        }
-        if (state.bindingsById.size >= state.limits.maxBindings) {
-            scope.bindingsComplete = false;
-            reachSemanticLimit(state, "maxBindings");
-            return;
-        }
         binding = createBinding(scope, name, kind, mutable);
         scope.bindings.set(name, binding);
         state.bindingsById.set(binding.bindingId, binding);

package/dist/domain/javascriptSemanticAsyncEffects.js

@@ -1,5 +1,5 @@
 import * as t from "@babel/types";
-import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -67,10 +67,6 @@ const collectEvent = (node, ownerCallableId, state, output) => {
     if (method === undefined)
         return;
     const kind = eventKind(method);
-    if (output.length >= state.limits.maxEventOperations) {
-        reachSemanticLimit(state, "maxEventOperations");
-        return;
-    }
     const eventArgument = node.arguments[0];
     const listenerArgument = node.arguments[1];
     const emitter = emitterIdentity(member.object, state);
@@ -130,10 +126,6 @@ const collectTimer = (input) => {
     const method = timerMethod(node.callee, state);
     if (method === null)
         return;
-    if (output.length >= state.limits.maxTimerOperations) {
-        reachSemanticLimit(state, "maxTimerOperations");
-        return;
-    }
     const kind = TIMER_SCHEDULE_METHODS.some((candidate) => candidate === method)
         ? "schedule"
         : "cancel";

package/dist/domain/javascriptSemanticCallResolution.js

@@ -1,24 +1,15 @@
 import * as t from "@babel/types";
-import { reachSemanticLimit, semanticCallableIdForNode, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { compareCodePoints, range } from "./javascriptStaticAnalysisHelpers.js";
-/** Resolve bounded local callable candidates without following dynamic properties. */
+/** Resolve local callable candidates without following dynamic properties. */
 export const resolveLocalCallables = (input) => resolveCallables(input.node, {
     state: input.state,
     callableById: input.callableById,
     seenBindings: input.seenBindings,
-    depth: input.depth,
     bindingCache: input.bindingCache,
 });
 const resolveCallables = (node, context) => {
-    if (context.depth >= context.state.limits.maxValueDepth) {
-        reachSemanticLimit(context.state, "maxValueDepth");
-        return {
-            callableIds: [],
-            complete: false,
-            reason: "Call target depth limit reached.",
-        };
-    }
     const direct = semanticCallableIdForNode(node);
     if (direct !== null && context.callableById.has(direct))
         return {
@@ -31,7 +22,7 @@ const resolveCallables = (node, context) => {
     if (t.isTSAsExpression(node) ||
         t.isTSTypeAssertion(node) ||
         t.isTSNonNullExpression(node))
-        return resolveCallables(node.expression, nestedContext(context));
+        return resolveCallables(node.expression, context);
     if (t.isConditionalExpression(node) || t.isLogicalExpression(node))
         return resolveAlternatives(t.isConditionalExpression(node) ? node.consequent : node.left, t.isConditionalExpression(node) ? node.alternate : node.right, context);
     return {
@@ -48,10 +39,10 @@ const resolveIdentifier = (node, context) => {
             complete: false,
             reason: `Unresolved call target ${node.name}.`,
         }
-        : resolveBindingCallables(binding, nestedContext(context));
+        : resolveBindingCallables(binding, context);
 };
 const resolveAlternatives = (left, right, context) => {
-    const candidates = [left, right].map((candidate) => resolveCallables(candidate, nestedContext(context)));
+    const candidates = [left, right].map((candidate) => resolveCallables(candidate, context));
     return {
         callableIds: uniqueCallableIds(candidates.flatMap(({ callableIds }) => callableIds)),
         complete: candidates.every(({ complete }) => complete),
@@ -71,7 +62,7 @@ const resolveBindingCallables = (binding, context) => {
     if (binding.initializers.length === 0)
         return missingBindingInitializer(binding);
     const candidateContext = {
-        ...nestedContext(context),
+        ...context,
         seenBindings: new Set([...context.seenBindings, binding.bindingId]),
     };
     const candidates = binding.initializers.map(({ node, projection }) => projection.length === 0
@@ -125,5 +116,4 @@ const rangeContains = (outer, inner) => (outer.start.line < inner.start.line ||
     (outer.end.line > inner.end.line ||
         (outer.end.line === inner.end.line &&
             outer.end.column >= inner.end.column));
-const nestedContext = (context) => ({ ...context, depth: context.depth + 1 });
 const uniqueCallableIds = (values) => [...new Set(values)].sort(compareCodePoints);

package/dist/domain/javascriptSemanticCalls.js

@@ -1,10 +1,10 @@
 import * as t from "@babel/types";
-import { reachSemanticLimit, semanticCallableIdForNode, semanticReferenceRole, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticReferenceRole, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { parameterBindings, resolveLocalCallables, } from "./javascriptSemanticCallResolution.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
-/** Recover bounded direct-call and lexical-capture candidates from inert syntax. */
+/** Recover direct-call and lexical-capture candidates from inert syntax. */
 export const collectJavaScriptSemanticCalls = (program, state, callables) => {
     const output = {
         callSites: [],
@@ -13,7 +13,6 @@ export const collectJavaScriptSemanticCalls = (program, state, callables) => {
         callResultFlows: [],
         closureCaptures: [],
         frontiers: [],
-        retainedArguments: 0,
     };
     const callableById = new Map(callables.map((callable) => [callable.callableId, callable]));
     const context = {
@@ -56,20 +55,15 @@ export const collectJavaScriptSemanticCalls = (program, state, callables) => {
 };
 const collectCallSite = (node, parent, owner, context) => {
     const { state, callableById, output } = context;
-    if (output.callSites.length >= state.limits.maxCallSites) {
-        reachSemanticLimit(state, "maxCallSites");
-        return;
-    }
     const resolution = resolveLocalCallables({
         node: node.callee,
         state,
         callableById,
         seenBindings: new Set(),
-        depth: 0,
         bindingCache: context.bindingResolutionCache,
     });
     const callSiteId = semanticCallSiteId(node);
-    const argumentsValue = retainedArguments(node.arguments, state, output);
+    const argumentsValue = retainedArguments(node.arguments);
     const site = {
         callSiteId,
         kind: t.isNewExpression(node) ? "construct" : "call",
@@ -123,14 +117,9 @@ const collectCallResultFlow = (site, node, parent, context) => {
         definitionLocation: definition.location,
     });
 };
-const retainedArguments = (nodes, state, output) => {
+const retainedArguments = (nodes) => {
     const retained = [];
     for (const [index, node] of nodes.entries()) {
-        if (output.retainedArguments >= state.limits.maxCallArguments) {
-            reachSemanticLimit(state, "maxCallArguments");
-            break;
-        }
-        output.retainedArguments += 1;
         retained.push({
             index,
             location: range(node),
@@ -140,7 +129,7 @@ const retainedArguments = (nodes, state, output) => {
     return retained;
 };
 const collectArgumentFlows = (site, node, context) => {
-    const { state, callableById, output } = context;
+    const { callableById, output } = context;
     const retainedIndexes = new Set(site.arguments.map(({ index }) => index));
     let positionIsExact = true;
     for (const [index, argument] of node.arguments.entries()) {
@@ -157,10 +146,6 @@ const collectArgumentFlows = (site, node, context) => {
             if (callable === undefined)
                 continue;
             for (const parameter of cachedParameterBindings(callable, index, context)) {
-                if (output.argumentFlows.length >= state.limits.maxArgumentFlows) {
-                    reachSemanticLimit(state, "maxArgumentFlows");
-                    return;
-                }
                 const definition = parameter.definitions.find(({ kind }) => kind === "parameter");
                 if (definition === undefined)
                     continue;
@@ -191,10 +176,6 @@ const collectReturnFlows = (site, callableById, state, output) => {
         if (callable === undefined)
             continue;
         for (const returnSite of callable.returnSites) {
-            if (output.callReturnFlows.length >= state.limits.maxCallReturnFlows) {
-                reachSemanticLimit(state, "maxCallReturnFlows");
-                return;
-            }
             output.callReturnFlows.push({
                 callSiteId: site.callSiteId,
                 callableId,
@@ -217,10 +198,6 @@ const collectCapture = (node, parent, owner, context) => {
     if (binding === undefined ||
         bindingIsWithinCallable(binding, owner.bodyScopeId, state))
         return;
-    if (output.closureCaptures.length >= state.limits.maxClosureCaptures) {
-        reachSemanticLimit(state, "maxClosureCaptures");
-        return;
-    }
     output.closureCaptures.push({
         callableId: owner.callableId,
         bindingId: binding.bindingId,
@@ -247,10 +224,6 @@ const collectDynamicProperty = (node, owner, state, output) => {
         }, state, output);
 };
 const addFrontier = (frontier, state, output) => {
-    if (output.frontiers.length >= state.limits.maxFrontiers) {
-        reachSemanticLimit(state, "maxFrontiers");
-        return;
-    }
     output.frontiers.push(frontier);
 };
 const bindingIsWithinCallable = (binding, bodyScopeId, state) => {

package/dist/domain/javascriptSemanticChildProcesses.js

@@ -1,5 +1,5 @@
 import * as t from "@babel/types";
-import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
@@ -28,8 +28,6 @@ const collectSpawns = (program, state, callables) => {
             const method = childProcessMethod(node.callee, state);
             if (method === null)
                 return;
-            if (operationLimitReached(output.length, state))
-                return;
             output.push({
                 node,
                 method,
@@ -86,8 +84,6 @@ const collectInteractions = (program, state, callables, spawns) => {
             const interaction = childInteraction(node, callableStack.at(-1) ?? null, context);
             if (interaction === null)
                 return;
-            if (operationLimitReached(spawns.length + output.length, state))
-                return;
             output.push(interaction);
         },
         exit: (node) => popCallable(node, callableStack),
@@ -220,12 +216,6 @@ const literalString = (node) => {
         return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
     return null;
 };
-const operationLimitReached = (retained, state) => {
-    if (retained < state.limits.maxChildProcessOperations)
-        return false;
-    reachSemanticLimit(state, "maxChildProcessOperations");
-    return true;
-};
 const popCallable = (node, stack) => {
     const callableId = semanticCallableIdForNode(node);
     if (callableId !== null && stack.at(-1) === callableId)

package/dist/domain/javascriptSemanticCoverage.js

@@ -0,0 +1,11 @@
+/** Classify whole-file semantic coverage from parser recovery. */
+export const semanticCoverage = (parserPartial) => ({
+    status: parserPartial ? "partial" : "complete",
+    omittedCount: 0,
+});
+/** Classify one callable's direct-return coverage. */
+export const semanticReturnCoverage = (retainedCount, parserPartial) => ({
+    status: parserPartial ? "partial" : "complete",
+    retainedCount,
+    omittedCount: 0,
+});