rea-agents 6.2.0 → 6.3.0

package/dist/domain/javascript/javascriptSemanticMutationInitializers.js

@@ -0,0 +1,190 @@
+import * as t from "@babel/types";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+const statementPosition = (statement, parents, declarator) => {
+    const parent = parents.get(statement);
+    if (!t.isProgram(parent) && !t.isBlockStatement(parent))
+        return null;
+    const index = parent.body.indexOf(statement);
+    return index < 0
+        ? null
+        : {
+            body: parent.body,
+            index,
+            declaratorIndex: t.isVariableDeclaration(statement) && declarator !== undefined
+                ? statement.declarations.indexOf(declarator)
+                : -1,
+        };
+};
+const positionPrecedes = (left, right) => left.body === right.body &&
+    (left.index < right.index ||
+        (left.index === right.index &&
+            left.declaratorIndex >= 0 &&
+            left.declaratorIndex < right.declaratorIndex));
+const directInitializerPosition = (node, parents) => {
+    const parent = parents.get(node);
+    if (t.isVariableDeclarator(parent) && parent.init === node) {
+        const declaration = parents.get(parent);
+        return t.isVariableDeclaration(declaration)
+            ? statementPosition(declaration, parents, parent)
+            : null;
+    }
+    if (t.isAssignmentExpression(parent) &&
+        parent.operator === "=" &&
+        parent.right === node &&
+        t.isIdentifier(parent.left)) {
+        const statement = parents.get(parent);
+        return t.isExpressionStatement(statement) && statement.expression === parent
+            ? statementPosition(statement, parents)
+            : null;
+    }
+    return null;
+};
+const directMutationPosition = (node, parents) => {
+    if (t.isForOfStatement(node))
+        return statementPosition(node, parents);
+    if (t.isVariableDeclarator(node)) {
+        const declaration = parents.get(node);
+        return t.isVariableDeclaration(declaration)
+            ? statementPosition(declaration, parents, node)
+            : null;
+    }
+    if (t.isSpreadElement(node)) {
+        const array = parents.get(node);
+        return t.isArrayExpression(array)
+            ? semanticCapturePosition(array, parents)
+            : null;
+    }
+    if (!t.isAssignmentExpression(node) &&
+        !t.isUpdateExpression(node) &&
+        !t.isUnaryExpression(node, { operator: "delete" }) &&
+        !t.isCallExpression(node) &&
+        !t.isOptionalCallExpression(node) &&
+        !t.isNewExpression(node) &&
+        !t.isTaggedTemplateExpression(node))
+        return null;
+    let current = node;
+    while (true) {
+        const parent = parents.get(current);
+        if (parent === undefined ||
+            t.isFunction(parent) ||
+            (t.isLogicalExpression(parent) && parent.right === current) ||
+            (t.isConditionalExpression(parent) && parent.test !== current))
+            return null;
+        if (t.isStatement(parent))
+            return statementPosition(parent, parents);
+        if (t.isVariableDeclarator(parent)) {
+            const declaration = parents.get(parent);
+            return t.isVariableDeclaration(declaration)
+                ? statementPosition(declaration, parents, parent)
+                : null;
+        }
+        current = parent;
+    }
+};
+const referenceInitializerPosition = (node, parents) => {
+    // Defaults live inside the declaration pattern rather than its initializer.
+    let current = node;
+    while (true) {
+        const direct = directInitializerPosition(current, parents);
+        if (direct !== null)
+            return direct;
+        const parent = parents.get(current);
+        if (parent === undefined || t.isStatement(parent) || t.isFunction(parent))
+            return null;
+        if (t.isVariableDeclarator(parent)) {
+            const declaration = parents.get(parent);
+            return t.isVariableDeclaration(declaration)
+                ? statementPosition(declaration, parents, parent)
+                : null;
+        }
+        current = parent;
+    }
+};
+/** Resolve origins at their use or capture, never at a later transitive effect. */
+export const semanticMutationInitializers = (binding, mutation, parents) => {
+    const mutationPosition = directMutationPosition(mutation, parents) ??
+        referenceInitializerPosition(mutation, parents);
+    if (mutationPosition === null)
+        return binding;
+    const origins = [
+        ...binding.initializers.map((initializer) => ({
+            initializer,
+            position: initializer.entryBody === undefined
+                ? directInitializerPosition(initializer.node, parents)
+                : {
+                    body: initializer.entryBody.body,
+                    index: -1,
+                    declaratorIndex: -1,
+                },
+        })),
+        ...binding.referenceInitializers.map((initializer) => ({
+            initializer,
+            position: referenceInitializerPosition(initializer.node, parents),
+        })),
+    ];
+    if (origins.some(({ position }) => position === null || !positionPrecedes(position, mutationPosition)))
+        return binding;
+    const latest = origins.reduce((latest, { position }) => position !== null &&
+        (latest === null || positionPrecedes(latest, position))
+        ? position
+        : latest, null);
+    const retained = new Set(origins
+        .filter(({ position }) => position?.index === latest?.index &&
+        position?.declaratorIndex === latest?.declaratorIndex)
+        .map(({ initializer }) => initializer));
+    return {
+        initializers: binding.initializers.filter((initializer) => retained.has(initializer)),
+        referenceInitializers: binding.referenceInitializers.filter((initializer) => retained.has(initializer)),
+    };
+};
+/** Locate a capture only in an unconditional declaration or literal initializer. */
+export const semanticCapturePosition = (node, parents) => {
+    let current = node;
+    while (true) {
+        const direct = directInitializerPosition(current, parents);
+        if (direct !== null)
+            return direct;
+        const parent = parents.get(current);
+        if (t.isObjectProperty(parent) &&
+            parent.value === current &&
+            semanticStaticPropertyKey(parent.key, parent.computed) !== null)
+            current = parent;
+        else if (t.isObjectExpression(parent) || t.isArrayExpression(parent))
+            current = parent;
+        else
+            return null;
+    }
+};
+/** Intermediate values must themselves have been initialized before capture. */
+export const semanticBindingPrecedesCapture = (binding, capture, parents) => {
+    const initializer = binding.initializers[0];
+    if (binding.initializers.length !== 1 || initializer === undefined)
+        return false;
+    const sourcePosition = directInitializerPosition(initializer.node, parents);
+    const capturePosition = semanticCapturePosition(capture, parents);
+    return (sourcePosition !== null &&
+        capturePosition !== null &&
+        positionPrecedes(sourcePosition, capturePosition));
+};
+/** Ignore later escapes only while reading earlier references in one activation. */
+export const semanticEscapeFollowsCapture = (binding, capture, escape, parents) => {
+    const initializer = binding.initializers[0];
+    if (escape === undefined ||
+        initializer === undefined ||
+        !semanticBindingPrecedesCapture(binding, capture, parents))
+        return false;
+    // A literal allocates here. Aliases are evaluated at the same capture point,
+    // so an outer/persistent origin still receives all of its own escape effects.
+    const origin = unwrapJavaScriptExpression(initializer.node).node;
+    if (!t.isObjectExpression(origin) &&
+        !t.isArrayExpression(origin) &&
+        !t.isIdentifier(origin) &&
+        !t.isMemberExpression(origin) &&
+        !t.isOptionalMemberExpression(origin))
+        return false;
+    const capturePosition = semanticCapturePosition(capture, parents);
+    const escapePosition = directMutationPosition(escape, parents);
+    return (capturePosition !== null &&
+        escapePosition !== null &&
+        positionPrecedes(capturePosition, escapePosition));
+};

