rea-agents 4.0.1 → 5.0.0

package/dist/domain/{javascriptSemanticDataEffectHelpers.js → javascript/javascriptSemanticDataEffectHelpers.js}

@@ -1,8 +1,9 @@
 import * as t from "@babel/types";
+import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { semanticStaticPropertyName } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
 /** Resolve bindings written by the nearest variable or assignment owner. */
 export const assignedSemanticResultBindings = (node, ancestors, state) => {
     for (let index = ancestors.length - 1; index >= 0; index -= 1) {
@@ -69,11 +70,10 @@ const projectedPatternBindings = (pattern, state) => {
                 else
                     visit(property.value, [
                         ...path,
-                        semanticStaticPropertyName(property.key, property.computed) ||
-                            null,
+                        semanticStaticPropertyKey(property.key, property.computed),
                     ], partial ||
-                        semanticStaticPropertyName(property.key, property.computed) ===
-                            "");
+                        semanticStaticPropertyKey(property.key, property.computed) ===
+                            null);
             }
         }
         else if (t.isArrayPattern(current)) {
@@ -102,7 +102,8 @@ export const builtinDataEffectMethod = (callee, state, specifiers) => {
     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);
+    const namespace = binding?.directOrigins.some(({ specifier, importedPath }) => specifiers.includes(specifier) &&
+        semanticBuiltinNamespacePath(importedPath));
     return namespace
         ? semanticStaticPropertyName(callee.property, callee.computed)
         : null;

package/dist/domain/{javascriptSemanticDataEffects.js → javascript/javascriptSemanticDataEffects.js}

@@ -1,8 +1,10 @@
 import * as t from "@babel/types";
-import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
+import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
+import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { builtinDataEffectMethod as builtinMethod, containsSemanticNode as containsNode, 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 { compareCodePoints, range } from "./javascriptStaticAnalysisHelpers.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
 /** Recover configuration, request, and boundary candidates from inert syntax. */
 export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
     const context = {
@@ -76,7 +78,8 @@ const processConfigurationMember = (node, state) => {
     const family = semanticStaticPropertyName(object.property, object.computed);
     if (family !== "env" && family !== "argv")
         return null;
-    const key = semanticStaticPropertyName(node.property, node.computed) || null;
+    // `process.env[""]` names an exact (empty) key; only a dynamic key is unknown.
+    const key = semanticStaticPropertyKey(node.property, node.computed);
     return {
         kind: family === "env" ? "environment" : "argv",
         key,
@@ -251,7 +254,7 @@ const requestMethod = (node, state) => {
         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)
+        semanticBuiltinNamespacePath(importedPath))
         ? method
         : null;
 };
@@ -268,8 +271,8 @@ const requestFields = (node, method, state) => {
             return [];
         // `{[key]: 1}` sends no knowable field name; reporting `key` would invent
         // a request field that may not exist.
-        const name = semanticStaticPropertyName(property.key, property.computed);
-        if (name.length === 0)
+        const name = semanticStaticPropertyKey(property.key, property.computed);
+        if (name === null)
             return [];
         return [
             {

package/dist/domain/{javascriptSemanticFingerprints.js → javascript/javascriptSemanticFingerprints.js}

@@ -1,11 +1,19 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
+import { compareCodePoints } from "../canonicalOrdering.js";
 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;
+    const callSitesByCaller = groupByOwner(calls.callSites, ({ callerCallableId }) => callerCallableId);
+    const captureCountByCallable = countByOwner(calls.closureCaptures, ({ callableId }) => callableId);
+    const promiseEffectsByOwner = groupByOwner(promises, ownerId);
+    const eventEffectsByOwner = groupByOwner(events, ownerId);
+    const timerEffectsByOwner = groupByOwner(timers, ownerId);
+    const childProcessEffectsByOwner = groupByOwner([...childProcessSpawns, ...childProcessInteractions], ownerId);
+    const networkEffectsByOwner = groupByOwner(requestOperations, ownerId);
+    const resourceEffectsByOwner = groupByOwner(resourceOperations, ownerId);
     return callables.flatMap((callable) => {
         if (callable.kind === "class")
             return [];
@@ -13,15 +21,12 @@ export const collectJavaScriptSemanticFingerprints = (input) => {
         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);
+        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,
@@ -32,7 +37,7 @@ export const collectJavaScriptSemanticFingerprints = (input) => {
                     parameterArity: callableParameterArity(node),
                     normalizedAstSha256: digest(syntax.normalizedTokens),
                     controlFlowSha256: digest(syntax.controlFlowTokens),
-                    relationShapeSha256: digest(relationShape(callable, calls, promiseEffects)),
+                    relationShapeSha256: digest(relationShape(callable, callSitesByCaller.get(callable.callableId) ?? [], captureCountByCallable.get(callable.callableId) ?? 0, promiseEffects)),
                     literalSetSha256: digest([...new Set(syntax.literals)].sort(compareCodePoints)),
                     effects: [
                         ...(isAsyncCallable(node) ? ["async"] : []),
@@ -56,6 +61,27 @@ export const collectJavaScriptSemanticFingerprints = (input) => {
         ];
     });
 };
+const ownerId = (value) => value.ownerCallableId;
+const groupByOwner = (values, getOwner) => {
+    const grouped = new Map();
+    for (const value of values) {
+        const owner = getOwner(value);
+        const ownedValues = grouped.get(owner);
+        if (ownedValues === undefined)
+            grouped.set(owner, [value]);
+        else
+            ownedValues.push(value);
+    }
+    return grouped;
+};
+const countByOwner = (values, getOwner) => {
+    const counts = new Map();
+    for (const value of values) {
+        const owner = getOwner(value);
+        counts.set(owner, (counts.get(owner) ?? 0) + 1);
+    }
+    return counts;
+};
 const fingerprintSyntax = (root, targetCallableId) => {
     const normalizedTokens = [];
     const controlFlowTokens = [];
@@ -159,12 +185,10 @@ const semanticLiteral = (node) => {
         return `template:${node.value.cooked ?? node.value.raw}`;
     return null;
 };
-const relationShape = (callable, calls, promises) => [
+const relationShape = (callable, callSites, captureCount, 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)}`,
+    ...callSites.map(({ kind, resolution, arguments: args, calleeCallableIds }) => `call:${kind}:${resolution}:${String(args.length)}:${String(calleeCallableIds.length)}`),
+    `captures:${String(captureCount)}`,
     ...promises.map(({ kind, method, ownership, sourceResolution }) => `promise:${kind}:${method}:${ownership}:${sourceResolution}`),
 ];
 const callableParameterArity = (node) => t.isFunction(node) ? node.params.length : 0;

package/dist/domain/{javascriptSemanticGraph.js → javascript/javascriptSemanticGraph.js}

@@ -1,26 +1,17 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
 import { z } from "zod";
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
+import { canonicalDigest, canonicalJson } from "../comparisonSemantics.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, javaScriptSemanticFingerprintInputSchema, javaScriptSemanticFingerprintSchema, javaScriptSemanticGraphInputSchema, javaScriptSemanticGraphRecordSchema, javaScriptSemanticNodeInputSchema, javaScriptSemanticNodeSchema, javaScriptSemanticRelationInputSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownInputSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
-const canonicalJson = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("JavaScript semantic graph could not canonicalize data");
-    return encoded;
-};
-const digestCanonical = (value) => createHash("sha256").update(canonicalJson(value)).digest("hex");
-const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);
 const normalizeEvidence = (evidence) => ({
     ...evidence,
     coverage: {
         ...evidence.coverage,
-        limits: [...evidence.coverage.limits].sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right))),
+        limits: [...evidence.coverage.limits].sort((left, right) => compareCodePoints(canonicalJson(left, "JavaScript semantic graph"), canonicalJson(right, "JavaScript semantic graph"))),
     },
     limitations: uniqueSorted(evidence.limitations),
     evidence_ids: uniqueSorted(evidence.evidence_ids),
 });
-const nodeId = (node) => `jsrg_node_${digestCanonical({ kind: node.kind, identity: node.identity })}`;
+const nodeId = (node) => `jsrg_node_${canonicalDigest({ kind: node.kind, identity: node.identity }, "JavaScript semantic graph")}`;
 /** Normalize one semantic entity and derive its artifact-version identifier. */
 export const createJavaScriptSemanticGraphNode = (input) => {
     const parsed = javaScriptSemanticNodeInputSchema.parse(input);
@@ -51,7 +42,7 @@ export const createJavaScriptSemanticGraphRelation = (input) => {
     };
     return javaScriptSemanticRelationSchema.parse({
         ...semantic,
-        relation_id: `jsrg_relation_${digestCanonical(semantic)}`,
+        relation_id: `jsrg_relation_${canonicalDigest(semantic, "JavaScript semantic graph")}`,
     });
 };
 /** Normalize one unresolved semantic frontier and derive its identifier. */
@@ -65,7 +56,7 @@ export const createJavaScriptSemanticGraphUnknown = (input) => {
     };
     return javaScriptSemanticUnknownSchema.parse({
         ...semantic,
-        unknown_id: `jsrg_unknown_${digestCanonical(semantic)}`,
+        unknown_id: `jsrg_unknown_${canonicalDigest(semantic, "JavaScript semantic graph")}`,
     });
 };
 /** Normalize one function fingerprint and derive its component commitment. */
@@ -80,15 +71,15 @@ export const createJavaScriptSemanticFingerprint = (input) => {
         limitations: uniqueSorted(parsed.limitations),
         evidence: normalizeEvidence(parsed.evidence),
     };
-    const fingerprintSha256 = digestCanonical(semantic.components);
+    const fingerprintSha256 = canonicalDigest(semantic.components, "JavaScript semantic graph");
     return javaScriptSemanticFingerprintSchema.parse({
         ...semantic,
         fingerprint_sha256: fingerprintSha256,
-        fingerprint_id: `jsrg_fingerprint_${digestCanonical({
+        fingerprint_id: `jsrg_fingerprint_${canonicalDigest({
             function_node_id: semantic.function_node_id,
             algorithm: semantic.algorithm,
             fingerprint_sha256: fingerprintSha256,
-        })}`,
+        }, "JavaScript semantic graph")}`,
     });
 };
 const sortedUniqueIssue = (values, path, label, context) => {
@@ -105,8 +96,8 @@ const sortedUniqueIssue = (values, path, label, context) => {
 };
 const checkCoverage = (graph, context) => {
     const families = graph.coverage.families.map(({ family }) => family);
-    if (canonicalJson(families) !==
-        canonicalJson(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES))
+    if (canonicalJson(families, "JavaScript semantic graph") !==
+        canonicalJson(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, "JavaScript semantic graph"))
         context.addIssue({
             code: "custom",
             path: ["coverage", "families"],
@@ -193,7 +184,8 @@ const checkRoots = (graph, nodes, context) => {
 const checkRelations = (graph, nodes, context) => {
     for (const [index, relation] of graph.relations.entries()) {
         const { relation_id: identifier, ...semantic } = relation;
-        if (identifier !== "jsrg_relation_" + digestCanonical(semantic))
+        if (identifier !==
+            "jsrg_relation_" + canonicalDigest(semantic, "JavaScript semantic graph"))
             context.addIssue({
                 code: "custom",
                 path: ["relations", index, "relation_id"],
@@ -224,7 +216,8 @@ const checkRelations = (graph, nodes, context) => {
 const checkUnknowns = (graph, nodes, context) => {
     for (const [index, unknown] of graph.unknowns.entries()) {
         const { unknown_id: identifier, ...semantic } = unknown;
-        if (identifier !== "jsrg_unknown_" + digestCanonical(semantic))
+        if (identifier !==
+            "jsrg_unknown_" + canonicalDigest(semantic, "JavaScript semantic graph"))
             context.addIssue({
                 code: "custom",
                 path: ["unknowns", index, "unknown_id"],
@@ -274,18 +267,19 @@ const checkFingerprints = (graph, nodes, context) => {
                 path: ["fingerprints", index, "function_node_id"],
                 message: "Fingerprint must name a function node",
             });
-        if (fingerprint.fingerprint_sha256 !== digestCanonical(fingerprint.components))
+        if (fingerprint.fingerprint_sha256 !==
+            canonicalDigest(fingerprint.components, "JavaScript semantic graph"))
             context.addIssue({
                 code: "custom",
                 path: ["fingerprints", index, "fingerprint_sha256"],
                 message: "Fingerprint component commitment is stale",
             });
         const expectedIdentifier = "jsrg_fingerprint_" +
-            digestCanonical({
+            canonicalDigest({
                 function_node_id: fingerprint.function_node_id,
                 algorithm: fingerprint.algorithm,
                 fingerprint_sha256: fingerprint.fingerprint_sha256,
-            });
+            }, "JavaScript semantic graph");
         if (fingerprint.fingerprint_id !== expectedIdentifier)
             context.addIssue({
                 code: "custom",
@@ -318,7 +312,8 @@ const checkGraph = (graph, context) => {
             message: "Non-complete graph coverage requires a limitation",
         });
     const { graph_id: identifier, ...semantic } = graph;
-    if (identifier !== "jsrg_" + digestCanonical(semantic))
+    if (identifier !==
+        "jsrg_" + canonicalDigest(semantic, "JavaScript semantic graph"))
         context.addIssue({
             code: "custom",
             path: ["graph_id"],
@@ -339,7 +334,7 @@ export const createJavaScriptSemanticGraph = (input) => {
         unknowns: [...parsed.unknowns].sort((left, right) => compareCodePoints(left.unknown_id, right.unknown_id)),
         coverage: {
             ...parsed.coverage,
-            limits: [...parsed.coverage.limits].sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right))),
+            limits: [...parsed.coverage.limits].sort((left, right) => compareCodePoints(canonicalJson(left, "JavaScript semantic graph"), canonicalJson(right, "JavaScript semantic graph"))),
             families: [...parsed.coverage.families]
                 .map((family) => ({
                 ...family,
@@ -351,6 +346,6 @@ export const createJavaScriptSemanticGraph = (input) => {
     };
     return javaScriptSemanticGraphSchema.parse({
         ...semantic,
-        graph_id: `jsrg_${digestCanonical(semantic)}`,
+        graph_id: `jsrg_${canonicalDigest(semantic, "JavaScript semantic graph")}`,
     });
 };

package/dist/domain/{javascriptSemanticGraphSchemas.js → javascript/javascriptSemanticGraphSchemas.js}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { applicationGraphEvidenceSchema } from "./javascriptApplicationEvidenceSchemas.js";
-import { jsonValueSchema } from "./jsonValue.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { jsonValueSchema } from "../jsonValue.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const boundedTextSchema = z.string().min(1);
 const semanticNodeIdSchema = prefixedDigestSchema("jsrg_node");
 const semanticRelationIdSchema = z

package/dist/domain/javascript/javascriptSemanticMemberMutations.js

@@ -0,0 +1,116 @@
+import * as t from "@babel/types";
+import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { evaluateSemanticBinding } from "./javascriptSemanticValues.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
+/** Keep explicit property mutations outside the initializer-only value lattice. */
+export const collectSemanticMemberMutations = (program, state) => {
+    const markValue = (node, path, bindings) => {
+        if (t.isIdentifier(node)) {
+            const binding = resolveSemanticBindingState(state, node, node.name);
+            if (binding === undefined || bindings.has(binding.bindingId))
+                return;
+            const value = evaluateSemanticBinding(binding, state);
+            if (value.status === "literal" || value.status === "union")
+                return;
+            binding.mutatedPaths.push(path);
+            const nested = new Set([...bindings, binding.bindingId]);
+            for (const initializer of binding.initializers)
+                markValue(initializer.node, [...initializer.projection, ...path], nested);
+            return;
+        }
+        if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+            const members = [];
+            let current = node;
+            while (t.isMemberExpression(current) ||
+                t.isOptionalMemberExpression(current)) {
+                members.push(semanticStaticPropertyKey(current.property, current.computed));
+                current = current.object;
+            }
+            markValue(current, [...members.reverse(), ...path], bindings);
+            return;
+        }
+        for (const value of referencedValues(node, path))
+            markValue(value.node, value.path, bindings);
+    };
+    const markTarget = (node) => {
+        if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
+            markValue(node.object, [semanticStaticPropertyKey(node.property, node.computed)], new Set());
+        else if (t.isRestElement(node))
+            markTarget(node.argument);
+        else if (t.isAssignmentPattern(node))
+            markTarget(node.left);
+        else if (t.isArrayPattern(node)) {
+            for (const element of node.elements)
+                if (element !== null)
+                    markTarget(element);
+        }
+        else if (t.isObjectPattern(node)) {
+            for (const property of node.properties)
+                markTarget(t.isRestElement(property) ? property.argument : property.value);
+        }
+    };
+    traverseJavaScriptAst(program, {
+        enter: (node) => {
+            if (t.isAssignmentExpression(node))
+                markTarget(node.left);
+            else if (t.isUpdateExpression(node))
+                markTarget(node.argument);
+            else if (t.isUnaryExpression(node, { operator: "delete" }))
+                markTarget(node.argument);
+            else if (t.isForOfStatement(node) || t.isForInStatement(node))
+                markTarget(node.left);
+        },
+    });
+};
+const referencedValues = (node, path) => {
+    const [key, ...remaining] = path;
+    // An initializer owns its slots; only deeper writes can affect shared children.
+    if (t.isObjectExpression(node))
+        return path.length < 2
+            ? []
+            : node.properties.flatMap((property) => {
+                if (t.isSpreadElement(property))
+                    return [{ node: property.argument, path }];
+                if (!t.isObjectProperty(property))
+                    return [];
+                const name = semanticStaticPropertyName(property.key, property.computed);
+                return key === null ||
+                    (name === "" && !t.isStringLiteral(property.key, { value: "" })) ||
+                    String(key) === name
+                    ? [{ node: property.value, path: remaining }]
+                    : [];
+            });
+    if (t.isArrayExpression(node)) {
+        if (path.length < 2)
+            return [];
+        let uncertainIndex = false;
+        return node.elements.flatMap((element, index) => {
+            if (element === null)
+                return [];
+            if (t.isSpreadElement(element)) {
+                uncertainIndex = true;
+                return [{ node: element.argument, path: [null, ...remaining] }];
+            }
+            return uncertainIndex || key === null || String(key) === String(index)
+                ? [{ node: element, path: remaining }]
+                : [];
+        });
+    }
+    if (t.isTSAsExpression(node) ||
+        t.isTSTypeAssertion(node) ||
+        t.isTSSatisfiesExpression(node) ||
+        t.isTSNonNullExpression(node))
+        return [{ node: node.expression, path }];
+    if (t.isConditionalExpression(node))
+        return [
+            { node: node.consequent, path },
+            { node: node.alternate, path },
+        ];
+    if (t.isLogicalExpression(node))
+        return [
+            { node: node.left, path },
+            { node: node.right, path },
+        ];
+    return [];
+};

package/dist/domain/javascript/javascriptSemanticMutationValues.js

@@ -0,0 +1,53 @@
+/** Invalidate only slots that an explicit mutation can affect. */
+export const invalidateSemanticMutationPath = (value, path) => {
+    const [key, ...remaining] = path;
+    const unknown = {
+        status: "unknown",
+        reason: "This property may have been mutated.",
+    };
+    if (key === undefined || key === null)
+        return unknown;
+    if (value.status === "object") {
+        const name = String(key);
+        const observed = value.properties.some((property) => property.name === name);
+        const properties = value.properties.map((property) => property.name === name
+            ? {
+                ...property,
+                value: invalidateSemanticMutationPath(property.value, remaining),
+            }
+            : property);
+        return value.unknownProperties || !observed
+            ? {
+                status: "object",
+                properties,
+                unknownProperties: true,
+                omittedProperties: observed ? value.omittedProperties : null,
+            }
+            : {
+                status: "object",
+                properties,
+                unknownProperties: false,
+                omittedProperties: 0,
+            };
+    }
+    if (value.status === "array") {
+        const index = typeof key === "number" ? key : Number(key);
+        if (!Number.isSafeInteger(index) ||
+            index < 0 ||
+            String(index) !== String(key))
+            return unknown;
+        const observed = value.items[index] !== undefined;
+        const items = value.items.map((item, position) => position === index
+            ? invalidateSemanticMutationPath(item, remaining)
+            : item);
+        return value.unknownItems || !observed
+            ? {
+                status: "array",
+                items,
+                unknownItems: true,
+                omittedItems: observed ? value.omittedItems : null,
+            }
+            : { status: "array", items, unknownItems: false, omittedItems: 0 };
+    }
+    return unknown;
+};

package/dist/domain/{javascriptSemanticObjects.js → javascript/javascriptSemanticObjects.js}

@@ -1,5 +1,5 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticReadsBeforeWrite, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticReadsBeforeWrite, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -41,8 +41,8 @@ export const collectJavaScriptSemanticObjects = (program, state, callables) => {
 };
 const collectMember = (node, parent, ownerCallableId, context) => {
     const { state, output } = context;
-    const name = semanticStaticPropertyName(node.property, node.computed);
-    if (name.length === 0)
+    const name = semanticStaticPropertyKey(node.property, node.computed);
+    if (name === null)
         return;
     const write = (t.isAssignmentExpression(parent) && parent.left === node) ||
         (t.isUpdateExpression(parent) && parent.argument === node);
@@ -72,8 +72,8 @@ const collectDestructuring = (node, ownerCallableId, state, output) => {
     for (const property of node.id.properties) {
         if (!t.isObjectProperty(property))
             continue;
-        const name = semanticStaticPropertyName(property.key, property.computed);
-        if (name.length === 0)
+        const name = semanticStaticPropertyKey(property.key, property.computed);
+        if (name === null)
             continue;
         const target = bindingIdentifier(property.value);
         addObjectOperation({

package/dist/domain/{javascriptSemanticPrimitives.js → javascript/javascriptSemanticPrimitives.js}

@@ -1,8 +1,13 @@
 import * as t from "@babel/types";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { semanticPrimitiveKey } from "./javascriptSemanticProvenance.js";
-import { compareCodePoints } from "./javascriptStaticAnalysisHelpers.js";
 /** Normalize one bounded collection of possible primitive values. */
 export const semanticPrimitiveSet = (values) => {
+    if (values.some((value) => typeof value === "number" && !Number.isFinite(value)))
+        return {
+            status: "unknown",
+            reason: "Nonfinite numbers are outside the JSON primitive lattice.",
+        };
     const unique = [
         ...new Map(values.map((value) => [semanticPrimitiveKey(value), value])).values(),
     ].sort((left, right) => compareCodePoints(semanticPrimitiveKey(left), semanticPrimitiveKey(right)));
@@ -19,7 +24,9 @@ export const semanticPrimitiveCandidates = (value) => value.status === "literal"
         : null;
 /** Parse one Babel primitive literal without evaluating code. */
 export const semanticPrimitiveValue = (node) => {
-    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
+    if (t.isStringLiteral(node))
+        return { found: true, value: node.value };
+    if (t.isNumericLiteral(node) && Number.isFinite(node.value))
         return { found: true, value: node.value };
     if (t.isBooleanLiteral(node))
         return { found: true, value: node.value };