rea-agents 6.4.0 → 6.7.0

package/dist/domain/javascript/javascriptSemanticDataEffects.js

@@ -1,10 +1,11 @@
 import * as t from "@babel/types";
-import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.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 { readExactJavaScriptLiteral, semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { recordSemanticValueLimit, resolveSemanticBindingState, semanticResolutionBlocked, semanticStableInitializer, } from "./javascriptSemanticState.js";
+import { semanticBindingAtRead } from "./javascriptSemanticMutationInitializers.js";
+import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticPrimitiveSet } from "./javascriptSemanticPrimitives.js";
 /** Recover configuration, request, and boundary candidates from inert syntax. */
 export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
     const context = {
@@ -29,8 +30,8 @@ export const collectJavaScriptSemanticDataEffects = (program, state, callables)
 };
 const collectConfigurations = (program, context) => {
     const output = [];
-    traverseWithContext(program, context, (node, parent) => {
-        const details = configurationDetails(node, parent, context);
+    traverseWithContext(program, context, (node) => {
+        const details = configurationDetails(node, context);
         if (details === null)
             return;
         const operation = {
@@ -48,9 +49,8 @@ const collectConfigurations = (program, context) => {
     });
     return output;
 };
-const configurationDetails = (node, parent, context) => {
-    if ((t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
-        !(memberObject(parent) === node)) {
+const configurationDetails = (node, context) => {
+    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
         const processMember = processConfigurationMember(node, context.state);
         if (processMember !== null)
             return processMember;
@@ -73,8 +73,6 @@ 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;
@@ -82,6 +80,8 @@ const processConfigurationMember = (node, state) => {
     const key = semanticStaticPropertyKey(node.property, node.computed);
     if (family === "argv" && key !== null && !isArrayIndexKey(key))
         return null;
+    if (!isProcessObject(object.object, state, family, key))
+        return null;
     return {
         kind: family === "env" ? "environment" : "argv",
         key,
@@ -105,6 +105,11 @@ const collectDefaults = (program, context, configurations) => {
         const candidate = configurationsByNode.get(source);
         if (candidate === undefined)
             return;
+        const literal = readExactJavaScriptLiteral(node.right);
+        const value = literal.found
+            ? semanticPrimitiveSet([literal.value])
+            : { status: "unknown", reason: "Default is not an exact primitive." };
+        recordSemanticValueLimit(context.state, value);
         output.push({
             configId: `config:default:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: "default",
@@ -113,8 +118,11 @@ const collectDefaults = (program, context, configurations) => {
             resultBindingId: outerAssignedBinding(node, context),
             key: candidate.operation.key,
             sourceConfigId: candidate.operation.configId,
-            value: primitiveValue(node.right),
-            resolution: primitiveValue(node.right) === null ? "partial" : "complete",
+            value: value.status === "literal" ? value.value : null,
+            ...(value.status === "unknown" && value.resourceLimit !== undefined
+                ? { valueResourceLimit: value.resourceLimit }
+                : {}),
+            resolution: value.status === "literal" ? "complete" : "partial",
         });
     });
     return output;
@@ -149,6 +157,15 @@ const collectRequests = (program, context) => {
     });
     return output;
 };
+/**
+ * Any other write (assignment, update, loop or destructuring target) can
+ * replace the response before this read. A sole write that can be skipped or
+ * runs after the read leaves an incoming value possible.
+ */
+const soleWriteReachesRead = (binding, read, context) => binding?.initializers.length === 1 &&
+    (semanticStableInitializer(binding, context.state) !== undefined ||
+        semanticBindingAtRead(binding, read, context.state.parentsByNode)
+            .hasDefiniteInitializer);
 const collectResponseConsumers = (program, context, requests) => {
     const requestsByBinding = new Map();
     for (const request of requests) {
@@ -180,6 +197,13 @@ const collectResponseConsumers = (program, context, requests) => {
             : (requestsByBinding.get(binding.bindingId) ?? []);
         if (linked.length === 0)
             return;
+        // A consumer of exactly one request through its own result binding
+        // reads that request's response, so it keeps the request's endpoint.
+        const uniqueRequest = linked.length === 1 &&
+            !linked[0]?.operation.projectedResultBindings.some(({ bindingId }) => bindingId === binding?.bindingId)
+            ? linked[0]
+            : undefined;
+        const soleWrite = soleWriteReachesRead(binding, member.object, context);
         output.push({
             requestId: `response:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: "response-consumer",
@@ -191,12 +215,9 @@ const collectResponseConsumers = (program, context, requests) => {
             linkedRequestIds: linked
                 .map(({ operation }) => operation.requestId)
                 .sort(compareUnicodeCodePoints),
-            endpoint: null,
+            endpoint: soleWrite ? (uniqueRequest?.operation.endpoint ?? null) : null,
             fields: [],
-            resolution: linked.length === 1 &&
-                !linked[0]?.operation.projectedResultBindings.some(({ bindingId }) => bindingId === binding?.bindingId)
-                ? "complete"
-                : "partial",
+            resolution: uniqueRequest === undefined ? "partial" : "complete",
         });
     });
     return output;
@@ -256,17 +277,13 @@ const requestMethod = (node, state) => {
         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) &&
-        semanticBuiltinNamespacePath(importedPath))
-        ? method
-        : null;
+    const method = builtinMethod(node.callee, state, [
+        "http",
+        "https",
+        "node:http",
+        "node:https",
+    ]);
+    return method === "request" || method === "get" ? method : null;
 };
 const requestFields = (node, method, state) => {
     const candidate = method === "fetch" || method === "WebSocket"

package/dist/domain/javascript/javascriptSemanticDependencies.js

@@ -0,0 +1,69 @@
+/**
+ * Identity layout belongs to the indexed state, not to a query or its effects.
+ * Every proof has the same height. Union shares unchanged branches, so aliases
+ * add a path rather than copying their dependency's transitive membership set.
+ */
+export class SemanticDependencyProofs {
+    indices = new Map();
+    singletons = new Map();
+    height;
+    constructor(bindings) {
+        for (const binding of bindings)
+            this.indices.set(binding, this.indices.size);
+        this.height = Math.ceil(Math.log2(Math.max(1, this.indices.size)));
+    }
+    binding(binding) {
+        const prior = this.singletons.get(binding);
+        if (prior !== undefined)
+            return prior;
+        const index = this.index(binding);
+        let proof = true;
+        for (let bit = 0; bit < this.height; bit++) {
+            const one = Math.floor(index / 2 ** bit) % 2 === 1;
+            proof = Object.freeze({
+                zero: one ? undefined : proof,
+                one: one ? proof : undefined,
+            });
+        }
+        this.singletons.set(binding, proof);
+        return proof;
+    }
+    union(first, second) {
+        if (first === second || second === undefined)
+            return first;
+        if (first === undefined)
+            return second;
+        if (first === true || second === true)
+            return true;
+        const zero = this.union(first.zero, second.zero);
+        const one = this.union(first.one, second.one);
+        if (zero === first.zero && one === first.one)
+            return first;
+        if (zero === second.zero && one === second.one)
+            return second;
+        return Object.freeze({ zero, one });
+    }
+    intersects(proof, active) {
+        for (const binding of active.keys())
+            if (this.has(proof, binding))
+                return true;
+        return false;
+    }
+    has(proof, binding) {
+        const index = this.index(binding);
+        for (let bit = this.height - 1; bit >= 0; bit--) {
+            if (proof === undefined)
+                return false;
+            if (proof === true)
+                return true;
+            proof = Math.floor(index / 2 ** bit) % 2 === 1 ? proof.one : proof.zero;
+        }
+        return proof === true;
+    }
+    index(binding) {
+        const index = this.indices.get(binding);
+        if (index === undefined)
+            throw new TypeError(`Unindexed semantic dependency: ${binding}`);
+        return index;
+    }
+}

package/dist/domain/javascript/javascriptSemanticDerivedAnalysis.js

@@ -11,7 +11,7 @@ import { collectJavaScriptSemanticResources } from "./javascriptSemanticResource
  * 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) {
+export function* collectJavaScriptDerivedSemanticsSteps(program, state, callables, references, parserPartial) {
     const calls = collectJavaScriptSemanticCalls(program, state, callables);
     yield;
     const promiseOperations = collectJavaScriptSemanticPromises(program, state, callables);

package/dist/domain/javascript/javascriptSemanticEvaluationOrder.js

@@ -0,0 +1,126 @@
+import * as t from "@babel/types";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+const preserveGrouping = { stopAtParentheses: true };
+/** Exact source-only cardinality for literal loop heads. */
+export const semanticIterationCardinality = (loop, prototypeMayAffectEnumeration) => {
+    const iterable = unwrapJavaScriptExpression(loop.right).node;
+    const literal = readExactJavaScriptLiteral(iterable);
+    if (t.isForOfStatement(loop)) {
+        if (prototypeMayAffectEnumeration !== false)
+            return "unknown";
+        if (t.isArrayExpression(iterable)) {
+            if (iterable.elements.length === 0)
+                return "empty";
+            if (iterable.elements.some((element) => element === null || !t.isSpreadElement(element)))
+                return "nonempty";
+            return "unknown";
+        }
+        if (literal.found && typeof literal.value === "string")
+            return literal.value.length === 0 ? "empty" : "nonempty";
+        return "unknown";
+    }
+    if (t.isObjectExpression(iterable)) {
+        let prototype;
+        for (const property of iterable.properties) {
+            if (t.isSpreadElement(property))
+                return "unknown";
+            const key = semanticStaticPropertyKey(property.key, property.computed);
+            if (t.isObjectProperty(property) &&
+                !property.computed &&
+                !property.shorthand &&
+                key === "__proto__") {
+                prototype = unwrapJavaScriptExpression(property.value).node;
+                continue;
+            }
+            if (key === null)
+                return "unknown";
+            return "nonempty";
+        }
+        if (t.isNullLiteral(prototype))
+            return "empty";
+        if (prototype !== undefined && !readExactJavaScriptLiteral(prototype).found)
+            return "unknown";
+        return prototypeMayAffectEnumeration === false ? "empty" : "unknown";
+    }
+    if (literal.found && literal.value === null)
+        return "empty";
+    if (literal.found &&
+        typeof literal.value === "string" &&
+        literal.value.length > 0)
+        return "nonempty";
+    if (literal.found)
+        return prototypeMayAffectEnumeration === false ? "empty" : "unknown";
+    return "unknown";
+};
+/** Instance values run on construction; their computed keys run at definition. */
+export const delayedInstanceFieldValue = (parent, child) => (t.isClassProperty(parent) ||
+    t.isClassPrivateProperty(parent) ||
+    t.isClassAccessorProperty(parent)) &&
+    !parent.static &&
+    parent.value === child;
+/** Shared branch facts for binding writes and their possible execution positions. */
+export const semanticBranchMayBeSkipped = (parent, child) => {
+    if (delayedInstanceFieldValue(parent, child))
+        return true;
+    if (t.isIfStatement(parent))
+        return child === parent.consequent || child === parent.alternate;
+    if (t.isSwitchCase(parent))
+        return true;
+    if (t.isTryStatement(parent))
+        return child === parent.block || child === parent.handler;
+    if (t.isForStatement(parent))
+        return child === parent.body || child === parent.update;
+    if (t.isWhileStatement(parent))
+        return child === parent.body;
+    if (t.isDoWhileStatement(parent))
+        return child === parent.test;
+    if (t.isForInStatement(parent) || t.isForOfStatement(parent))
+        return child === parent.left || child === parent.body;
+    if (t.isLogicalExpression(parent))
+        return child === parent.right;
+    if (t.isAssignmentPattern(parent))
+        return child === parent.right;
+    if (t.isAssignmentExpression(parent))
+        return (["&&=", "||=", "??="].includes(parent.operator) && child === parent.right);
+    if (t.isConditionalExpression(parent))
+        return child === parent.consequent || child === parent.alternate;
+    if (t.isOptionalCallExpression(parent) || t.isCallExpression(parent))
+        return (parent.arguments.includes(child) &&
+            ((t.isOptionalCallExpression(parent) && parent.optional) ||
+                optionalChainMayShortCircuit(parent.callee)));
+    if (t.isOptionalMemberExpression(parent))
+        return (parent.computed &&
+            child === parent.property &&
+            (parent.optional || optionalChainMayShortCircuit(parent.object)));
+    return false;
+};
+const optionalChainMayShortCircuit = (expression) => {
+    let current = expression;
+    while (true) {
+        // Parentheses terminate optional-chain short-circuiting. In particular,
+        // `(foo?.bar)(arg)` evaluates arg before attempting the call.
+        if (current.extra?.parenthesized === true)
+            return false;
+        const unwrapped = unwrapJavaScriptExpression(current, preserveGrouping).node;
+        if (unwrapped !== current) {
+            current = unwrapped;
+            continue;
+        }
+        if (t.isOptionalMemberExpression(current)) {
+            if (current.optional)
+                return true;
+            current = current.object;
+        }
+        else if (t.isMemberExpression(current))
+            current = current.object;
+        else if (t.isOptionalCallExpression(current)) {
+            if (current.optional)
+                return true;
+            current = current.callee;
+        }
+        else if (t.isCallExpression(current))
+            current = current.callee;
+        else
+            return false;
+    }
+};

package/dist/domain/javascript/javascriptSemanticExpressionShapes.js

@@ -0,0 +1,111 @@
+import { semanticOpaqueBindingReadMayHaveChanged, semanticOpaqueNameMayHaveChanged, } from "./javascriptSemanticOpaqueEffects.js";
+import * as t from "@babel/types";
+import { isNullishJavaScriptSyntax, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { isErasedJavaScriptDeclaration, isUnmodeledJavaScriptRuntimeScope, } from "./javascriptModuleDeclaration.js";
+import { semanticBindingAtRead } from "./javascriptSemanticMutationInitializers.js";
+import { SEMANTIC_EXPRESSION_DEPTH_LIMIT } from "./javascriptSemanticResourceLimits.js";
+import { isUnshadowedGlobal, resolveSemanticBindingState, semanticStableInitializer, } from "./javascriptSemanticState.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { javaScriptRuntimeContext } from "./javascriptSourceParser.js";
+const commonJsWrapperParameterNames = new Set([
+    "exports",
+    "require",
+    "module",
+    "__filename",
+    "__dirname",
+]);
+/** Bounded child-argument identity only; never recover named object contents. */
+export const createSemanticExpressionShapeResolver = (state) => {
+    const hoistedFunction = (node) => {
+        const parent = state.parentsByNode.get(node);
+        return (t.isFunctionDeclaration(node) &&
+            (t.isProgram(parent) ||
+                (t.isBlockStatement(parent) &&
+                    t.isFunction(state.parentsByNode.get(parent)))));
+    };
+    // Most modules have no named child arguments. Collect source-wide blockers
+    // only when a query actually needs a named binding or ambient undefined.
+    let blocked;
+    const blockFunctionNames = new Set();
+    const namedProofBlocked = () => {
+        if (blocked !== undefined)
+            return blocked;
+        blocked = false;
+        traverseJavaScriptAst(state.program, {
+            enter(node) {
+                blocked ||=
+                    isErasedJavaScriptDeclaration(node) ||
+                        isUnmodeledJavaScriptRuntimeScope(node);
+                if (javaScriptRuntimeContext(state.program) !== "module" &&
+                    t.isFunctionDeclaration(node) &&
+                    node.id != null &&
+                    !hoistedFunction(node))
+                    blockFunctionNames.add(node.id.name);
+            },
+        });
+        return blocked;
+    };
+    const shape = (input) => {
+        const seen = new Set();
+        let node = input;
+        let depth = 0;
+        while (true) {
+            const unwrapped = unwrapJavaScriptExpression(node);
+            node = unwrapped.node;
+            depth += unwrapped.depth;
+            if (depth > SEMANTIC_EXPRESSION_DEPTH_LIMIT) {
+                state.valueResourceLimits.add("expression-depth");
+                return "unknown";
+            }
+            if (seen.has(node))
+                return "unknown";
+            seen.add(node);
+            if (t.isArrayExpression(node))
+                return "array";
+            if (t.isFunction(node) && !("declare" in node && node.declare))
+                return "callback";
+            if (!t.isIdentifier(node))
+                return "unknown";
+            const binding = resolveSemanticBindingState(state, node, node.name);
+            if (binding === undefined || binding.referenceInitializers.length > 0)
+                return "unknown";
+            if (state.scopesById.get(binding.scopeId)?.kind === "program") {
+                const context = javaScriptRuntimeContext(state.program);
+                // Unknown scripts expose globals; wrapper parameters can alias arguments.
+                // Neither environment has a proven stable local initializer here.
+                if (context === "unknown" ||
+                    (context === "commonjs" &&
+                        commonJsWrapperParameterNames.has(binding.name)))
+                    return "unknown";
+            }
+            // Annex B may copy a block function into an outer var without an indexed
+            // assignment. Keep same-named vars unknown rather than model that copy.
+            if (namedProofBlocked() ||
+                semanticOpaqueBindingReadMayHaveChanged(binding, node, state) ||
+                (binding.declarationKinds.has("var") &&
+                    blockFunctionNames.has(binding.name)))
+                return "unknown";
+            const initializer = semanticStableInitializer(binding, state);
+            if (initializer === undefined || initializer.projection.length > 0)
+                return "unknown";
+            const read = semanticBindingAtRead(binding, node, state.parentsByNode);
+            // Hoisted function declarations are the only accepted unordered source.
+            if (!hoistedFunction(initializer.node) &&
+                (read.status !== "ordered" || !read.hasDefiniteInitializer))
+                return "unknown";
+            node = initializer.node;
+            depth++;
+        }
+    };
+    return {
+        isArray: (node) => shape(node) === "array",
+        isCallback: (node) => shape(node) === "callback",
+        isNullish: (input) => {
+            const { node } = unwrapJavaScriptExpression(input);
+            return (isNullishJavaScriptSyntax(node) ||
+                (isUnshadowedGlobal(node, state, "undefined") &&
+                    !namedProofBlocked() &&
+                    !semanticOpaqueNameMayHaveChanged(node, state)));
+        },
+    };
+};

package/dist/domain/javascript/javascriptSemanticFingerprints.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
+import { runtimeFunctionParameters } from "./javascriptAstValues.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";
@@ -22,7 +23,7 @@ export function* collectJavaScriptSemanticFingerprintsSteps(input) {
         if (node === undefined)
             continue;
         yield;
-        const syntax = yield* fingerprintSyntaxSteps(node, callable.callableId);
+        const syntax = yield* fingerprintSyntaxSteps(node);
         const promiseEffects = promiseEffectsByOwner.get(callable.callableId) ?? [];
         const eventEffects = eventEffectsByOwner.get(callable.callableId) ?? [];
         const timerEffects = timerEffectsByOwner.get(callable.callableId) ?? [];
@@ -83,18 +84,13 @@ const countByOwner = (values, getOwner) => {
     }
     return counts;
 };
-function* fingerprintSyntaxSteps(root, targetCallableId) {
+function* fingerprintSyntaxSteps(root) {
     const normalizedTokens = [];
     const controlFlowTokens = [];
     const literals = [];
-    const callableStack = [];
     yield* traverseJavaScriptAstSteps(root, {
+        skip: (node) => semanticCallableIdForNode(node) !== null,
         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)
@@ -103,11 +99,6 @@ function* fingerprintSyntaxSteps(root, targetCallableId) {
             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 };
 }
@@ -127,6 +118,8 @@ const normalizedNodeToken = (node, parent) => {
         primitiveAttribute(node, "optional"),
         primitiveAttribute(node, "async"),
         primitiveAttribute(node, "generator"),
+        primitiveAttribute(node, "delegate"),
+        primitiveAttribute(node, "prefix"),
     ].filter((value) => value !== null);
     return [node.type, ...attributes].join(":");
 };
@@ -170,6 +163,10 @@ const controlFlowToken = (node) => {
     return operator === null ? node.type : `${node.type}:${operator}`;
 };
 const semanticLiteral = (node) => {
+    // Babel retains directive escapes in value; decoding them would erase the
+    // distinction between a strict-mode directive and an escaped lookalike.
+    if (t.isDirectiveLiteral(node))
+        return `directive:${node.value}`;
     if (t.isStringLiteral(node))
         return `string:${node.value}`;
     if (t.isNumericLiteral(node))
@@ -192,6 +189,6 @@ const relationShape = (callable, callSites, captureCount, promises) => [
     `captures:${String(captureCount)}`,
     ...promises.map(({ kind, method, ownership, sourceResolution }) => `promise:${kind}:${method}:${ownership}:${sourceResolution}`),
 ];
-const callableParameterArity = (node) => t.isFunction(node) ? node.params.length : 0;
+const callableParameterArity = (node) => t.isFunction(node) ? runtimeFunctionParameters(node).length : 0;
 const isAsyncCallable = (node) => t.isFunction(node) && node.async;
 const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");