package/dist/domain/javascript/javascriptSemanticMutationValues.js

@@ -1,3 +1,24 @@
+import { semanticPropertyPathKeyMatches, } from "./javascriptSemanticPropertyPaths.js";
+/** Invalidate escaped object references without rewriting their containing slots. */
+export const invalidateSemanticEscapedPath = (value, path) => {
+    if (value.status !== "object" && value.status !== "array")
+        return value;
+    const [key, ...remaining] = path;
+    if (key === undefined)
+        return {
+            status: "unknown",
+            reason: "This object reference may have been mutated by a call.",
+        };
+    const invalidateChild = (property) => semanticPropertyPathKeyMatches(key, property.name)
+        ? {
+            ...property,
+            value: invalidateSemanticEscapedPath(property.value, remaining),
+        }
+        : property;
+    return value.status === "object"
+        ? { ...value, properties: value.properties.map(invalidateChild) }
+        : { ...value, items: value.items.map(invalidateChild) };
+};
 /** Invalidate only slots that an explicit mutation can affect. */
 export const invalidateSemanticMutationPath = (value, path) => {
     const [key, ...remaining] = path;
@@ -7,10 +28,17 @@ export const invalidateSemanticMutationPath = (value, path) => {
     };
     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
+    if (value.status === "object" || value.status === "array") {
+        if (value.status === "array" && key === "length")
+            return {
+                status: "array",
+                items: [],
+                unknownItems: true,
+                omittedItems: null,
+            };
+        const slots = value.status === "object" ? value.properties : value.items;
+        const observed = slots.some((property) => semanticPropertyPathKeyMatches(key, property.name));
+        const properties = slots.map((property) => semanticPropertyPathKeyMatches(key, property.name)
             ? {
                 ...property,
                 ...(remaining.length === 0
@@ -19,29 +47,15 @@ export const invalidateSemanticMutationPath = (value, path) => {
                 value: invalidateSemanticMutationPath(property.value, remaining),
             }
             : property);
-        if (!observed)
-            properties.push({ name, value: unknown, presence: "unknown-coverage" });
-        return { ...value, properties };
-    }
-    if (value.status === "array") {
-        const name = String(key);
-        // Array length writes can remove every index; ordinary named properties
-        // and sparse indices affect only their own slot.
-        if (name === "length")
-            return unknown;
-        const observed = value.items.some((item) => item.name === name);
-        const items = value.items.map((item) => item.name === name
-            ? {
-                ...item,
-                presence: remaining.length === 0
-                    ? "unknown-coverage"
-                    : item.presence,
-                value: invalidateSemanticMutationPath(item.value, remaining),
-            }
-            : item);
-        if (!observed)
-            items.push({ name, presence: "unknown-coverage", value: unknown });
-        return { ...value, items };
+        if (!observed && typeof key !== "object")
+            properties.push({
+                name: String(key),
+                value: unknown,
+                presence: "unknown-coverage",
+            });
+        return value.status === "object"
+            ? { ...value, properties }
+            : { ...value, items: properties };
     }
     return unknown;
 };

package/dist/domain/javascript/javascriptSemanticObjects.js

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { semanticCallableIdForNode, semanticReadsBeforeWrite, } from "./javascriptSemanticProjection.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -128,6 +128,7 @@ const expressionObjectIdentity = (node, state) => {
     let current = node;
     let staticPath = true;
     while (current !== null && current !== undefined) {
+        current = unwrapJavaScriptExpression(current).node;
         if (t.isMemberExpression(current) ||
             t.isOptionalMemberExpression(current)) {
             const name = semanticStaticPropertyKey(current.property, current.computed);
@@ -137,11 +138,6 @@ const expressionObjectIdentity = (node, state) => {
                 path.push(name);
             current = current.object;
         }
-        else if (t.isTSAsExpression(current) ||
-            t.isTSTypeAssertion(current) ||
-            t.isTSNonNullExpression(current) ||
-            t.isTSSatisfiesExpression(current))
-            current = current.expression;
         else
             break;
     }

package/dist/domain/javascript/javascriptSemanticPrimitives.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticPrimitiveKey } from "./javascriptSemanticProvenance.js";
 import { SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveStringByteBudget, semanticResourceLimitUnknown, } from "./javascriptSemanticResourceLimits.js";
 /** Normalize one bounded collection of possible primitive values. */
@@ -10,6 +10,11 @@ export const semanticPrimitiveSet = (values) => {
                 status: "unknown",
                 reason: "Nonfinite numbers are outside the JSON primitive lattice.",
             };
+        if (typeof value === "number" && Object.is(value, -0))
+            return {
+                status: "unknown",
+                reason: "Negative zero cannot be preserved by JSON primitive evidence.",
+            };
         uniqueValues.add(value);
         if (uniqueValues.size > SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT)
             return semanticResourceLimitUnknown("primitive-candidates");
@@ -18,7 +23,7 @@ export const semanticPrimitiveSet = (values) => {
         return semanticResourceLimitUnknown("primitive-bytes");
     const unique = [...uniqueValues]
         .map((value) => ({ key: semanticPrimitiveKey(value), value }))
-        .sort((left, right) => compareCodePoints(left.key, right.key))
+        .sort((left, right) => compareUnicodeCodePoints(left.key, right.key))
         .map(({ value }) => value);
     const only = unique[0];
     return unique.length === 1 && only !== undefined

package/dist/domain/javascript/javascriptSemanticProjection.js

@@ -1,10 +1,10 @@
 import * as t from "@babel/types";
 import { resolveSemanticBindingState, semanticResolutionBlocked, isUnshadowedGlobal, } from "./javascriptSemanticState.js";
 import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { evaluateSemanticBinding, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js";
-import { range, stringValue } from "./javascriptStaticAnalysisHelpers.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { propertyName, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
 /** Retain callable identity without polluting lexical bindings. */
 export const collectSemanticCallable = (input) => {
@@ -43,7 +43,7 @@ export const collectSemanticModuleLink = (node, state) => {
             localName: null,
             exportedName: "*",
             location: range(node),
-        });
+        }, node);
     else if (t.isExportNamedDeclaration(node))
         collectNamedExports(node, state);
     else if (t.isExportDefaultDeclaration(node))
@@ -55,7 +55,7 @@ export const collectSemanticModuleLink = (node, state) => {
             exportedName: "default",
             callableId: semanticCallableIdForNode(node.declaration),
             location: range(node),
-        });
+        }, node);
     else if (t.isVariableDeclarator(node))
         collectRequireLink(node, state);
     else if (t.isAssignmentExpression(node))
