rea-agents 6.0.0 → 6.2.0

package/dist/domain/javascript/javascriptSemanticReturns.js

@@ -1,4 +1,5 @@
 import * as t from "@babel/types";
+import { semanticContainer, semanticPropertyPointer, } from "./javascriptSemanticSlots.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
@@ -137,35 +138,49 @@ export const flattenSemanticReturnValue = (value) => {
     propertyCoverage.sort((left, right) => compareCodePoints(left.path, right.path));
     return { fields, propertyCoverage };
 };
-const flattenValue = (value, path, fields, coverage) => {
+const flattenValue = (value, path, fields, coverage, presence = "present") => {
+    if (presence !== "present") {
+        fields.push({
+            path,
+            presence,
+            state: "unknown",
+            value: null,
+            reason: "reason" in value ? value.reason : "Property presence is uncertain.",
+        });
+        return;
+    }
     if (value.status === "literal") {
-        fields.push({ path, state: "literal", value: value.value, reason: null });
+        fields.push({
+            path,
+            presence,
+            state: "literal",
+            value: value.value,
+            reason: null,
+        });
         return;
     }
     if (value.status === "union") {
         fields.push({
             path,
+            presence,
             state: "union",
             value: [...value.values],
             reason: null,
         });
         return;
     }
-    if (value.status === "object") {
-        coverage.push(value.unknownProperties
-            ? { path, status: "partial", omitted: value.omittedProperties }
-            : { path, status: "complete", omitted: 0 });
-        for (const property of value.properties)
-            flattenValue(property.value, `${path}/${escapePointer(property.name)}`, fields, coverage);
-        return;
-    }
-    if (value.status === "array") {
-        coverage.push(value.unknownItems
-            ? { path, status: "partial", omitted: value.omittedItems }
-            : { path, status: "complete", omitted: 0 });
-        value.items.forEach((item, index) => flattenValue(item, `${path}/${String(index)}`, fields, coverage));
+    if ("reason" in value) {
+        fields.push({
+            path,
+            presence,
+            state: "unknown",
+            value: null,
+            reason: value.reason,
+        });
         return;
     }
-    fields.push({ path, state: "unknown", value: null, reason: value.reason });
+    const container = semanticContainer(value);
+    coverage.push({ path, ...container.coverage });
+    for (const slot of container.slots)
+        flattenValue(slot.value, `${path}${semanticPropertyPointer([slot.name])}`, fields, coverage, slot.presence);
 };
-const escapePointer = (value) => value.replaceAll("~", "~0").replaceAll("/", "~1");

package/dist/domain/javascript/javascriptSemanticSlots.js

@@ -0,0 +1,72 @@
+export function semanticContainer(value) {
+    if (value.status === "object")
+        return {
+            slots: value.properties,
+            coverage: value.unknownProperties
+                ? { status: "partial", omitted: value.omittedProperties }
+                : { status: "complete", omitted: 0 },
+        };
+    if (value.status === "array")
+        return {
+            slots: value.items,
+            coverage: value.unknownItems
+                ? { status: "partial", omitted: value.omittedItems }
+                : { status: "complete", omitted: 0 },
+        };
+    return null;
+}
+/** Resolve a full static own-property path without conflating missing siblings. */
+export const semanticSlotAtPath = (value, path) => {
+    const leafName = path.at(-1) ?? "";
+    let current = {
+        name: "",
+        presence: "present",
+        value,
+    };
+    for (const [index, name] of path.entries()) {
+        const container = semanticContainer(current.value);
+        if (current.presence !== "present" || container === null)
+            return {
+                name: leafName,
+                presence: "unknown-coverage",
+                value: "reason" in current.value
+                    ? {
+                        ...current.value,
+                        reason: `${current.value.reason} Cannot continue ${semanticPropertyPointer(path)} through receiver ${semanticPropertyPointer(path.slice(0, index))}.`,
+                    }
+                    : {
+                        status: "unknown",
+                        reason: `Cannot resolve ${semanticPropertyPointer(path)} through ${current.value.status} receiver ${semanticPropertyPointer(path.slice(0, index))}.`,
+                    },
+            };
+        // Array position inventories omit the intrinsic non-enumerable length slot.
+        // Its own presence is guaranteed even when no exact length is retained.
+        if (current.value.status === "array" && name === "length") {
+            current = {
+                name,
+                presence: "present",
+                value: {
+                    status: "unknown",
+                    reason: "Array length is present but its value is not retained.",
+                },
+            };
+            continue;
+        }
+        const observed = container.slots.find((slot) => slot.name === name);
+        current = observed ?? {
+            name,
+            presence: container.coverage.status === "complete"
+                ? "absent"
+                : "unknown-coverage",
+            value: {
+                status: "unknown",
+                reason: `Own property ${name} was not observed.`,
+            },
+        };
+    }
+    return current;
+};
+/** Encode path segments as an unambiguous JSON Pointer, preserving empty keys. */
+export const semanticPropertyPointer = (path) => path
+    .map((key) => `/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`)
+    .join("");

package/dist/domain/javascript/javascriptSemanticValues.js

@@ -1,25 +1,66 @@
 import * as t from "@babel/types";
+import { semanticSlotAtPath } from "./javascriptSemanticSlots.js";
 import { invalidateSemanticMutationPath } from "./javascriptSemanticMutationValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
 import { semanticAmbiguousProvenance, semanticLocalProvenance, semanticOriginsProvenance, semanticUnresolvedProvenance, uniqueSemanticOrigins, } from "./javascriptSemanticProvenance.js";
-import { semanticPrimitiveCandidates as primitiveCandidates, semanticPrimitiveSet as primitiveSet, semanticPrimitiveValue as primitiveValue, } from "./javascriptSemanticPrimitives.js";
+import { semanticPrimitiveCandidates as primitiveCandidates, semanticPrimitiveSet as primitiveSet, } from "./javascriptSemanticPrimitives.js";
+import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveAdditionByteBudget, exceedsSemanticTemplateByteBudget, semanticResourceLimitUnknown, semanticResourceLimitReason, } from "./javascriptSemanticResourceLimits.js";
+const primitiveBindingValuesByState = new WeakMap();
+const primitiveBindingValuesFor = (state) => {
+    const existing = primitiveBindingValuesByState.get(state);
+    if (existing !== undefined)
+        return existing;
+    const values = new Map();
+    primitiveBindingValuesByState.set(state, values);
+    return values;
+};
+// Cap expression recursion independently from graph nodes and primitive unions.
+const isSemanticResourceLimit = (value) => value.status === "unknown" && value.resourceLimit !== undefined;
 /** Evaluate one binding in the bounded constant-value lattice. */
-export const evaluateSemanticBinding = (binding, state) => evaluateBinding(binding, { state, bindings: new Set() });
+export const evaluateSemanticBinding = (binding, state) => evaluateBinding(binding, {
+    state,
+    bindings: new Set(),
+    expressionDepth: 0,
+    primitiveBindingValues: primitiveBindingValuesFor(state),
+});
 /** Evaluate one arbitrary inert expression in the established lexical state. */
-export const evaluateSemanticExpression = (node, state) => evaluateExpression(node, { state, bindings: new Set() });
+export const evaluateSemanticExpression = (node, state) => evaluateExpression(node, {
+    state,
+    bindings: new Set(),
+    expressionDepth: 0,
+    primitiveBindingValues: primitiveBindingValuesFor(state),
+});
 /** Follow module provenance through destructuring, members, and aliases. */
-export const evaluateSemanticProvenance = (binding, state) => provenanceForBinding(binding, { state, bindings: new Set() });
+export const evaluateSemanticProvenance = (binding, state) => provenanceForBinding(binding, {
+    state,
+    bindings: new Set(),
+    expressionDepth: 0,
+    primitiveBindingValues: primitiveBindingValuesFor(state),
+});
 const evaluateBinding = (binding, context) => {
     if (context.bindings.has(binding.bindingId))
         return { status: "cycle", reason: `Alias cycle at ${binding.name}.` };
+    const cached = context.primitiveBindingValues.get(binding.bindingId);
+    if (cached !== undefined)
+        return cached;
     if (binding.initializers.length === 0)
         return {
             status: "unknown",
             reason: `Binding ${binding.name} has no constant initializer.`,
         };
+    if (binding.initializers.some(({ node }) => t.isUpdateExpression(node) ||
+        (t.isAssignmentExpression(node) &&
+            node.operator !== "=" &&
+            node.operator !== "&&=" &&
+            node.operator !== "||=" &&
+            node.operator !== "??=")))
+        return {
+            status: "unknown",
+            reason: `Binding ${binding.name} has a compound or update write.`,
+        };
     if (binding.initializers.length > 1)
         return {
             status: "ambiguous",
@@ -30,10 +71,19 @@ const evaluateBinding = (binding, context) => {
         return { status: "unknown", reason: "Missing binding initializer." };
     const nested = nestedContext(context, binding.bindingId);
     const value = projectValue(evaluateExpression(initializer.node, nested), initializer.projection);
-    return binding.mutatedPaths.reduce(invalidateSemanticMutationPath, value);
+    const projected = binding.mutatedPaths.reduce(invalidateSemanticMutationPath, value);
+    if (projected.status === "literal" ||
+        projected.status === "union" ||
+        (isSemanticResourceLimit(projected) &&
+            (projected.resourceLimit === "primitive-bytes" ||
+                projected.resourceLimit === "primitive-candidates")))
+        context.primitiveBindingValues.set(binding.bindingId, projected);
+    return projected;
 };
 const evaluateExpression = (node, context) => {
-    const literal = primitiveValue(node);
+    if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT)
+        return semanticResourceLimitUnknown("expression-depth");
+    const literal = readExactJavaScriptLiteral(node);
     if (literal.found)
         return { status: "literal", value: literal.value };
     if (t.isIdentifier(node)) {
@@ -75,18 +125,34 @@ const evaluateTemplate = (node, context) => {
     let candidates = [""];
     for (let index = 0; index < node.quasis.length; index += 1) {
         const quasi = node.quasis[index];
-        const text = quasi?.value.cooked ?? quasi?.value.raw ?? "";
+        const text = quasi?.value.cooked;
+        if (text === undefined || text === null)
+            return {
+                status: "unknown",
+                reason: "Template text has no cooked representation.",
+            };
+        if (exceedsSemanticTemplateByteBudget(candidates, [text]))
+            return semanticResourceLimitUnknown("primitive-bytes");
         candidates = candidates.map((prefix) => `${prefix}${text}`);
         const expression = node.expressions[index];
         if (expression === undefined)
             continue;
-        const values = primitiveCandidates(evaluateExpression(expression, nestedContext(context)));
-        if (values === null)
+        const evaluated = evaluateExpression(expression, nestedContext(context));
+        const values = primitiveCandidates(evaluated);
+        if (values === null) {
+            if (isSemanticResourceLimit(evaluated))
+                return evaluated;
             return {
                 status: "unknown",
                 reason: "Template expression is not a bounded primitive.",
             };
-        candidates = candidates.flatMap((prefix) => values.map((value) => `${prefix}${String(value)}`));
+        }
+        if (candidates.length > SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT / values.length)
+            return semanticResourceLimitUnknown("primitive-candidates");
+        const suffixes = values.map((value) => String(value));
+        if (exceedsSemanticTemplateByteBudget(candidates, suffixes))
+            return semanticResourceLimitUnknown("primitive-bytes");
+        candidates = candidates.flatMap((prefix) => suffixes.map((suffix) => `${prefix}${suffix}`));
     }
     return primitiveSet(candidates);
 };
@@ -98,6 +164,7 @@ const evaluateObject = (node, context) => {
         for (const [name] of propertiesByName)
             propertiesByName.set(name, {
                 name,
+                presence: "present",
                 value: {
                     status: "unknown",
                     reason: "A later property may overwrite this value.",
@@ -131,6 +198,7 @@ const evaluateObject = (node, context) => {
         }
         propertiesByName.set(name, {
             name,
+            presence: "present",
             value: t.isObjectProperty(property)
                 ? evaluateExpression(property.value, nestedContext(context))
                 : {
@@ -166,20 +234,27 @@ const evaluateArray = (node, context) => {
             break;
         }
         if (element === null) {
-            unknownItems = true;
-            if (omittedItems !== null)
-                omittedItems += 1;
             items.push({
-                status: "unknown",
-                reason: "Array hole has no primitive value.",
+                name: String(items.length),
+                presence: "absent",
+                value: { status: "unknown", reason: "Array hole has no own value." },
             });
             continue;
         }
-        items.push(evaluateExpression(element, nestedContext(context)));
+        items.push({
+            name: String(items.length),
+            presence: "present",
+            value: evaluateExpression(element, nestedContext(context)),
+        });
     }
     return unknownItems
         ? { status: "array", items, unknownItems: true, omittedItems }
-        : { status: "array", items, unknownItems: false, omittedItems: 0 };
+        : {
+            status: "array",
+            items,
+            unknownItems: false,
+            omittedItems: 0,
+        };
 };
 const evaluateMember = (node, context) => {
     const keys = [];
@@ -231,17 +306,30 @@ const evaluateAddition = (node, context) => {
 const addPrimitiveValues = (leftValue, rightValue) => {
     const left = primitiveCandidates(leftValue);
     const right = primitiveCandidates(rightValue);
-    if (left === null || right === null)
+    if (left === null || right === null) {
+        if (isSemanticResourceLimit(leftValue))
+            return leftValue;
+        if (isSemanticResourceLimit(rightValue))
+            return rightValue;
         return { status: "unknown", reason: "Non-primitive addition." };
+    }
+    if (left.length > SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT / right.length)
+        return semanticResourceLimitUnknown("primitive-candidates");
+    if (exceedsSemanticPrimitiveAdditionByteBudget(left, right))
+        return semanticResourceLimitUnknown("primitive-bytes");
     const values = left.flatMap((leftValue) => right.map((rightValue) => typeof leftValue === "string" || typeof rightValue === "string"
         ? `${String(leftValue)}${String(rightValue)}`
         : Number(leftValue) + Number(rightValue)));
     return primitiveSet(values);
 };
 const evaluateUnary = (node, context) => {
-    const argument = primitiveCandidates(evaluateExpression(node.argument, nestedContext(context)));
-    if (argument === null)
+    const evaluated = evaluateExpression(node.argument, nestedContext(context));
+    const argument = primitiveCandidates(evaluated);
+    if (argument === null) {
+        if (isSemanticResourceLimit(evaluated))
+            return evaluated;
         return { status: "unknown", reason: "Non-primitive unary operand." };
+    }
     if (node.operator === "!")
         return primitiveSet(argument.map((value) => !value));
     if (node.operator === "+")
@@ -251,46 +339,16 @@ const evaluateUnary = (node, context) => {
     return { status: "unknown", reason: `Unsupported unary ${node.operator}.` };
 };
 const projectValue = (value, projection) => {
-    let current = value;
-    for (const key of projection) {
-        if (key === null)
-            return {
-                status: "unknown",
-                reason: "Cannot project a dynamic property.",
-            };
-        if (current.status === "object" && typeof key === "string") {
-            const property = current.properties.find(({ name }) => name === key);
-            if (property === undefined)
-                return {
-                    status: current.unknownProperties ? "unknown" : "unknown",
-                    reason: `Object property ${key} was not observed.`,
-                };
-            current = property.value;
-        }
-        else if (current.status === "array") {
-            const index = typeof key === "number" ? key : Number(key);
-            if (!Number.isSafeInteger(index) ||
-                index < 0 ||
-                String(index) !== String(key))
-                return {
-                    status: "unknown",
-                    reason: `Array property ${String(key)} is not a canonical index.`,
-                };
-            const item = current.items[index];
-            if (item === undefined)
-                return {
-                    status: "unknown",
-                    reason: `Array item ${String(key)} missing.`,
-                };
-            current = item;
-        }
-        else
-            return {
-                status: "unknown",
-                reason: `Cannot project ${String(key)} from ${current.status}.`,
-            };
-    }
-    return current;
+    if (projection.includes(null))
+        return { status: "unknown", reason: "Cannot project a dynamic property." };
+    const path = projection.map((key) => String(key));
+    const slot = semanticSlotAtPath(value, path);
+    return slot.presence === "present"
+        ? slot.value
+        : {
+            status: "unknown",
+            reason: `Own property ${path.join("/")} is ${slot.presence}.`,
+        };
 };
 const provenanceForBinding = (binding, context) => {
     if (context.bindings.has(binding.bindingId))
@@ -318,6 +376,8 @@ const provenanceForBinding = (binding, context) => {
     })));
 };
 const provenanceForExpression = (node, context) => {
+    if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT)
+        return semanticUnresolvedProvenance("unknown", semanticResourceLimitReason("expression-depth"));
     const required = semanticRequireOrigin(node, context.state);
     if (required !== undefined)
         return semanticOriginsProvenance([required]);
@@ -364,6 +424,9 @@ const provenanceForExpression = (node, context) => {
     return semanticLocalProvenance();
 };
 const mergeValues = (values) => {
+    const resourceLimit = values.find(isSemanticResourceLimit);
+    if (resourceLimit !== undefined)
+        return resourceLimit;
     const primitives = values.flatMap((value) => primitiveCandidates(value) ?? []);
     return values.every((value) => value.status === "union" || value.status === "literal")
         ? primitiveSet(primitives)
@@ -371,6 +434,8 @@ const mergeValues = (values) => {
 };
 const nestedContext = (context, bindingId) => ({
     state: context.state,
+    primitiveBindingValues: context.primitiveBindingValues,
+    expressionDepth: context.expressionDepth + 1,
     bindings: bindingId === undefined
         ? context.bindings
         : new Set([...context.bindings, bindingId]),

package/dist/domain/javascript/javascriptSourceMapPaths.js

@@ -0,0 +1,104 @@
+import { posix } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { z } from "zod";
+/** Map-scoped source declaration and its path interpretation for matching. */
+export const javascriptSourceMapReferenceSchema = z.strictObject({
+    source_name: z.string(),
+    source_root: z.string().nullable(),
+    map_path: z.string().min(1),
+    resolution: z.discriminatedUnion("kind", [
+        z.strictObject({
+            kind: z.enum(["artifact-relative", "suffix"]),
+            path: z.string().min(1),
+        }),
+        z.strictObject({
+            kind: z.literal("unresolved"),
+            reason: z.string().min(1),
+        }),
+    ]),
+});
+/** Interpret a declaration once at the source-map ingestion boundary. */
+export const resolveJavaScriptSourceMapReference = (sourceName, sourceRoot, mapPath) => {
+    // TraceMap's producer prefixes sourceRoot before resolving the URL reference.
+    const reference = `${sourceRoot ? `${sourceRoot}/` : ""}${sourceName}`;
+    return {
+        source_name: sourceName,
+        source_root: sourceRoot,
+        map_path: mapPath,
+        resolution: resolveJavaScriptSourceMapPath(reference, mapPath),
+    };
+};
+/** Resolve a source-map URL reference without changing its recorded identity. */
+const resolveJavaScriptSourceMapPath = (source, mapPath) => {
+    const portable = source.replaceAll("\\", "/");
+    const windowsPath = /^[a-z]:\//iu.test(portable) || source.startsWith("\\\\");
+    // Preserve parent traversal rather than letting URL resolution clamp at '/'.
+    const anchor = `/${"source/".repeat(portable.split("/").length + 1)}`;
+    const directory = posix.join(anchor, posix.dirname(mapPath.replaceAll("\\", "/")));
+    const base = pathToFileURL(`${directory}/`, { windows: false });
+    const absolute = windowsPath ? windowsFileUrl(source) : URL.parse(source);
+    const resolved = windowsPath ? absolute : URL.parse(source, base);
+    if (resolved === null)
+        return {
+            kind: "unresolved",
+            reason: "Source reference is not a valid URL or filesystem path.",
+        };
+    if (!resolved.pathname.startsWith("/"))
+        return {
+            kind: "unresolved",
+            reason: "Source reference uses a non-hierarchical URL without a file pathname.",
+        };
+    if (resolved.pathname.endsWith("/"))
+        return {
+            kind: "unresolved",
+            reason: "Source reference names a directory rather than a file.",
+        };
+    // Encoded separators must not manufacture a different filesystem hierarchy.
+    if (/%(?:2f|5c)/iu.test(resolved.pathname))
+        return {
+            kind: "unresolved",
+            reason: "Source reference contains an encoded path separator.",
+        };
+    const relative = absolute === null
+        ? !portable.startsWith("/")
+        : absolute.href !== resolved.href;
+    const path = decodedUrlPath(resolved);
+    if (path === null)
+        return {
+            kind: "unresolved",
+            reason: "Source reference has malformed URL encoding or an invalid file URL.",
+        };
+    const value = relative
+        ? posix.relative(anchor, path)
+        : path.replace(/^\/+/, "");
+    if (value === "" || value === ".." || value.startsWith("../"))
+        return {
+            kind: "unresolved",
+            reason: "Source reference resolves outside the inventoried artifact.",
+        };
+    return { path: value, kind: relative ? "artifact-relative" : "suffix" };
+};
+const windowsFileUrl = (path) => {
+    try {
+        return pathToFileURL(path, { windows: true });
+    }
+    catch (cause) {
+        if (cause instanceof TypeError)
+            return null;
+        throw cause;
+    }
+};
+const decodedUrlPath = (url) => {
+    try {
+        if (url.protocol === "file:")
+            return fileURLToPath(url, {
+                windows: url.hostname !== "" && url.hostname !== "localhost",
+            }).replaceAll("\\", "/");
+        return `${url.host}${decodeURIComponent(url.pathname)}`;
+    }
+    catch (cause) {
+        if (cause instanceof URIError || cause instanceof TypeError)
+            return null;
+        throw cause;
+    }
+};

package/dist/domain/javascript/javascriptSourceParser.js

@@ -1,6 +1,6 @@
 import { parse } from "@babel/parser";
 /** Parse JavaScript or TypeScript once without attaching comments to AST nodes. */
-export const parseJavaScriptSource = (source) => {
+export const parseJavaScriptSource = (source, sourcePath) => {
     try {
         return parse(source, {
             sourceType: "unambiguous",
@@ -10,7 +10,11 @@ export const parseJavaScriptSource = (source) => {
             // forms, including parameter decorators. Without it a decorated
             // TypeScript source fails to parse at all rather than reporting
             // recovered syntax, which loses every fact derived from that source.
-            plugins: ["decorators-legacy", "jsx", "typescript"],
+            // Plain .ts artifacts admit angle-bracket type assertions instead of JSX.
+            // Unknown paths retain the existing JSX-capable parser contract.
+            plugins: sourcePath?.toLowerCase().endsWith(".ts") === true
+                ? ["decorators-legacy", "typescript"]
+                : ["decorators-legacy", "jsx", "typescript"],
         });
     }
     catch (cause) {

package/dist/domain/javascript/javascriptStaticAnalysis.js

@@ -6,26 +6,27 @@ import { addReference, addSourceMapDirectives, inspectCall, inspectRouteProperty
 import { inspectBundlerRegistration, inspectEsbuildWrapper, } from "./javascriptStaticAnalysisBundler.js";
 import { finalizeLocatedFindings } from "./javascriptStaticAnalysisFindings.js";
 import { createJavaScriptAnalysisAccumulator, } from "./javascriptStaticAnalysisState.js";
+import { classifyParsedJavaScriptOpenReceivers, } from "./javascriptSemanticAnalysis.js";
 import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
 /** Parse one JavaScript artifact and recover static structure only. */
 export const analyzeJavaScriptStaticSource = (source) => {
     const file = parseJavaScriptSource(source);
     return file === null
         ? failedJavaScriptStaticAnalysis()
-        : analyzeParsedJavaScriptStaticSource(source, file);
+        : analyzeParsedJavaScriptStaticSource(source, file, classifyParsedJavaScriptOpenReceivers(file));
 };
 /** Recover static structure from an already parsed JavaScript artifact. */
-export const analyzeParsedJavaScriptStaticSource = (source, file) => {
-    const accumulator = createJavaScriptAnalysisAccumulator();
-    traverseStaticSource(source, file, accumulator);
+export const analyzeParsedJavaScriptStaticSource = (source, file, openReceiverFacts) => {
+    const accumulator = createJavaScriptAnalysisAccumulator(source.length);
+    traverseStaticSource(source, file, accumulator, openReceiverFacts);
     addSourceMapDirectives(source, file.comments ?? [], accumulator);
     return finalizeStaticAnalysis(source, file, accumulator);
 };
-const traverseStaticSource = (source, file, accumulator) => {
+const traverseStaticSource = (source, file, accumulator, openReceiverFacts) => {
     traverseJavaScriptAst(file, {
         enter: (node) => {
             accumulator.visitedNodes += 1;
-            inspectNode(source, node, accumulator);
+            inspectNode(source, node, accumulator, openReceiverFacts);
             return undefined;
         },
     });
@@ -51,28 +52,29 @@ const finalizeStaticAnalysis = (source, file, accumulator) => {
             : "complete",
         parse_error_count: parserErrors,
         visited_ast_nodes: accumulator.visitedNodes,
-        references: finalizeLocatedFindings(accumulator.references, accumulator.modules),
-        endpoints: finalizeLocatedFindings(accumulator.endpoints, accumulator.modules),
-        storage: finalizeLocatedFindings(accumulator.storage, accumulator.modules),
+        references: finalizeLocatedFindings(accumulator.references, accumulator.moduleRangeIndex),
+        endpoints: finalizeLocatedFindings(accumulator.endpoints, accumulator.moduleRangeIndex),
+        storage: finalizeLocatedFindings(accumulator.storage, accumulator.moduleRangeIndex),
         bundler_registrations: sortedUnique(accumulator.registrations, registrationKey),
-        role_paths: finalizeLocatedFindings(accumulator.roles, accumulator.modules),
+        role_paths: finalizeLocatedFindings(accumulator.roles, accumulator.moduleRangeIndex),
         source_map_urls: accumulator.sourceMaps,
         vendors: detectVendors(source),
         electron: {
-            browser_windows: finalizeLocatedFindings(accumulator.browserWindows, accumulator.modules),
-            context_bridge_apis: finalizeLocatedFindings(accumulator.contextBridgeApis, accumulator.modules),
-            ipc: finalizeLocatedFindings(accumulator.ipc, accumulator.modules),
-            sender_validations: finalizeLocatedFindings(accumulator.senderValidations, accumulator.modules),
-            utility_processes: finalizeLocatedFindings(accumulator.utilityProcesses, accumulator.modules),
-            native_addon_bindings: finalizeLocatedFindings(accumulator.nativeAddonBindings, accumulator.modules),
+            browser_windows: finalizeLocatedFindings(accumulator.browserWindows, accumulator.moduleRangeIndex),
+            context_bridge_apis: finalizeLocatedFindings(accumulator.contextBridgeApis, accumulator.moduleRangeIndex),
+            ipc: finalizeLocatedFindings(accumulator.ipc, accumulator.moduleRangeIndex),
+            sender_validations: finalizeLocatedFindings(accumulator.senderValidations, accumulator.moduleRangeIndex),
+            utility_processes: finalizeLocatedFindings(accumulator.utilityProcesses, accumulator.moduleRangeIndex),
+            native_addon_bindings: finalizeLocatedFindings(accumulator.nativeAddonBindings, accumulator.moduleRangeIndex),
         },
         limitations,
     };
 };
-const inspectNode = (source, node, accumulator) => {
+const inspectNode = (source, node, accumulator, openReceiverFacts) => {
     const findings = {
         source,
         accumulator,
+        ...(openReceiverFacts === undefined ? {} : { openReceiverFacts }),
     };
     inspectElectronStaticNode(node, findings);
     if (t.isCallExpression(node)) {
@@ -80,6 +82,9 @@ const inspectNode = (source, node, accumulator) => {
         inspectEsbuildWrapper(source, node, accumulator);
         inspectCall(source, node, findings);
     }
+    else if (t.isOptionalCallExpression(node)) {
+        inspectCall(source, node, findings);
+    }
     else if (t.isNewExpression(node))
         inspectCall(source, node, findings);
     if ((t.isImportDeclaration(node) || t.isExportAllDeclaration(node)) &&