rea-agents 6.2.0 → 6.4.0

package/dist/domain/javascript/javascriptSemanticCalls.js

@@ -262,4 +262,11 @@ const bindingIsWithinCallable = (binding, bodyScopeId, state) => {
     return false;
 };
 const enclosingFunction = (stack) => stack.findLast(({ kind }) => kind !== "class");
-const semanticCallSiteId = (node) => `call:${t.isNewExpression(node) ? "construct" : "call"}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;
+const semanticCallSiteId = (node) => 
+// Join once so retained IDs do not keep a chain of intermediate strings.
+[
+    "call",
+    t.isNewExpression(node) ? "construct" : "call",
+    String(node.start ?? -1),
+    String(node.end ?? -1),
+].join(":");

package/dist/domain/javascript/javascriptSemanticChildProcesses.js

@@ -3,7 +3,7 @@ import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js"
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { dataEffectLiteralString, dataEffectMemberCallee, assignedSemanticResultBindings, scalarAssignedResultBinding, semanticProjectedBindingFacts, } from "./javascriptSemanticDataEffectHelpers.js";
@@ -130,7 +130,7 @@ const childInteraction = (node, ownerCallableId, context) => {
         processBindingId: binding?.bindingId ?? null,
         linkedProcessIds: linked
             .map((candidate) => spawnId(candidate))
-            .sort(compareCodePoints),
+            .sort(compareUnicodeCodePoints),
         eventName: kind === "listener" ? eventName : null,
         signalName: kind === "signal"
             ? (dataEffectLiteralString(node.arguments[0]) ?? "SIGTERM")

package/dist/domain/javascript/javascriptSemanticCoverage.js

@@ -1,9 +1,29 @@
+import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT, } from "./javascriptSemanticResourceLimits.js";
 /** Classify whole-file semantic coverage from parsing and value bounds. */
 export const semanticCoverage = (parserPartial, resourceLimits = []) => resourceLimits.length > 0
     ? { status: "partial", omittedCount: null, resourceLimits }
     : { status: parserPartial ? "partial" : "complete", omittedCount: 0 };
 /** Read typed resource-limit classifications from any coverage state. */
 export const semanticCoverageResourceLimits = (coverage) => coverage.resourceLimits ?? [];
+const semanticResourceBounds = {
+    "primitive-candidates": {
+        value: SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT,
+        unit: "items",
+    },
+    "primitive-bytes": {
+        value: SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT,
+        unit: "bytes",
+    },
+    "expression-depth": {
+        value: SEMANTIC_EXPRESSION_DEPTH_LIMIT,
+        unit: "depth",
+    },
+};
+/** Map semantic evaluator bounds to their caller-visible application coverage. */
+export const semanticResourceLimitCoverage = (resourceLimits) => resourceLimits.map((resourceLimit) => ({
+    name: `javascript_semantic_${resourceLimit.replaceAll("-", "_")}`,
+    ...semanticResourceBounds[resourceLimit],
+}));
 /** Classify one callable's direct-return coverage. */
 export const semanticReturnCoverage = (retainedCount, parserPartial) => ({
     status: parserPartial ? "partial" : "complete",

package/dist/domain/javascript/javascriptSemanticDataEffectHelpers.js

@@ -3,7 +3,7 @@ import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js"
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { readExactJavaScriptLiteral, semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 /** Resolve bindings written by the nearest variable or assignment owner. */
 export const assignedSemanticResultBindings = (node, ancestors, state) => {
     for (let index = ancestors.length - 1; index >= 0; index -= 1) {
@@ -34,14 +34,12 @@ const assignedSourceIs = (node, source) => {
     while (true) {
         if (t.isAwaitExpression(value))
             value = value.argument;
-        else if (t.isParenthesizedExpression(value) ||
-            t.isTSAsExpression(value) ||
-            t.isTSTypeAssertion(value) ||
-            t.isTypeCastExpression(value) ||
-            t.isTSSatisfiesExpression(value))
-            value = value.expression;
-        else
-            break;
+        else {
+            const unwrapped = unwrapJavaScriptExpression(value).node;
+            if (unwrapped === value)
+                break;
+            value = unwrapped;
+        }
     }
     return value === node;
 };

package/dist/domain/javascript/javascriptSemanticDataEffects.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
-import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -101,14 +101,7 @@ const collectDefaults = (program, context, configurations) => {
         if (!t.isLogicalExpression(node) ||
             (node.operator !== "??" && node.operator !== "||"))
             return;
-        let source = node.left;
-        while (t.isParenthesizedExpression(source) ||
-            t.isTSAsExpression(source) ||
-            t.isTSTypeAssertion(source) ||
-            t.isTypeCastExpression(source) ||
-            t.isTSSatisfiesExpression(source) ||
-            t.isTSNonNullExpression(source))
-            source = source.expression;
+        const source = unwrapJavaScriptExpression(node.left).node;
         const candidate = configurationsByNode.get(source);
         if (candidate === undefined)
             return;
@@ -197,7 +190,7 @@ const collectResponseConsumers = (program, context, requests) => {
             projectedResultBindings: semanticProjectedBindingFacts(assignedSemanticResultBindings(node, context.ancestors, context.state).filter(({ projectionPath }) => projectionPath.length > 0)),
             linkedRequestIds: linked
                 .map(({ operation }) => operation.requestId)
-                .sort(compareCodePoints),
+                .sort(compareUnicodeCodePoints),
             endpoint: null,
             fields: [],
             resolution: linked.length === 1 &&

package/dist/domain/javascript/javascriptSemanticDerivedAnalysis.js

@@ -1,21 +1,32 @@
 import { collectJavaScriptSemanticAsyncEffects } from "./javascriptSemanticAsyncEffects.js";
 import { collectJavaScriptSemanticCalls } from "./javascriptSemanticCalls.js";
 import { collectJavaScriptSemanticChildProcesses } from "./javascriptSemanticChildProcesses.js";
-import { collectJavaScriptSemanticFingerprints } from "./javascriptSemanticFingerprints.js";
+import { collectJavaScriptSemanticFingerprintsSteps } from "./javascriptSemanticFingerprints.js";
 import { collectJavaScriptSemanticDataEffects } from "./javascriptSemanticDataEffects.js";
 import { collectJavaScriptSemanticPromises } from "./javascriptSemanticPromises.js";
 import { collectJavaScriptSemanticObjects } from "./javascriptSemanticObjects.js";
 import { collectJavaScriptSemanticResources } from "./javascriptSemanticResources.js";
 /** Compose bounded semantic passes after lexical definitions are available. */
-export const collectJavaScriptDerivedSemantics = (program, state, callables, parserPartial) => {
+/**
+ * Collect derived semantics with a yield between collectors. Each collector
+ * completes before the next starts, so results equal the synchronous form.
+ */
+export function* collectJavaScriptDerivedSemanticsSteps(program, state, callables, parserPartial) {
     const calls = collectJavaScriptSemanticCalls(program, state, callables);
+    yield;
     const promiseOperations = collectJavaScriptSemanticPromises(program, state, callables);
+    yield;
     const asyncEffects = collectJavaScriptSemanticAsyncEffects(program, state, callables);
+    yield;
     const childProcesses = collectJavaScriptSemanticChildProcesses(program, state, callables);
+    yield;
     const dataEffects = collectJavaScriptSemanticDataEffects(program, state, callables);
+    yield;
     const resourceOperations = collectJavaScriptSemanticResources(program, state, callables);
+    yield;
     const objectOperations = collectJavaScriptSemanticObjects(program, state, callables);
-    const functionFingerprints = collectJavaScriptSemanticFingerprints({
+    yield;
+    const functionFingerprints = yield* collectJavaScriptSemanticFingerprintsSteps({
         state,
         callables,
         calls,
@@ -38,4 +49,4 @@ export const collectJavaScriptDerivedSemantics = (program, state, callables, par
         objectOperations,
         functionFingerprints,
     };
-};
+}

package/dist/domain/javascript/javascriptSemanticFileProjection.js

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

package/dist/domain/javascript/javascriptSemanticFingerprints.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
-import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-/** Build bounded rename- and formatting-resistant components per callable. */
-export const collectJavaScriptSemanticFingerprints = (input) => {
+import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";
+/** Build bounded rename- and formatting-resistant components per callable, yielding between callables. */
+export function* collectJavaScriptSemanticFingerprintsSteps(input) {
     const { state, callables, calls, promises, events, timers, childProcessSpawns, childProcessInteractions, requestOperations, resourceOperations, parserPartial, } = input;
     const callSitesByCaller = groupByOwner(calls.callSites, ({ callerCallableId }) => callerCallableId);
     const captureCountByCallable = countByOwner(calls.closureCaptures, ({ callableId }) => callableId);
@@ -14,53 +14,54 @@ export const collectJavaScriptSemanticFingerprints = (input) => {
     const childProcessEffectsByOwner = groupByOwner([...childProcessSpawns, ...childProcessInteractions], ownerId);
     const networkEffectsByOwner = groupByOwner(requestOperations, ownerId);
     const resourceEffectsByOwner = groupByOwner(resourceOperations, ownerId);
-    return callables.flatMap((callable) => {
+    const fingerprints = [];
+    for (const callable of callables) {
         if (callable.kind === "class")
-            return [];
+            continue;
         const node = state.callableNodesById.get(callable.callableId);
         if (node === undefined)
-            return [];
-        const syntax = fingerprintSyntax(node, callable.callableId);
+            continue;
+        yield;
+        const syntax = yield* fingerprintSyntaxSteps(node, callable.callableId);
         const promiseEffects = promiseEffectsByOwner.get(callable.callableId) ?? [];
         const eventEffects = eventEffectsByOwner.get(callable.callableId) ?? [];
         const timerEffects = timerEffectsByOwner.get(callable.callableId) ?? [];
         const childProcessEffects = childProcessEffectsByOwner.get(callable.callableId) ?? [];
         const networkEffects = networkEffectsByOwner.get(callable.callableId) ?? [];
         const resourceEffects = resourceEffectsByOwner.get(callable.callableId) ?? [];
-        return [
-            {
-                callableId: callable.callableId,
-                status: parserPartial || callable.returnCoverage.status !== "complete"
-                    ? "partial"
-                    : "complete",
-                components: {
-                    parameterArity: callableParameterArity(node),
-                    normalizedAstSha256: digest(syntax.normalizedTokens),
-                    controlFlowSha256: digest(syntax.controlFlowTokens),
-                    relationShapeSha256: digest(relationShape(callable, callSitesByCaller.get(callable.callableId) ?? [], captureCountByCallable.get(callable.callableId) ?? 0, promiseEffects)),
-                    literalSetSha256: digest([...new Set(syntax.literals)].sort(compareCodePoints)),
-                    effects: [
-                        ...(isAsyncCallable(node) ? ["async"] : []),
-                        ...(childProcessEffects.length > 0
-                            ? ["child-process"]
-                            : []),
-                        ...(eventEffects.length > 0 ? ["event"] : []),
-                        ...(networkEffects.length > 0 ? ["network"] : []),
-                        ...(promiseEffects.length > 0 ? ["promise"] : []),
-                        ...(resourceEffects.length > 0 ? ["resource"] : []),
-                        ...(timerEffects.length > 0 ? ["timer"] : []),
-                    ],
-                },
-                limitations: [
-                    "The fingerprint is a static candidate and does not prove behavioral equivalence.",
-                    ...(parserPartial
-                        ? ["Incomplete semantic recovery makes this fingerprint partial."]
+        fingerprints.push({
+            callableId: callable.callableId,
+            status: parserPartial || callable.returnCoverage.status !== "complete"
+                ? "partial"
+                : "complete",
+            components: {
+                parameterArity: callableParameterArity(node),
+                normalizedAstSha256: digest(syntax.normalizedTokens),
+                controlFlowSha256: digest(syntax.controlFlowTokens),
+                relationShapeSha256: digest(relationShape(callable, callSitesByCaller.get(callable.callableId) ?? [], captureCountByCallable.get(callable.callableId) ?? 0, promiseEffects)),
+                literalSetSha256: digest([...new Set(syntax.literals)].sort(compareUnicodeCodePoints)),
+                effects: [
+                    ...(isAsyncCallable(node) ? ["async"] : []),
+                    ...(childProcessEffects.length > 0
+                        ? ["child-process"]
                         : []),
+                    ...(eventEffects.length > 0 ? ["event"] : []),
+                    ...(networkEffects.length > 0 ? ["network"] : []),
+                    ...(promiseEffects.length > 0 ? ["promise"] : []),
+                    ...(resourceEffects.length > 0 ? ["resource"] : []),
+                    ...(timerEffects.length > 0 ? ["timer"] : []),
                 ],
             },
-        ];
-    });
-};
+            limitations: [
+                "The fingerprint is a static candidate and does not prove behavioral equivalence.",
+                ...(parserPartial
+                    ? ["Incomplete semantic recovery makes this fingerprint partial."]
+                    : []),
+            ],
+        });
+    }
+    return fingerprints;
+}
 const ownerId = (value) => value.ownerCallableId;
 const groupByOwner = (values, getOwner) => {
     const grouped = new Map();
@@ -82,12 +83,12 @@ const countByOwner = (values, getOwner) => {
     }
     return counts;
 };
-const fingerprintSyntax = (root, targetCallableId) => {
+function* fingerprintSyntaxSteps(root, targetCallableId) {
     const normalizedTokens = [];
     const controlFlowTokens = [];
     const literals = [];
     const callableStack = [];
-    traverseJavaScriptAst(root, {
+    yield* traverseJavaScriptAstSteps(root, {
         enter: (node, parent) => {
             const callableId = semanticCallableIdForNode(node);
             if (callableId !== null)
@@ -109,7 +110,7 @@ const fingerprintSyntax = (root, targetCallableId) => {
         },
     });
     return { normalizedTokens, controlFlowTokens, literals };
-};
+}
 const normalizedNodeToken = (node, parent) => {
     if (t.isIdentifier(node))
         return propertyIdentity(node, parent)