@@ -121,7 +121,7 @@ export const immutableSemanticScopes = (state) => state.scopes.map((scope) => ({
     bindingsComplete: scope.bindingsComplete,
     bindingIds: [...scope.bindings.values()]
         .map(({ bindingId }) => bindingId)
-        .sort(compareCodePoints),
+        .sort(compareUnicodeCodePoints),
 }));
 /** Evaluate and freeze bindings into deterministic IR order. */
 export const immutableSemanticBindings = (state) => [...state.bindingsById.values()]
@@ -135,7 +135,7 @@ export const immutableSemanticBindings = (state) => [...state.bindingsById.value
     value: evaluateSemanticBinding(binding, state),
     provenance: evaluateSemanticProvenance(binding, state),
 }))
-    .sort((left, right) => compareCodePoints(left.bindingId, right.bindingId));
+    .sort((left, right) => compareUnicodeCodePoints(left.bindingId, right.bindingId));
 const callableKind = (node) => {
     if (t.isClassMethod(node) ||
         t.isClassPrivateMethod(node) ||
@@ -180,7 +180,7 @@ const collectImports = (node, state) => {
             localName: null,
             exportedName: null,
             location: range(node),
-        });
+        }, node);
     for (const specifier of node.specifiers)
         addModuleLink(state, {
             kind: "import",
@@ -193,7 +193,7 @@ const collectImports = (node, state) => {
             localName: specifier.local.name,
             exportedName: null,
             location: range(specifier),
-        });
+        }, node);
 };
 const collectNamedExports = (node, state) => {
     if (node.declaration !== null && node.declaration !== undefined)
@@ -206,7 +206,7 @@ const collectNamedExports = (node, state) => {
                 exportedName: localName,
                 callableId: declarationCallableId(node.declaration, localName),
                 location: range(node.declaration),
-            });
+            }, node);
     for (const specifier of node.specifiers)
         if (t.isExportSpecifier(specifier))
             addModuleLink(state, {
@@ -216,7 +216,7 @@ const collectNamedExports = (node, state) => {
                 localName: node.source == null ? propertyName(specifier.local) : null,
                 exportedName: propertyName(specifier.exported),
                 location: range(specifier),
-            });
+            }, node);
 };
 const collectRequireLink = (node, state) => {
     const origin = semanticRequireOrigin(node.init, state);
@@ -230,7 +230,7 @@ const collectRequireLink = (node, state) => {
             localName: binding.localName,
             exportedName: null,
             location: range(node),
-        });
+        }, node);
 };
 const requirePatternBindings = (pattern, path) => {
     if (t.isTSParameterProperty(pattern))
@@ -267,10 +267,16 @@ const collectCommonJsExport = (node, state) => {
         exportedName,
         callableId: semanticCallableIdForNode(node.right),
         location: range(node),
-    });
+    }, node);
 };
