rea-agents 6.3.0 → 6.4.0

package/dist/domain/javascript/javascriptSemanticAnalysis.js

@@ -1,17 +1,21 @@
 import * as t from "@babel/types";
 import { failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
-import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, } from "./javascriptSemanticProjection.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
-import { currentSemanticScope, resolveSemanticBindingState, semanticResolutionBlocked, resolveSemanticBindingFromScope, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
-import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { collectSemanticMemberMutations } from "./javascriptSemanticMemberMutations.js";
+import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, collectSemanticReferencesSteps, immutableSemanticBindings, immutableSemanticScopes, } from "./javascriptSemanticProjection.js";
+import { semanticObjectPatternKeys, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
+import { currentSemanticScope, resolveSemanticBindingState, semanticResolutionBlocked, resolveSemanticBindingFromScope, semanticBindingId, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
+import { completeSemanticSteps, traverseJavaScriptAstSteps, } from "./javascriptSemanticTraversal.js";
+import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
+import { collectSemanticMemberMutationsSteps } from "./javascriptSemanticMemberMutations.js";
 import { collectSemanticReturns, resolveSemanticModuleCallables, } from "./javascriptSemanticReturns.js";
-import { collectJavaScriptDerivedSemantics } from "./javascriptSemanticDerivedAnalysis.js";
+import { collectJavaScriptDerivedSemanticsSteps } from "./javascriptSemanticDerivedAnalysis.js";
+import { evaluateSemanticProvenance } from "./javascriptSemanticValues.js";
+import { collectElectronMemberWritesSteps, electronExportPath, electronMemberPath, ELECTRON_MODULE, } from "./javascriptElectronMemberWrites.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { propertyName } from "./javascriptAstValues.js";
 import { semanticCoverage } from "./javascriptSemanticCoverage.js";
 import { semanticResourceLimitsIn } from "./javascriptSemanticResourceLimits.js";
 import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
+import { isJavaScriptRpcClientFactory } from "./javascriptRpcEndpoints.js";
 /** Recover lexical bindings, aliases, constants, and module links. */
 export const analyzeJavaScriptSemantics = (source) => {
     const file = parseJavaScriptSource(source);
@@ -22,23 +26,33 @@ export const analyzeJavaScriptSemantics = (source) => {
 /** Recover lexical references, optionally for one name, without evaluating values or provenance. */
 export const analyzeParsedJavaScriptReferences = (file, name) => {
     const state = createState(file.program);
-    collectDefinitions(file.program, state);
+    completeSemanticSteps(collectDefinitionsSteps(file.program, state));
     return collectSemanticReferences(file.program, state, name);
 };
 /** Recover semantics from an already parsed JavaScript artifact. */
-export const analyzeParsedJavaScriptSemantics = (file) => {
+export const analyzeParsedJavaScriptSemantics = (file) => completeSemanticSteps(analyzeParsedJavaScriptSemanticsSteps(file));
+/**
+ * Recover semantics from a parsed artifact with a yield between analysis
+ * phases, so a caller can serve control messages within one large file.
+ * Each phase completes before the next starts; results equal the synchronous
+ * form.
+ */
+export function* analyzeParsedJavaScriptSemanticsSteps(file) {
     const state = createState(file.program);
-    collectDefinitions(file.program, state);
-    collectSemanticMemberMutations(file.program, state);
-    traverseJavaScriptAst(file.program, {
+    yield* collectDefinitionsSteps(file.program, state);
+    yield* collectSemanticMemberMutationsSteps(file.program, state);
+    yield* traverseJavaScriptAstSteps(file.program, {
         enter: (node) => collectSemanticModuleLink(node, state),
     });
-    const references = collectSemanticReferences(file.program, state);
+    yield;
+    const references = yield* collectSemanticReferencesSteps(file.program, state);
     const parserPartial = file.errors.length > 0;
     const bindings = immutableSemanticBindings(state);
+    yield;
     const callables = collectSemanticReturns(file.program, state, parserPartial);
+    yield;
     const moduleLinks = resolveSemanticModuleCallables(state, callables);
-    const derived = collectJavaScriptDerivedSemantics(file.program, state, callables, parserPartial);
+    const derived = yield* collectJavaScriptDerivedSemanticsSteps(file.program, state, callables, parserPartial);
     return {
         schema: "JavaScriptSemanticIR",
         scopes: immutableSemanticScopes(state),
@@ -64,17 +78,53 @@ export const analyzeParsedJavaScriptSemantics = (file) => {
             "Cross-function mutation and dynamic property resolution remain unknown.",
         ],
     };
-};
+}
+/** Resolve tRPC client roots by lexical identity, excluding overwritten bindings. */
+export function* classifyParsedJavaScriptRpcClientRootsSteps(file) {
+    const state = createState(file.program);
+    yield* collectDefinitionsSteps(file.program, state);
+    const roots = new Set();
+    const clients = new Map();
+    yield* traverseJavaScriptAstSteps(file.program, {
+        enter: (node) => {
+            if (!t.isMemberExpression(node) && !t.isOptionalMemberExpression(node))
+                return;
+            const root = node.object;
+            if (!t.isIdentifier(root))
+                return;
+            const binding = resolveSemanticBindingState(state, root, root.name);
+            if (binding === undefined)
+                return;
+            let client = clients.get(binding.bindingId);
+            if (client === undefined) {
+                const [initializer] = binding.initializers;
+                client =
+                    initializer !== undefined &&
+                        initializer.projection.length === 0 &&
+                        binding.initializers.length === 1 &&
+                        !binding.definitions.some(({ kind }) => kind === "assignment") &&
+                        !state.conditionalInitializers.has(initializer.node) &&
+                        isJavaScriptRpcClientFactory(initializer.node);
+                clients.set(binding.bindingId, client);
+            }
+            if (client)
+                roots.add(root);
+        },
+    });
+    return roots;
+}
 /**
  * Resolve only the lexical receiver identity needed to distinguish browser
  * `window.open` from XHR and global storage `.open` calls. This deliberately
  * builds definitions without running semantic value or provenance analysis.
  */
-export const classifyParsedJavaScriptOpenReceivers = (file) => {
+export const classifyParsedJavaScriptOpenReceivers = (file) => completeSemanticSteps(classifyParsedJavaScriptOpenReceiversSteps(file));
+/** Classify `.open` receivers while yielding during lexical and AST scans. */
+export function* classifyParsedJavaScriptOpenReceiversSteps(file) {
     const state = createState(file.program);
-    collectDefinitions(file.program, state);
+    yield* collectDefinitionsSteps(file.program, state);
     const facts = new Map();
-    traverseJavaScriptAst(file.program, {
+    yield* traverseJavaScriptAstSteps(file.program, {
         enter: (node) => {
             if ((!t.isCallExpression(node) && !t.isOptionalCallExpression(node)) ||
                 (!t.isMemberExpression(node.callee) &&
@@ -133,7 +183,7 @@ export const classifyParsedJavaScriptOpenReceivers = (file) => {
         },
     });
     return facts;
-};
+}
 const openGlobalFact = (name) => {
     if (name === "window" ||
         name === "self" ||
@@ -156,6 +206,95 @@ const resolveGlobalAliasFact = (state, node, name) => {
         return undefined;
     return openGlobalFact(name);
 };
+/**
+ * Proven Electron export path segments for call and construction roots, keyed by
+ * root offset. Only proven Electron origins are present; callers must not
+ * infer an Electron export from an absent entry or familiar local name.
+ */
+export const classifyParsedJavaScriptElectronBindings = (file) => completeSemanticSteps(classifyParsedJavaScriptElectronBindingsSteps(file));
+/** Resolve Electron aliases while yielding during lexical and AST scans. */
+export function* classifyParsedJavaScriptElectronBindingsSteps(file) {
+    const facts = new Map();
+    const state = createState(file.program);
+    yield* collectDefinitionsSteps(file.program, state);
+    const exportsByBinding = new Map();
+    const rootExport = (root) => {
+        if (t.isIdentifier(root)) {
+            if (semanticResolutionBlocked(state, root, root.name))
+                return undefined;
+            const binding = resolveSemanticBindingState(state, root, root.name);
+            if (binding === undefined)
+                return undefined;
+            let exported = exportsByBinding.get(binding.bindingId);
+            if (exported === undefined) {
+                exported = electronExport(binding, state);
+                exportsByBinding.set(binding.bindingId, exported);
+            }
+            return exported ?? undefined;
+        }
+        const origin = semanticRequireOrigin(root, state);
+        return origin !== undefined && ELECTRON_MODULE.test(origin.specifier)
+            ? electronExportPath(origin.importedPath)
+            : undefined;
+    };
+    const writes = yield* collectElectronMemberWritesSteps(file.program, rootExport);
+    yield* traverseJavaScriptAstSteps(file.program, {
+        enter: (node) => {
+            if (!t.isCallExpression(node) &&
+                !t.isOptionalCallExpression(node) &&
+                !t.isNewExpression(node))
+                return;
+            const { root, members } = electronMemberPath(node.callee);
+            const exported = rootExport(root);
+            if (exported !== undefined && !writes.covers([...exported, ...members]))
+                facts.set(root.start ?? -1, exported);
+        },
+    });
+    return facts;
+}
+// Read import and require origins directly; general value evaluation is
+// unnecessary here and costly across large vendor bundles.
+const electronExport = (binding, state) => {
+    if (binding.definitions.some(({ kind }) => kind === "assignment"))
+        return null;
+    const directOrigin = bindingOrigin(binding, state);
+    const [initializer] = binding.initializers;
+    if (directOrigin === undefined &&
+        (initializer === undefined ||
+            binding.initializers.length !== 1 ||
+            state.conditionalInitializers.has(initializer.node)))
+        return null;
+    const provenance = directOrigin === undefined
+        ? evaluateSemanticProvenance(binding, state)
+        : undefined;
+    const origin = directOrigin ??
+        (provenance?.status === "module" && provenance.origins.length === 1
+            ? provenance.origins[0]
+            : undefined);
+    return origin !== undefined && ELECTRON_MODULE.test(origin.specifier)
+        ? electronExportPath(origin.importedPath)
+        : null;
+};
+const bindingOrigin = (binding, state) => {
+    if (binding.directOrigins.length > 0)
+        return binding.directOrigins.length === 1
+            ? binding.directOrigins[0]
+            : undefined;
+    const [initializer] = binding.initializers;
+    // A var/let declaration permits writes without proving one occurred.
+    // Require one unconditional initializer and no actual binding writes.
+    if (initializer === undefined ||
+        binding.initializers.length !== 1 ||
+        binding.definitions.some(({ kind }) => kind === "assignment") ||
+        state.conditionalInitializers.has(initializer.node))
+        return undefined;
+    const origin = semanticRequireOrigin(initializer.node, state);
+    const projection = initializer.projection;
+    return origin === undefined ||
+        !projection.every((key) => typeof key === "string")
+        ? undefined
+        : { ...origin, importedPath: [...origin.importedPath, ...projection] };
+};
 const createState = (program) => {
     const root = {
         scopeId: semanticScopeId("program", program),
@@ -178,15 +317,17 @@ const createState = (program) => {
         conditionalInitializers: new WeakSet(),
     };
 };
-const collectDefinitions = (program, state) => {
+function* collectDefinitionsSteps(program, state) {
     const stack = [
         currentSemanticScope(state.scopes),
     ];
     const openedScopes = new WeakMap();
     const assignments = [];
     const functionBodies = [];
-    traverseJavaScriptAst(program, {
+    yield* traverseJavaScriptAstSteps(program, {
         enter: (node, parent, readAncestors) => {
+            if (parent !== null)
+                state.parentsByNode.set(node, parent);
             let parentScope = currentSemanticScope(stack);
             if (parent !== null &&
                 (t.isObjectMethod(parent) || t.isClassMethod(parent)) &&
@@ -232,7 +373,10 @@ const collectDefinitions = (program, state) => {
                     });
             }
             const scope = currentSemanticScope(stack);
-            state.scopeByNode.set(node, scope);
+            // Other nodes inherit the nearest boundary through their AST parents.
+            // Avoid a second full-tree index for the same lexical relationship.
+            if (parent === null || openedScopes.has(node))
+                state.scopeByNode.set(node, scope);
             collectSemanticCallable({
                 node,
                 parent,
@@ -260,13 +404,19 @@ const collectDefinitions = (program, state) => {
     });
     // All declarations must exist before resolving writes, including hoisted
     // functions and local declarations that shadow an outer binding.
-    for (const { node, scope } of assignments)
+    for (const [index, { node, scope }] of assignments.entries()) {
+        if (index % 64 === 0)
+            yield;
         bindAssignment(node, scope, state);
-    for (const { body, scope, parameters } of functionBodies)
+    }
+    for (const [index, { body, scope, parameters }] of functionBodies.entries()) {
+        if (index % 64 === 0)
+            yield;
         for (const parameter of parameters)
             for (const identifier of assignedPatternIdentifiers(t.isTSParameterProperty(parameter) ? parameter.parameter : parameter))
                 copyParameterToBody({ identifier, body, scope, state });
-};
+    }
+}
 const copyParameterToBody = (input) => {
     const { identifier, body, scope, state } = input;
     const binding = scope.bindings.get(identifier.name);
@@ -383,9 +533,21 @@ const bindAssignment = (node, scope, state) => {
     else if (t.isForOfStatement(node) || t.isForInStatement(node))
         for (const pattern of t.isVariableDeclaration(node.left)
             ? node.left.declarations.map(({ id }) => id)
-            : [node.left])
+            : [node.left]) {
             for (const identifier of assignedPatternIdentifiers(pattern))
                 addAssignment(identifier, node, scope, state);
+            if (t.isForOfStatement(node))
+                // Keep the loop value unknown, but preserve references yielded into
+                // each bound slot so writes/escapes can reach their iterable origins.
+                bindPattern({
+                    pattern,
+                    initializer: node,
+                    scope,
+                    state,
+                    mutable: true,
+                    referenceOnly: true,
+                });
+        }
 };
 const assignedPatternIdentifiers = (pattern) => {
     const identifiers = [];
@@ -564,7 +726,7 @@ const bindPattern = (input) => {
     }
     if (t.isIdentifier(pattern)) {
         if (referenceOnly) {
-            const binding = scope.bindings.get(pattern.name);
+            const binding = resolveSemanticBindingFromScope(scope, pattern.name, state);
             if (binding !== undefined && initializer !== null)
                 binding.referenceInitializers.push({
                     node: initializer,
@@ -647,12 +809,7 @@ const bindPattern = (input) => {
                     referenceOnly: true,
                     copyKind: "object-rest",
                     copyProjectionOffset: projection.length,
-                    copyExcludedKeys: pattern.properties.flatMap((property) => {
-                        if (t.isRestElement(property))
-                            return [];
-                        const key = semanticStaticPropertyKey(property.key, property.computed);
-                        return key === null ? [] : [key];
-                    }),
+                    copyExcludedKeys: semanticObjectPatternKeys(pattern),
                 });
             }
             else {
@@ -703,7 +860,7 @@ const addBinding = (input) => {
         binding.directOrigins.push(directOrigin);
 };
 const createBinding = (scope, name, kind, mutable) => ({
-    bindingId: `${scope.scopeId}:binding:${encodeURIComponent(name)}`,
+    bindingId: semanticBindingId(scope.scopeId, name),
     scopeId: scope.scopeId,
     name,
     kind,

package/dist/domain/javascript/javascriptSemanticCallableResults.js

@@ -0,0 +1,42 @@
+import * as t from "@babel/types";
+import { childNodes } from "./javascriptSemanticTraversal.js";
+/** Collect direct result syntax without executing or evaluating a callable. */
+export const semanticCallableResultExpressions = (callable) => {
+    if (t.isArrowFunctionExpression(callable) &&
+        !t.isBlockStatement(callable.body))
+        return [
+            {
+                node: callable.body,
+                site: callable.body,
+                kind: "return",
+                delegated: false,
+            },
+        ];
+    if (!t.isFunction(callable))
+        return [];
+    const output = [];
+    const pending = childNodes(callable.body).reverse();
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (node === undefined || t.isFunction(node) || t.isClass(node))
+            continue;
+        if (t.isReturnStatement(node)) {
+            output.push({
+                node: node.argument ?? null,
+                site: node,
+                kind: "return",
+                delegated: false,
+            });
+        }
+        if (t.isYieldExpression(node))
+            output.push({
+                node: node.argument ?? null,
+                site: node,
+                kind: "yield",
+                delegated: node.delegate,
+            });
+        for (const child of childNodes(node).reverse())
+            pending.push(child);
+    }
+    return output;
+};

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/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

@@ -2,9 +2,9 @@ import { createHash } from "node:crypto";
 import * as t from "@babel/types";
 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(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."]
+        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)