rea-agents 2.4.0 → 2.5.0

package/dist/domain/javascriptSemanticDataEffectHelpers.js

@@ -0,0 +1,125 @@
+import * as t from "@babel/types";
+import { reachSemanticLimit, semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+/** Resolve a direct or namespace-imported built-in method. */
+export const builtinDataEffectMethod = (callee, state, specifiers) => {
+    if (t.isIdentifier(callee)) {
+        const binding = resolveSemanticBindingState(state, callee, callee.name);
+        return moduleMethod(binding, specifiers);
+    }
+    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee))
+        return null;
+    if (!t.isIdentifier(callee.object))
+        return null;
+    const binding = resolveSemanticBindingState(state, callee.object, callee.object.name);
+    const namespace = binding?.directOrigins.some(({ specifier, importedPath }) => specifiers.includes(specifier) && importedPath.length === 0);
+    return namespace
+        ? semanticStaticPropertyName(callee.property, callee.computed)
+        : null;
+};
+const moduleMethod = (binding, specifiers) => {
+    for (const { specifier, importedPath } of binding?.directOrigins ?? []) {
+        if (!specifiers.includes(specifier))
+            continue;
+        return importedPath.at(-1) ?? null;
+    }
+    return null;
+};
+/** Recognize global or node:process aliases without accepting shadowing. */
+export const isSemanticProcessObject = (node, state) => {
+    if (!t.isIdentifier(node))
+        return false;
+    const binding = resolveSemanticBindingState(state, node, node.name);
+    if (binding === undefined)
+        return (node.name === "process" &&
+            !semanticResolutionBlocked(state, node, node.name));
+    return binding.directOrigins.some(({ specifier }) => specifier === "process" || specifier === "node:process");
+};
+/** Resolve the nearest direct variable/assignment owner before a callable. */
+export const outerDataEffectBinding = (node, context) => {
+    for (let index = context.ancestors.length - 1; index >= 0; index -= 1) {
+        const ancestor = context.ancestors[index];
+        if (ancestor === undefined)
+            continue;
+        if (t.isVariableDeclarator(ancestor) &&
+            t.isNode(ancestor.init) &&
+            containsSemanticNode(ancestor.init, node) &&
+            t.isIdentifier(ancestor.id))
+            return (resolveSemanticBindingState(context.state, ancestor.id, ancestor.id.name)?.bindingId ?? null);
+        if (t.isAssignmentExpression(ancestor) &&
+            containsSemanticNode(ancestor.right, node) &&
+            t.isIdentifier(ancestor.left))
+            return (resolveSemanticBindingState(context.state, ancestor.left, ancestor.left.name)?.bindingId ?? null);
+        if (semanticCallableIdForNode(ancestor) !== null)
+            return null;
+    }
+    return null;
+};
+/** Traverse with exact callable and ancestor stacks. */
+export const traverseDataEffects = (program, context, visit) => {
+    context.callableStack.length = 0;
+    context.ancestors.length = 0;
+    traverseJavaScriptAst(program, {
+        enter: (node, parent) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && context.callableIds.has(callableId))
+                context.callableStack.push(callableId);
+            visit(node, parent);
+            context.ancestors.push(node);
+        },
+        exit: (node) => {
+            context.ancestors.pop();
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && context.callableStack.at(-1) === callableId)
+                context.callableStack.pop();
+        },
+    });
+};
+/** Resolve one direct identifier argument to a lexical binding. */
+export const dataEffectArgumentBindingId = (node, state) => t.isIdentifier(node)
+    ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)
+    : null;
+/** Read one JSON primitive default without evaluating code. */
+export const dataEffectPrimitive = (node) => {
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
+        return node.value;
+    if (t.isBooleanLiteral(node))
+        return node.value;
+    return null;
+};
+/** Read one static string or expression-free template. */
+export const dataEffectLiteralString = (node) => {
+    if (t.isStringLiteral(node))
+        return node.value;
+    if (t.isTemplateLiteral(node) && node.expressions.length === 0)
+        return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
+    return null;
+};
+/** Read a member callee from call or construction syntax. */
+export const dataEffectMemberCallee = (node) => t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)
+    ? node.callee
+    : null;
+/** Read a parent member's object when present. */
+export const dataEffectMemberObject = (node) => node !== null &&
+    (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
+    ? node.object
+    : null;
+/** Compare Babel source offsets for exact containment. */
+export const containsSemanticNode = (outer, inner) => outer.start !== null &&
+    outer.start !== undefined &&
+    outer.end !== null &&
+    outer.end !== undefined &&
+    inner.start !== null &&
+    inner.start !== undefined &&
+    inner.end !== null &&
+    inner.end !== undefined &&
+    outer.start <= inner.start &&
+    outer.end >= inner.end;
+/** Record one bounded data-effect frontier. */
+export const dataEffectLimitReached = (retained, limit, name, state) => {
+    if (retained < limit)
+        return false;
+    reachSemanticLimit(state, name);
+    return true;
+};

package/dist/domain/javascriptSemanticDataEffects.js

@@ -0,0 +1,284 @@
+import * as t from "@babel/types";
+import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
+import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { builtinDataEffectMethod as builtinMethod, containsSemanticNode as containsNode, dataEffectArgumentBindingId as argumentBindingId, dataEffectLimitReached as limitReached, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
+import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
+/** Recover configuration, request, and boundary candidates from inert syntax. */
+export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
+    const context = {
+        state,
+        callableIds: new Set(callables.map(({ callableId }) => callableId)),
+        callableStack: [],
+        ancestors: [],
+    };
+    const configuration = collectConfigurations(program, context);
+    const requests = collectRequests(program, context);
+    return {
+        configurationOperations: [
+            ...configuration.map(({ operation }) => operation),
+            ...collectDefaults(program, context, configuration),
+        ],
+        requestOperations: [
+            ...requests.map(({ operation }) => operation),
+            ...collectResponseConsumers(program, context, requests),
+        ],
+        boundaryOperations: collectBoundaries(program, context),
+    };
+};
+const collectConfigurations = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node, parent) => {
+        const details = configurationDetails(node, parent, context);
+        if (details === null)
+            return;
+        if (limitReached(output.length, context.state.limits.maxConfigurationOperations, "maxConfigurationOperations", context.state))
+            return;
+        const operation = {
+            configId: `config:${details.kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: details.kind,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            key: details.key,
+            sourceConfigId: null,
+            value: null,
+            resolution: details.resolution,
+        };
+        output.push({ node, operation });
+    });
+    return output;
+};
+const configurationDetails = (node, parent, context) => {
+    if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
+        !(memberObject(parent) === node)) {
+        const processMember = processConfigurationMember(node, context.state);
+        if (processMember !== null)
+            return processMember;
+    }
+    if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+        return null;
+    const fileMethod = builtinMethod(node.callee, context.state, [
+        "fs",
+        "node:fs",
+    ]);
+    return fileMethod === "readFile" || fileMethod === "readFileSync"
+        ? {
+            kind: "file",
+            key: literalString(node.arguments[0]),
+            resolution: literalString(node.arguments[0]) === null ? "partial" : "complete",
+        }
+        : null;
+};
+const processConfigurationMember = (node, state) => {
+    const object = node.object;
+    if (!t.isMemberExpression(object) && !t.isOptionalMemberExpression(object))
+        return null;
+    if (!isProcessObject(object.object, state))
+        return null;
+    const family = semanticStaticPropertyName(object.property, object.computed);
+    if (family !== "env" && family !== "argv")
+        return null;
+    const key = semanticStaticPropertyName(node.property, node.computed) || null;
+    return {
+        kind: family === "env" ? "environment" : "argv",
+        key,
+        resolution: key === null ? "partial" : "complete",
+    };
+};
+const collectDefaults = (program, context, configurations) => {
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isLogicalExpression(node) ||
+            (node.operator !== "??" && node.operator !== "||"))
+            return;
+        const sources = configurations.filter(({ node: source }) => containsNode(node.left, source));
+        if (sources.length !== 1 || sources[0] === undefined)
+            return;
+        if (limitReached(configurations.length + output.length, context.state.limits.maxConfigurationOperations, "maxConfigurationOperations", context.state))
+            return;
+        output.push({
+            configId: `config:default:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: "default",
+            location: range(node.right),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            key: sources[0].operation.key,
+            sourceConfigId: sources[0].operation.configId,
+            value: primitiveValue(node.right),
+            resolution: primitiveValue(node.right) === null ? "partial" : "complete",
+        });
+    });
+    return output;
+};
+const collectRequests = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) &&
+            !t.isOptionalCallExpression(node) &&
+            !t.isNewExpression(node))
+            return;
+        const method = requestMethod(node, context.state);
+        if (method === null)
+            return;
+        if (limitReached(output.length, context.state.limits.maxRequestOperations, "maxRequestOperations", context.state))
+            return;
+        const endpoint = requestEndpoint(node);
+        output.push({
+            node,
+            operation: {
+                requestId: `request:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+                kind: "request",
+                method,
+                location: range(node),
+                ownerCallableId: context.callableStack.at(-1) ?? null,
+                resultBindingId: outerAssignedBinding(node, context),
+                linkedRequestIds: [],
+                endpoint,
+                fields: requestFields(node, method, context.state),
+                resolution: endpoint === null ? "partial" : "complete",
+            },
+        });
+    });
+    return output;
+};
+const collectResponseConsumers = (program, context, requests) => {
+    const requestsByBinding = new Map();
+    for (const request of requests) {
+        const bindingId = request.operation.resultBindingId;
+        if (bindingId === null)
+            continue;
+        const existing = requestsByBinding.get(bindingId) ?? [];
+        existing.push(request);
+        requestsByBinding.set(bindingId, existing);
+    }
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+            return;
+        const member = memberCallee(node);
+        if (member === null || !t.isIdentifier(member.object))
+            return;
+        const method = semanticStaticPropertyName(member.property, member.computed);
+        if (method !== "json" && method !== "text" && method !== "arrayBuffer")
+            return;
+        const binding = resolveSemanticBindingState(context.state, member.object, member.object.name);
+        const linked = binding === undefined
+            ? []
+            : (requestsByBinding.get(binding.bindingId) ?? []);
+        if (linked.length === 0)
+            return;
+        if (limitReached(requests.length + output.length, context.state.limits.maxRequestOperations, "maxRequestOperations", context.state))
+            return;
+        output.push({
+            requestId: `response:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: "response-consumer",
+            method,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            resultBindingId: outerAssignedBinding(node, context),
+            linkedRequestIds: linked
+                .map(({ operation }) => operation.requestId)
+                .sort(compareCodePoints),
+            endpoint: null,
+            fields: [],
+            resolution: linked.length === 1 ? "complete" : "partial",
+        });
+    });
+    return output;
+};
+const collectBoundaries = (program, context) => {
+    const output = [];
+    traverseWithContext(program, context, (node) => {
+        if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+            return;
+        const details = boundaryDetails(node, context.state);
+        if (details === null)
+            return;
+        if (limitReached(output.length, context.state.limits.maxBoundaryOperations, "maxBoundaryOperations", context.state))
+            return;
+        output.push({
+            boundaryId: `boundary:${details.kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
+            kind: details.kind,
+            method: details.method,
+            location: range(node),
+            ownerCallableId: context.callableStack.at(-1) ?? null,
+            sourceBindingId: argumentBindingId(node.arguments[0], context.state),
+            resultBindingId: outerAssignedBinding(node, context),
+            resolution: details.resolution,
+        });
+    });
+    return output;
+};
+const boundaryDetails = (node, state) => {
+    if (t.isIdentifier(node.callee)) {
+        const name = node.callee.name;
+        const unbound = resolveSemanticBindingState(state, node.callee, name) === undefined &&
+            !semanticResolutionBlocked(state, node.callee, name);
+        if (unbound &&
+            ["String", "Number", "Boolean", "parseInt", "parseFloat"].includes(name))
+            return { kind: "coerce", method: name, resolution: "complete" };
+    }
+    const member = memberCallee(node);
+    if (member === null)
+        return null;
+    const method = semanticStaticPropertyName(member.property, member.computed);
+    if (method === "parse" &&
+        t.isIdentifier(member.object, { name: "JSON" }) &&
+        resolveSemanticBindingState(state, member.object, "JSON") === undefined &&
+        !semanticResolutionBlocked(state, member.object, "JSON"))
+        return { kind: "parse", method: "JSON.parse", resolution: "complete" };
+    if (method === "parse" || method === "safeParse")
+        return { kind: "parse", method, resolution: "partial" };
+    if (method === "validate" || method === "assert" || method === "is")
+        return { kind: "validate", method, resolution: "partial" };
+    return null;
+};
+const requestMethod = (node, state) => {
+    if (t.isIdentifier(node.callee)) {
+        const name = node.callee.name;
+        const unbound = resolveSemanticBindingState(state, node.callee, name) === undefined &&
+            !semanticResolutionBlocked(state, node.callee, name);
+        if (!t.isNewExpression(node) && unbound && name === "fetch")
+            return "fetch";
+        if (t.isNewExpression(node) && unbound && name === "WebSocket")
+            return "WebSocket";
+    }
+    const member = memberCallee(node);
+    if (member === null || !t.isIdentifier(member.object))
+        return null;
+    const method = semanticStaticPropertyName(member.property, member.computed);
+    if (method !== "request" && method !== "get")
+        return null;
+    const binding = resolveSemanticBindingState(state, member.object, member.object.name);
+    return binding?.directOrigins.some(({ specifier, importedPath }) => ["http", "https", "node:http", "node:https"].includes(specifier) &&
+        importedPath.length === 0)
+        ? method
+        : null;
+};
+const requestFields = (node, method, state) => {
+    const candidate = method === "fetch" || method === "WebSocket"
+        ? node.arguments[1]
+        : t.isObjectExpression(node.arguments[0])
+            ? node.arguments[0]
+            : node.arguments[1];
+    if (!t.isObjectExpression(candidate))
+        return [];
+    return candidate.properties.flatMap((property) => {
+        if (!t.isObjectProperty(property))
+            return [];
+        const name = propertyName(property.key);
+        if (name.length === 0)
+            return [];
+        return [
+            {
+                name,
+                sourceBindingId: t.isIdentifier(property.value)
+                    ? (resolveSemanticBindingState(state, property.value, property.value.name)?.bindingId ?? null)
+                    : null,
+            },
+        ];
+    });
+};
+const requestEndpoint = (node) => t.isObjectExpression(node.arguments[0])
+    ? null
+    : literalString(node.arguments[0]);

package/dist/domain/javascriptSemanticDerivedAnalysis.js

@@ -0,0 +1,41 @@
+import { collectJavaScriptSemanticAsyncEffects } from "./javascriptSemanticAsyncEffects.js";
+import { collectJavaScriptSemanticCalls } from "./javascriptSemanticCalls.js";
+import { collectJavaScriptSemanticChildProcesses } from "./javascriptSemanticChildProcesses.js";
+import { collectJavaScriptSemanticFingerprints } 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) => {
+    const calls = collectJavaScriptSemanticCalls(program, state, callables);
+    const promiseOperations = collectJavaScriptSemanticPromises(program, state, callables);
+    const asyncEffects = collectJavaScriptSemanticAsyncEffects(program, state, callables);
+    const childProcesses = collectJavaScriptSemanticChildProcesses(program, state, callables);
+    const dataEffects = collectJavaScriptSemanticDataEffects(program, state, callables);
+    const resourceOperations = collectJavaScriptSemanticResources(program, state, callables);
+    const objectOperations = collectJavaScriptSemanticObjects(program, state, callables);
+    const functionFingerprints = collectJavaScriptSemanticFingerprints({
+        state,
+        callables,
+        calls,
+        promises: promiseOperations,
+        events: asyncEffects.eventOperations,
+        timers: asyncEffects.timerOperations,
+        childProcessSpawns: childProcesses.childProcessSpawns,
+        childProcessInteractions: childProcesses.childProcessInteractions,
+        requestOperations: dataEffects.requestOperations,
+        resourceOperations,
+        parserPartial,
+    });
+    return {
+        ...calls,
+        promiseOperations,
+        ...asyncEffects,
+        ...childProcesses,
+        ...dataEffects,
+        resourceOperations,
+        objectOperations,
+        functionFingerprints,
+    };
+};

package/dist/domain/javascriptSemanticFingerprints.js

@@ -0,0 +1,174 @@
+import { createHash } from "node:crypto";
+import * as t from "@babel/types";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { compareCodePoints } from "./javascriptStaticAnalysisHelpers.js";
+/** Build bounded rename- and formatting-resistant components per callable. */
+export const collectJavaScriptSemanticFingerprints = (input) => {
+    const { state, callables, calls, promises, events, timers, childProcessSpawns, childProcessInteractions, requestOperations, resourceOperations, parserPartial, } = input;
+    return callables.flatMap((callable) => {
+        if (callable.kind === "class")
+            return [];
+        const node = state.callableNodesById.get(callable.callableId);
+        if (node === undefined)
+            return [];
+        const syntax = fingerprintSyntax(node, callable.callableId);
+        const promiseEffects = promises.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const eventEffects = events.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const timerEffects = timers.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const childProcessEffects = [
+            ...childProcessSpawns,
+            ...childProcessInteractions,
+        ].filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const networkEffects = requestOperations.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        const resourceEffects = resourceOperations.filter(({ ownerCallableId }) => ownerCallableId === callable.callableId);
+        return [
+            {
+                callableId: callable.callableId,
+                status: parserPartial ||
+                    state.limitsReached.size > 0 ||
+                    callable.returnCoverage.status !== "complete"
+                    ? "partial"
+                    : "complete",
+                components: {
+                    parameterArity: callableParameterArity(node),
+                    normalizedAstSha256: digest(syntax.normalizedTokens),
+                    controlFlowSha256: digest(syntax.controlFlowTokens),
+                    relationShapeSha256: digest(relationShape(callable, calls, 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 bounded static candidate and does not prove behavioral equivalence.",
+                    ...(parserPartial || state.limitsReached.size > 0
+                        ? ["Incomplete semantic recovery makes this fingerprint partial."]
+                        : []),
+                ],
+            },
+        ];
+    });
+};
+const fingerprintSyntax = (root, targetCallableId) => {
+    const normalizedTokens = [];
+    const controlFlowTokens = [];
+    const literals = [];
+    const callableStack = [];
+    traverseJavaScriptAst(root, {
+        enter: (node, parent) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null)
+                callableStack.push(callableId);
+            if (callableStack.at(-1) !== targetCallableId)
+                return;
+            normalizedTokens.push(normalizedNodeToken(node, parent));
+            const control = controlFlowToken(node);
+            if (control !== null)
+                controlFlowTokens.push(control);
+            const literal = semanticLiteral(node);
+            if (literal !== null)
+                literals.push(literal);
+        },
+        exit: (node) => {
+            const callableId = semanticCallableIdForNode(node);
+            if (callableId !== null && callableStack.at(-1) === callableId)
+                callableStack.pop();
+        },
+    });
+    return { normalizedTokens, controlFlowTokens, literals };
+};
+const normalizedNodeToken = (node, parent) => {
+    if (t.isIdentifier(node))
+        return propertyIdentity(node, parent)
+            ? `property:${node.name}`
+            : "identifier";
+    if (t.isStringLiteral(node))
+        return propertyIdentity(node, parent)
+            ? `property:${node.value}`
+            : "string-literal";
+    const attributes = [
+        primitiveAttribute(node, "operator"),
+        primitiveAttribute(node, "kind"),
+        primitiveAttribute(node, "computed"),
+        primitiveAttribute(node, "optional"),
+        primitiveAttribute(node, "async"),
+        primitiveAttribute(node, "generator"),
+    ].filter((value) => value !== null);
+    return [node.type, ...attributes].join(":");
+};
+const primitiveAttribute = (node, key) => {
+    const value = Reflect.get(node, key);
+    return typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean"
+        ? `${key}=${String(value)}`
+        : null;
+};
+const propertyIdentity = (node, parent) => {
+    if (parent === null)
+        return false;
+    if ((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&
+        parent.property === node)
+        return !parent.computed || t.isStringLiteral(node);
+    if ((t.isObjectProperty(parent) ||
+        t.isObjectMethod(parent) ||
+        t.isClassMethod(parent) ||
+        t.isClassProperty(parent)) &&
+        parent.key === node)
+        return !parent.computed || t.isStringLiteral(node);
+    return false;
+};
+const controlFlowToken = (node) => {
+    if (!t.isIfStatement(node) &&
+        !t.isConditionalExpression(node) &&
+        !t.isSwitchStatement(node) &&
+        !t.isSwitchCase(node) &&
+        !t.isLoop(node) &&
+        !t.isTryStatement(node) &&
+        !t.isCatchClause(node) &&
+        !t.isReturnStatement(node) &&
+        !t.isThrowStatement(node) &&
+        !t.isAwaitExpression(node) &&
+        !t.isYieldExpression(node) &&
+        !t.isLogicalExpression(node))
+        return null;
+    const operator = primitiveAttribute(node, "operator");
+    return operator === null ? node.type : `${node.type}:${operator}`;
+};
+const semanticLiteral = (node) => {
+    if (t.isStringLiteral(node))
+        return `string:${node.value}`;
+    if (t.isNumericLiteral(node))
+        return `number:${String(node.value)}`;
+    if (t.isBooleanLiteral(node))
+        return `boolean:${String(node.value)}`;
+    if (t.isNullLiteral(node))
+        return "null";
+    if (t.isBigIntLiteral(node))
+        return `bigint:${node.value}`;
+    if (t.isRegExpLiteral(node))
+        return `regexp:${node.pattern}/${node.flags}`;
+    if (t.isTemplateElement(node))
+        return `template:${node.value.cooked ?? node.value.raw}`;
+    return null;
+};
+const relationShape = (callable, calls, promises) => [
+    `returns:${String(callable.returnSites.length)}:${callable.returnCoverage.status}`,
+    ...calls.callSites
+        .filter(({ callerCallableId }) => callerCallableId === callable.callableId)
+        .map(({ kind, resolution, arguments: args, calleeCallableIds }) => `call:${kind}:${resolution}:${String(args.length)}:${String(calleeCallableIds.length)}`),
+    `captures:${String(calls.closureCaptures.filter(({ callableId }) => callableId === callable.callableId).length)}`,
+    ...promises.map(({ kind, method, ownership, sourceResolution }) => `promise:${kind}:${method}:${ownership}:${sourceResolution}`),
+];
+const callableParameterArity = (node) => t.isFunction(node) ? node.params.length : 0;
+const isAsyncCallable = (node) => t.isFunction(node) && node.async;
+const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");

package/dist/domain/javascriptSemanticIr.js

@@ -11,6 +11,15 @@ export const DEFAULT_JAVASCRIPT_SEMANTIC_LIMITS = {
     maxArgumentFlows: 100_000,
     maxCallReturnFlows: 100_000,
     maxClosureCaptures: 100_000,
+    maxPromiseOperations: 100_000,
+    maxEventOperations: 100_000,
+    maxTimerOperations: 100_000,
+    maxChildProcessOperations: 100_000,
+    maxConfigurationOperations: 100_000,
+    maxRequestOperations: 100_000,
+    maxBoundaryOperations: 100_000,
+    maxResourceOperations: 100_000,
+    maxObjectOperations: 100_000,
     maxFrontiers: 20_000,
     maxValueDepth: 16,
     maxUnionValues: 32,
@@ -23,7 +32,7 @@ export const semanticBinding = (ir, bindingId) => ir.bindings.find(({ bindingId:
 /** Fail-closed result when Babel cannot produce an inert syntax tree. */
 export const failedJavaScriptSemanticIr = () => ({
     schema: "JavaScriptSemanticIR",
-    schemaVersion: 3,
+    schemaVersion: 4,
     scopes: [],
     bindings: [],
     callables: [],
@@ -34,6 +43,17 @@ export const failedJavaScriptSemanticIr = () => ({
     callReturnFlows: [],
     callResultFlows: [],
     closureCaptures: [],
+    promiseOperations: [],
+    eventOperations: [],
+    timerOperations: [],
+    childProcessSpawns: [],
+    childProcessInteractions: [],
+    configurationOperations: [],
+    requestOperations: [],
+    boundaryOperations: [],
+    resourceOperations: [],
+    objectOperations: [],
+    functionFingerprints: [],
     frontiers: [],
     coverage: { status: "failed", omittedCount: null, limitsReached: [] },
     limitations: [