-const addModuleLink = (state, link) => {
-    state.moduleLinks.push({ ...link, callableId: link.callableId ?? null });
+const addModuleLink = (state, link, referenceNode) => {
+    const collected = { ...link, callableId: link.callableId ?? null };
+    state.moduleLinks.push(collected);
+    if (link.localName !== null) {
+        const binding = resolveSemanticBindingState(state, referenceNode, link.localName);
+        if (binding !== undefined)
+            state.moduleLinkBindings.set(collected, binding);
+    }
 };
 /** Deterministic callable identity shared by collection and return recovery. */
 export const semanticCallableIdForNode = (node) => {

package/dist/domain/javascript/javascriptSemanticPromises.js

@@ -1,8 +1,8 @@
 import * as t from "@babel/types";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
-import { semanticStaticPropertyName } from "./javascriptAstValues.js";
+import { semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { assignedSemanticResultBindings, dataEffectMemberCallee, scalarAssignedResultBinding, } from "./javascriptSemanticDataEffectHelpers.js";
@@ -23,7 +23,7 @@ export const collectJavaScriptSemanticPromises = (program, state, callables) =>
             location: range(candidate.node),
             ownerCallableId: candidate.ownerCallableId,
             ...ownership,
-            sourcePromiseIds: [...new Set(sources.promiseIds)].sort(compareCodePoints),
+            sourcePromiseIds: [...new Set(sources.promiseIds)].sort(compareUnicodeCodePoints),
             sourceResolution: sources.status,
         };
     });
@@ -85,7 +85,8 @@ const promiseCandidateDetails = (node, state) => {
 };
 const isUnshadowedGlobalPromise = (node, state) => resolveSemanticBindingState(state, node, "Promise") === undefined &&
     !semanticResolutionBlocked(state, node, "Promise");
-const isPromiseProducer = (node, state) => promiseCandidateDetails(unwrapExpression(node), state) !== null;
+const isPromiseProducer = (node, state) => promiseCandidateDetails(unwrapJavaScriptExpression(node).node, state) !==
+    null;
 const semanticPromiseId = (kind, node) => `promise:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;
 const promiseOwnership = (candidate, candidateByNode, state, returnSiteIdFor) => {
     if (candidate.kind === "awaited-expression")
@@ -111,7 +112,7 @@ const promiseOwnership = (candidate, candidateByNode, state, returnSiteIdFor) =>
 const ownershipAtAncestor = (ancestor, context) => {
     const { candidate, candidateByNode, state, returnSiteIdFor } = context;
     if (t.isAwaitExpression(ancestor))
-        return unwrapExpression(ancestor.argument) === candidate.node
+        return unwrapJavaScriptExpression(ancestor.argument).node === candidate.node
             ? emptyOwnership("awaited")
             : "boundary";
     const outer = candidateByNode.get(ancestor);
@@ -132,19 +133,20 @@ const ownershipAtAncestor = (ancestor, context) => {
         };
     if (t.isReturnStatement(ancestor)) {
         if (ancestor.argument == null ||
-            unwrapExpression(ancestor.argument) !== candidate.node)
+            unwrapJavaScriptExpression(ancestor.argument).node !== candidate.node)
             return "boundary";
         return returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor), returnSiteIdFor);
     }
     if (t.isExpressionStatement(ancestor))
-        return unwrapExpression(ancestor.expression) === candidate.node
+        return unwrapJavaScriptExpression(ancestor.expression).node ===
+            candidate.node
             ? emptyOwnership("detached")
             : "boundary";
     const callableId = semanticCallableIdForNode(ancestor);
     if (callableId === null || callableId !== candidate.ownerCallableId)
         return null;
     return t.isArrowFunctionExpression(ancestor) &&
-        unwrapExpression(ancestor.body) === candidate.node
+        unwrapJavaScriptExpression(ancestor.body).node === candidate.node
         ? returnedPromiseOwnership(candidate.ownerCallableId, range(ancestor.body), returnSiteIdFor)
         : "boundary";
 };
@@ -160,7 +162,7 @@ const assignedPromiseBinding = (ancestor, candidate, state) => {
         : ancestor.right;
     if (source == null)
         return undefined;
-    if (unwrapExpression(source) !== candidate)
+    if (unwrapJavaScriptExpression(source).node !== candidate)
         return undefined;
     return scalarAssignedResultBinding(assignedSemanticResultBindings(source, [ancestor], state));
 };
@@ -173,7 +175,8 @@ const outerConsumesCandidate = (outer, candidate) => {
     if (outer.kind === "chain" &&
         (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
         const member = dataEffectMemberCallee(outer.node);
-        return (member !== null && unwrapExpression(member.object) === candidate.node);
+        return (member !== null &&
+            unwrapJavaScriptExpression(member.object).node === candidate.node);
     }
     if (outer.kind === "aggregate" &&
         (t.isCallExpression(outer.node) || t.isOptionalCallExpression(outer.node))) {
@@ -181,7 +184,7 @@ const outerConsumesCandidate = (outer, candidate) => {
         return (t.isArrayExpression(input) &&
             input.elements.some((element) => element !== null &&
                 !t.isSpreadElement(element) &&
-                unwrapExpression(element) === candidate.node));
+                unwrapJavaScriptExpression(element).node === candidate.node));
     }
     return false;
 };
@@ -266,7 +269,7 @@ const aggregateSources = (candidate, candidateByNode, state) => {
 };
 const resolvePromiseExpression = (rawNode, context) => {
     const { current, candidateByNode, state, seenBindings } = context;
-    const node = unwrapExpression(rawNode);
+    const node = unwrapJavaScriptExpression(rawNode).node;
     const direct = candidateByNode.get(node);
     if (direct !== undefined && direct.promiseId !== current.promiseId)
         return { promiseIds: [direct.promiseId], status: "complete" };
@@ -294,15 +297,6 @@ const promiseResolutionContext = (current, candidateByNode, state) => ({
     state,
     seenBindings: new Set(),
 });
-const unwrapExpression = (node) => {
-    if (t.isParenthesizedExpression(node) ||
-        t.isTSAsExpression(node) ||
-        t.isTSSatisfiesExpression(node) ||
-        t.isTSNonNullExpression(node) ||
-        t.isTypeCastExpression(node))
-        return unwrapExpression(node.expression);
-    return node;
-};
 const combinePromiseResolutions = (resolutions) => ({
     promiseIds: resolutions.flatMap(({ promiseIds }) => promiseIds),
     status: resolutions.some(({ status }) => status === "unresolved")

package/dist/domain/javascript/javascriptSemanticPropertyPaths.js

@@ -0,0 +1,23 @@
+/** Read only canonical JavaScript array indices, excluding named properties. */
+export const semanticArrayIndex = (key) => {
+    const index = Number(key);
+    return Number.isInteger(index) &&
+        index >= 0 &&
+        index < 4_294_967_295 &&
+        String(index) === String(key)
+        ? index
+        : null;
+};
+/** Test an exact key, wildcard, or copied-slot selection against an own key. */
+export const semanticPropertyPathKeyMatches = (key, name) => {
+    if (key === null)
+        return true;
+    if (typeof key !== "object")
+        return String(key) === name;
+    if (key.excludedKeys.includes(name))
+        return false;
+    if (key.startIndex === undefined)
+        return true;
+    const index = semanticArrayIndex(name);
+    return index !== null && index >= key.startIndex;
+};

package/dist/domain/javascript/javascriptSemanticProvenance.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Construct exact local provenance without inventing module origins. */
 export const semanticLocalProvenance = () => ({
     status: "local",
@@ -20,8 +20,8 @@ export const semanticOriginsProvenance = (origins) => {
 /** Deduplicate and canonically order module origins. */
 export const uniqueSemanticOrigins = (origins) => [
     ...new Map(origins.map((origin) => [semanticOriginKey(origin), origin])).values(),
-].sort((left, right) => compareCodePoints(semanticOriginKey(left), semanticOriginKey(right)));
-const semanticOriginKey = (origin) => `${origin.specifier}\0${origin.importedPath.join("\0")}`;
+].sort((left, right) => compareUnicodeCodePoints(semanticOriginKey(left), semanticOriginKey(right)));
+const semanticOriginKey = (origin) => JSON.stringify([origin.specifier, origin.importedPath]);
 /** Canonically distinguish primitive values across type boundaries. */
 export const semanticPrimitiveKey = (value) => `${value === null ? "null" : typeof value}:${JSON.stringify(value)}`;
 /** Match namespace paths only after the caller has identified a Node built-in. */

package/dist/domain/javascript/javascriptSemanticQuery.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { isJavaScriptSemanticOwnershipRelation as ownershipRelation } from "./javascriptSemanticQueryRelations.js";
 import { javaScriptSemanticQueryInputSchema, javaScriptSemanticQueryResultSchema, } from "./javascriptSemanticQuerySchemas.js";
 import { assessJavaScriptSemanticQuery } from "./javascriptSemanticQueryAssessment.js";
@@ -17,6 +17,11 @@ export const queryJavaScriptSemanticGraph = (graph, rawInput) => {
     const relevantUnknowns = allRelevantUnknowns;
     const candidateRelations = relevantCandidateRelationCount(graph, traversal.nodeIds, input);
     const expectedMatches = expectedMatchesFor(result.retainedNodes, result.retainedRelations, input);
+    const retainedContextIds = new Set([
+        ...result.retainedNodes.map(({ evidence }) => evidence.context_id),
+        ...result.retainedRelations.map(({ evidence }) => evidence.context_id),
+        ...relevantUnknowns.map(({ evidence }) => evidence.context_id),
+    ]);
     const assessment = assessJavaScriptSemanticQuery({
         graph,
         totalSeeds: seeds.length,
@@ -32,6 +37,7 @@ export const queryJavaScriptSemanticGraph = (graph, rawInput) => {
         direction: input.direction,
         status: assessment.status,
         seed_node_ids: retainedSeeds,
+        evidence_contexts: graph.evidence_contexts.filter(({ context_id }) => retainedContextIds.has(context_id)),
         nodes: result.retainedNodes,
         relations: result.retainedRelations,
         unknowns: relevantUnknowns,
@@ -78,7 +84,7 @@ const buildAdjacency = (relations, input) => {
         addDirectedEntries(adjacency, relation, input.direction);
     }
     for (const entries of adjacency.values())
-        entries.sort((left, right) => compareCodePoints(`${left.relation.relation_id}\0${left.nextNodeId}`, `${right.relation.relation_id}\0${right.nextNodeId}`));
+        entries.sort((left, right) => compareUnicodeCodePoints(`${left.relation.relation_id}\0${left.nextNodeId}`, `${right.relation.relation_id}\0${right.nextNodeId}`));
     return adjacency;
 };
 const addDirectedEntries = (adjacency, relation, direction) => {

package/dist/domain/javascript/javascriptSemanticQueryIdentity.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Canonical JSON used by semantic query commitments and ordering. */
 export const canonicalJavaScriptSemanticQueryJson = (value) => {
     const encoded = canonicalize(value);
@@ -39,7 +40,7 @@ export const resolveJavaScriptSemanticQuerySeeds = (graph, input) => {
     return graph.nodes
         .filter((node) => seedMatches(node, input, fingerprintFunctions))
         .map(({ node_id }) => node_id)
-        .sort(compareCodePoints);
+        .sort(compareUnicodeCodePoints);
 };
 const seedMatches = (node, input, fingerprintFunctions) => {
     const seed = input.seed;