rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptRuntimeStaticCandidates.js

@@ -1,11 +1,11 @@
 import { posix, relative, win32 } from "node:path";
-import {} from "./javascriptApplicationGraph.js";
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Index statically reconstructed entities that can receive runtime matches. */
 export const collectStaticRuntimeCandidates = (layers) => layers
     .flatMap((layer) => candidatesForLayer(layer))
-    .sort((left, right) => compareCodePoints(left.layer.layerId, right.layer.layerId) ||
-    compareCodePoints(left.node.node_id, right.node.node_id));
+    .sort((left, right) => compareUnicodeCodePoints(left.layer.layerId, right.layer.layerId) ||
+    compareUnicodeCodePoints(left.node.node_id, right.node.node_id));
 /** Translate one already-authorized runtime location into artifact paths. */
 export const mappedRuntimePaths = (layer, entity) => {
     const paths = [];
@@ -187,7 +187,7 @@ const activeArtifactPrefixes = (layer, entities) => {
                 ? pathBelowUrlPrefix(mapping.prefix, location.value) !== null
                 : false))
             prefixes.add(mapping.artifact_prefix);
-    return [...prefixes].sort(compareCodePoints);
+    return [...prefixes].sort(compareUnicodeCodePoints);
 };
 const pathWithinPrefix = (path, prefix) => prefix === "" || path === prefix || path.startsWith(`${prefix}/`);
 const safeArtifactPath = (prefix, suffix) => normalizeArtifactPath(prefix === "" ? suffix : posix.join(prefix, suffix));
@@ -205,5 +205,5 @@ const normalizeArtifactPath = (value) => {
 };
 const uniqueMappedPaths = (values) => [
     ...new Map(values.map((value) => [`${value.basis}:${value.path}`, value])).values(),
-].sort((left, right) => compareCodePoints(left.path, right.path) ||
-    compareCodePoints(left.basis, right.basis));
+].sort((left, right) => compareUnicodeCodePoints(left.path, right.path) ||
+    compareUnicodeCodePoints(left.basis, right.basis));

package/dist/domain/javascript/javascriptSemanticAnalysis.js

@@ -1,12 +1,14 @@
 import * as t from "@babel/types";
 import { failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
-import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.js";
+import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
 import { currentSemanticScope, resolveSemanticBindingState, semanticResolutionBlocked, resolveSemanticBindingFromScope, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { collectSemanticMemberMutations } from "./javascriptSemanticMemberMutations.js";
 import { collectSemanticReturns, resolveSemanticModuleCallables, } from "./javascriptSemanticReturns.js";
 import { collectJavaScriptDerivedSemantics } from "./javascriptSemanticDerivedAnalysis.js";
-import { propertyName, range } from "./javascriptStaticAnalysisHelpers.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { propertyName } from "./javascriptAstValues.js";
 import { semanticCoverage } from "./javascriptSemanticCoverage.js";
 import { semanticResourceLimitsIn } from "./javascriptSemanticResourceLimits.js";
 import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
@@ -164,6 +166,7 @@ const createState = (program) => {
         bindings: new Map(),
     };
     return {
+        parentsByNode: new WeakMap(),
         scopes: [root],
         scopesById: new Map([[root.scopeId, root]]),
         scopeByNode: new WeakMap([[program, root]]),
@@ -171,6 +174,8 @@ const createState = (program) => {
         callables: [],
         callableNodesById: new Map(),
         moduleLinks: [],
+        moduleLinkBindings: new WeakMap(),
+        conditionalInitializers: new WeakSet(),
     };
 };
 const collectDefinitions = (program, state) => {
@@ -178,9 +183,25 @@ const collectDefinitions = (program, state) => {
         currentSemanticScope(state.scopes),
     ];
     const openedScopes = new WeakMap();
+    const assignments = [];
+    const functionBodies = [];
     traverseJavaScriptAst(program, {
-        enter: (node, parent) => {
+        enter: (node, parent, readAncestors) => {
             let parentScope = currentSemanticScope(stack);
+            if (parent !== null &&
+                (t.isObjectMethod(parent) || t.isClassMethod(parent)) &&
+                parent.computed &&
+                parent.key === node &&
+                parentScope.parentScopeId !== null) {
+                // A computed method key is evaluated before entering the method's
+                // parameter and body environments.
+                const keyScope = state.scopesById.get(parentScope.parentScopeId);
+                if (keyScope !== undefined) {
+                    stack.push(keyScope);
+                    openedScopes.set(node, 1);
+                    parentScope = keyScope;
+                }
+            }
             if (parent !== null &&
                 t.isWithStatement(parent) &&
                 parent.body === node) {
@@ -203,6 +224,12 @@ const collectDefinitions = (program, state) => {
             if (nested !== undefined) {
                 stack.push(nested);
                 openedScopes.set(node, (openedScopes.get(node) ?? 0) + 1);
+                if (t.isBlockStatement(node) && t.isFunction(parent))
+                    functionBodies.push({
+                        body: node,
+                        scope: nested,
+                        parameters: parent.params,
+                    });
             }
             const scope = currentSemanticScope(stack);
             state.scopeByNode.set(node, scope);
@@ -214,12 +241,73 @@ const collectDefinitions = (program, state) => {
                 state,
             });
             bindInnerDeclaration(node, parent, scope, state);
+            if (t.isVariableDeclarator(node) &&
+                node.init != null &&
+                parent !== null &&
+                t.isVariableDeclaration(parent, { kind: "var" }) &&
+                hasConditionalInitializer(readAncestors()))
+                state.conditionalInitializers.add(node.init);
+            if (t.isAssignmentExpression(node) ||
+                t.isUpdateExpression(node) ||
+                t.isForOfStatement(node) ||
+                t.isForInStatement(node))
+                assignments.push({ node, scope });
         },
         exit: (node) => {
             for (let count = openedScopes.get(node) ?? 0; count > 0; count--)
                 stack.pop();
         },
     });
+    // All declarations must exist before resolving writes, including hoisted
+    // functions and local declarations that shadow an outer binding.
+    for (const { node, scope } of assignments)
+        bindAssignment(node, scope, state);
+    for (const { body, scope, parameters } of functionBodies)
+        for (const parameter of parameters)
+            for (const identifier of assignedPatternIdentifiers(t.isTSParameterProperty(parameter) ? parameter.parameter : parameter))
+                copyParameterToBody({ identifier, body, scope, state });
+};
+const copyParameterToBody = (input) => {
+    const { identifier, body, scope, state } = input;
+    const binding = scope.bindings.get(identifier.name);
+    if (binding === undefined ||
+        binding.kind !== "variable" ||
+        binding.definitions.some(({ kind }) => kind === "function"))
+        return;
+    // A separate body var environment starts with the parameter's value. The
+    // real parameter identifier retains its scope and source location; entryBody
+    // records when the copy occurs without inventing an expression in the AST.
+    binding.initializers.unshift({
+        node: identifier,
+        projection: [],
+        entryBody: body,
+    });
+    for (let index = binding.initializers.length - 1; index >= 0; index -= 1) {
+        const initializer = binding.initializers[index];
+        if (initializer !== undefined &&
+            initializer.entryBody === undefined &&
+            initializer.projection.length === 0 &&
+            t.isIdentifier(initializer.node) &&
+            resolveSemanticBindingState(state, initializer.node, initializer.node.name) === binding)
+            // Direct self-initialization preserves the prior value, including any
+            // actual overwrite before it. Keep the source definition/reference facts.
+            binding.initializers.splice(index, 1);
+    }
+};
+const hasConditionalInitializer = (ancestors) => {
+    // A hoisted var can remain undefined when control flow skips its initializer.
+    // Conditions outside the owning callable/static block do not govern its body.
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+        const node = ancestors[index];
+        if (t.isFunction(node) || t.isProgram(node) || t.isStaticBlock(node))
+            return false;
+        if (t.isIfStatement(node) ||
+            t.isLoop(node) ||
+            t.isSwitchCase(node) ||
+            t.isTryStatement(node))
+            return true;
+    }
+    return false;
 };
 const bindOuterDeclaration = (node, scope, state) => {
     if (t.isFunctionDeclaration(node) && t.isIdentifier(node.id))
@@ -277,9 +365,15 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
             mutable: true,
             kind: "catch",
         });
-    else if (t.isAssignmentExpression(node)) {
+};
+const bindAssignment = (node, scope, state) => {
+    if (t.isAssignmentExpression(node)) {
         if (t.isIdentifier(node.left))
-            addAssignment(node.left, node.right, scope, state);
+            addAssignment(node.left, node.operator === "=" ||
+                node.operator === "||=" ||
+                node.operator === "??="
+                ? node.right
+                : node, scope, state);
         else
             for (const identifier of assignedPatternIdentifiers(node.left))
                 addAssignment(identifier, node, scope, state);
@@ -287,8 +381,11 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
     else if (t.isUpdateExpression(node) && t.isIdentifier(node.argument))
         addAssignment(node.argument, node, scope, state);
     else if (t.isForOfStatement(node) || t.isForInStatement(node))
-        for (const identifier of assignedPatternIdentifiers(node.left))
-            addAssignment(identifier, node, scope, state);
+        for (const pattern of t.isVariableDeclaration(node.left)
+            ? node.left.declarations.map(({ id }) => id)
+            : [node.left])
+            for (const identifier of assignedPatternIdentifiers(pattern))
+                addAssignment(identifier, node, scope, state);
 };
 const assignedPatternIdentifiers = (pattern) => {
     const identifiers = [];
@@ -386,10 +483,47 @@ const scopeKind = (node, parent) => {
     if (t.isStaticBlock(node))
         return "static-block";
     if (t.isBlockStatement(node) &&
-        !(parent !== null && t.isFunction(parent) && parent.body === node))
+        parent !== null &&
+        t.isFunction(parent) &&
+        parent.body === node) {
+        // Parameter expressions cannot see declarations in the function body.
+        // Retain the outer function scope for parameters and callable ownership;
+        // body declarations belong to a separate variable environment.
+        return functionParametersHaveExpressions(parent) ? "function" : undefined;
+    }
+    if (t.isBlockStatement(node))
         return "block";
     return undefined;
 };
+const functionParametersHaveExpressions = (node) => {
+    const pending = [...node.params];
+    while (pending.length > 0) {
+        const parameter = pending.pop();
+        if (t.isAssignmentPattern(parameter))
+            return true;
+        if (t.isTSParameterProperty(parameter))
+            pending.push(parameter.parameter);
+        else if (t.isRestElement(parameter))
+            pending.push(parameter.argument);
+        else if (t.isArrayPattern(parameter)) {
+            for (const element of parameter.elements)
+                if (element !== null)
+                    pending.push(element);
+        }
+        else if (t.isObjectPattern(parameter)) {
+            for (const property of parameter.properties) {
+                if (t.isRestElement(property))
+                    pending.push(property.argument);
+                else {
+                    if (property.computed)
+                        return true;
+                    pending.push(property.value);
+                }
+            }
+        }
+    }
+    return false;
+};
 const bindImports = (node, scope, state) => {
     for (const specifier of node.specifiers) {
         const importedPath = t.isImportDefaultSpecifier(specifier)
@@ -423,12 +557,29 @@ const bindFunctionLocals = (node, scope, state) => {
         });
 };
 const bindPattern = (input) => {
-    const { pattern, initializer, scope, state, mutable, kind = "variable", projection = [], } = input;
+    const { pattern, initializer, scope, state, mutable, kind = "variable", projection = [], referenceOnly = false, copyKind, copyProjectionOffset, copyExcludedKeys, copyStartIndex, fallbackSources, requiredSources, } = input;
     if (t.isTSParameterProperty(pattern)) {
         bindPattern({ ...input, pattern: pattern.parameter });
         return;
     }
     if (t.isIdentifier(pattern)) {
+        if (referenceOnly) {
+            const binding = scope.bindings.get(pattern.name);
+            if (binding !== undefined && initializer !== null)
+                binding.referenceInitializers.push({
+                    node: initializer,
+                    projection,
+                    ...(copyKind === undefined ? {} : { copyKind }),
+                    ...(copyProjectionOffset === undefined
+                        ? {}
+                        : { copyProjectionOffset }),
+                    ...(copyExcludedKeys === undefined ? {} : { copyExcludedKeys }),
+                    ...(copyStartIndex === undefined ? {} : { copyStartIndex }),
+                    ...(fallbackSources === undefined ? {} : { fallbackSources }),
+                    ...(requiredSources === undefined ? {} : { requiredSources }),
+                });
+            return;
+        }
         addBinding({
             state,
             scope,
@@ -448,6 +599,25 @@ const bindPattern = (input) => {
             initializer: kind === "parameter" || kind === "catch"
                 ? initializer
                 : (initializer ?? pattern.right),
+            requiredSources: [
+                ...(requiredSources ?? []),
+                ...(initializer === null ? [] : [{ node: initializer, projection }]),
+            ],
+        });
+        bindPattern({
+            state,
+            scope,
+            mutable,
+            kind,
+            pattern: pattern.left,
+            initializer: pattern.right,
+            projection: [],
+            referenceOnly: true,
+            fallbackSources: [
+                ...(fallbackSources ?? []),
+                ...(initializer === null ? [] : [{ node: initializer, projection }]),
+            ],
+            ...(requiredSources === undefined ? {} : { requiredSources }),
         });
         return;
     }
@@ -462,7 +632,7 @@ const bindPattern = (input) => {
     }
     if (t.isObjectPattern(pattern))
         for (const property of pattern.properties) {
-            if (t.isRestElement(property))
+            if (t.isRestElement(property)) {
                 bindPattern({
                     ...input,
                     pattern: property.argument,
@@ -470,6 +640,21 @@ const bindPattern = (input) => {
                     mutable: true,
                     projection: [],
                 });
+                bindPattern({
+                    ...input,
+                    pattern: property.argument,
+                    projection: [...projection, null],
+                    referenceOnly: true,
+                    copyKind: "object-rest",
+                    copyProjectionOffset: projection.length,
+                    copyExcludedKeys: pattern.properties.flatMap((property) => {
+                        if (t.isRestElement(property))
+                            return [];
+                        const key = semanticStaticPropertyKey(property.key, property.computed);
+                        return key === null ? [] : [key];
+                    }),
+                });
+            }
             else {
                 const name = semanticStaticPropertyKey(property.key, property.computed);
                 bindPattern({
@@ -481,12 +666,23 @@ const bindPattern = (input) => {
         }
     else if (t.isArrayPattern(pattern))
         pattern.elements.forEach((element, index) => {
-            if (element !== null)
+            if (element !== null) {
                 bindPattern({
                     ...input,
                     pattern: element,
                     projection: [...projection, index],
                 });
+                if (t.isRestElement(element))
+                    bindPattern({
+                        ...input,
+                        pattern: element.argument,
+                        projection: [...projection, null],
+                        referenceOnly: true,
+                        copyKind: "array-rest",
+                        copyProjectionOffset: projection.length,
+                        copyStartIndex: index,
+                    });
+            }
         });
 };
 const addBinding = (input) => {
@@ -513,8 +709,10 @@ const createBinding = (scope, name, kind, mutable) => ({
     kind,
     mutable,
     mutatedPaths: [],
+    escapedPaths: [],
     definitions: [],
     initializers: [],
+    referenceInitializers: [],
     directOrigins: [],
 });
 const addAssignment = (identifier, initializer, scope, state) => {

package/dist/domain/javascript/javascriptSemanticAsyncEffects.js

@@ -1,6 +1,7 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
-import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";

package/dist/domain/javascript/javascriptSemanticCallResolution.js

@@ -1,6 +1,7 @@
 import * as t from "@babel/types";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { unwrapJavaScriptExpression } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 /** Resolve local callable candidates without following dynamic properties. */
@@ -11,6 +12,11 @@ export const resolveLocalCallables = (input) => resolveCallables(input.node, {
     bindingCache: input.bindingCache,
 });
 const resolveCallables = (node, context) => {
+    // `unwrapJavaScriptExpression` strips all transparent layers iteratively,
+    // so a single recursion step suffices (no per-layer stack growth).
+    const unwrapped = unwrapJavaScriptExpression(node).node;
+    if (unwrapped !== node)
+        return resolveCallables(unwrapped, context);
     const direct = semanticCallableIdForNode(node);
     if (direct !== null && context.callableById.has(direct))
         return {
@@ -20,10 +26,6 @@ const resolveCallables = (node, context) => {
         };
     if (t.isIdentifier(node))
         return resolveIdentifier(node, context);
-    if (t.isTSAsExpression(node) ||
-        t.isTSTypeAssertion(node) ||
-        t.isTSNonNullExpression(node))
-        return resolveCallables(node.expression, context);
     if (t.isConditionalExpression(node) || t.isLogicalExpression(node))
         return resolveAlternatives(t.isConditionalExpression(node) ? node.consequent : node.left, t.isConditionalExpression(node) ? node.alternate : node.right, context);
     return {
@@ -103,7 +105,7 @@ export const parameterBindings = (callable, index, state) => {
         .filter((binding) => binding.kind === "parameter" &&
         binding.definitions.some(({ kind, location }) => kind === "parameter" &&
             parameterAcceptsArgument(callable, location, index, state)))
-        .sort((left, right) => compareCodePoints(left.bindingId, right.bindingId));
+        .sort((left, right) => compareUnicodeCodePoints(left.bindingId, right.bindingId));
 };
 const parameterAcceptsArgument = (callable, location, argumentIndex, state) => {
     const node = state.callableNodesById.get(callable.callableId);
@@ -122,4 +124,4 @@ const rangeContains = (outer, inner) => (outer.start.line < inner.start.line ||
     (outer.end.line > inner.end.line ||
         (outer.end.line === inner.end.line &&
             outer.end.column >= inner.end.column));
-const uniqueCallableIds = (values) => [...new Set(values)].sort(compareCodePoints);
+const uniqueCallableIds = (values) => [...new Set(values)].sort(compareUnicodeCodePoints);

package/dist/domain/javascript/javascriptSemanticCalls.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticReferenceRole, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticReferenceRole, } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, isUnshadowedGlobal, } from "./javascriptSemanticState.js";
 import { parameterBindings, resolveLocalCallables, } from "./javascriptSemanticCallResolution.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";

package/dist/domain/javascript/javascriptSemanticChildProcesses.js

@@ -1,8 +1,9 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
-import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { dataEffectLiteralString, dataEffectMemberCallee, assignedSemanticResultBindings, scalarAssignedResultBinding, semanticProjectedBindingFacts, } from "./javascriptSemanticDataEffectHelpers.js";
@@ -129,7 +130,7 @@ const childInteraction = (node, ownerCallableId, context) => {
         processBindingId: binding?.bindingId ?? null,
         linkedProcessIds: linked
             .map((candidate) => spawnId(candidate))
-            .sort(compareCodePoints),
+            .sort(compareUnicodeCodePoints),
         eventName: kind === "listener" ? eventName : null,
         signalName: kind === "signal"
             ? (dataEffectLiteralString(node.arguments[0]) ?? "SIGTERM")

package/dist/domain/javascript/javascriptSemanticCoverage.js

@@ -1,9 +1,29 @@
+import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT, } from "./javascriptSemanticResourceLimits.js";
 /** Classify whole-file semantic coverage from parsing and value bounds. */
 export const semanticCoverage = (parserPartial, resourceLimits = []) => resourceLimits.length > 0
     ? { status: "partial", omittedCount: null, resourceLimits }
     : { status: parserPartial ? "partial" : "complete", omittedCount: 0 };
 /** Read typed resource-limit classifications from any coverage state. */
 export const semanticCoverageResourceLimits = (coverage) => coverage.resourceLimits ?? [];
+const semanticResourceBounds = {
+    "primitive-candidates": {
+        value: SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT,
+        unit: "items",
+    },
+    "primitive-bytes": {
+        value: SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT,
+        unit: "bytes",
+    },
+    "expression-depth": {
+        value: SEMANTIC_EXPRESSION_DEPTH_LIMIT,
+        unit: "depth",
+    },
+};
+/** Map semantic evaluator bounds to their caller-visible application coverage. */
+export const semanticResourceLimitCoverage = (resourceLimits) => resourceLimits.map((resourceLimit) => ({
+    name: `javascript_semantic_${resourceLimit.replaceAll("-", "_")}`,
+    ...semanticResourceBounds[resourceLimit],
+}));
 /** Classify one callable's direct-return coverage. */
 export const semanticReturnCoverage = (retainedCount, parserPartial) => ({
     status: parserPartial ? "partial" : "complete",

package/dist/domain/javascript/javascriptSemanticDataEffectHelpers.js

@@ -3,7 +3,7 @@ import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js"
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { readExactJavaScriptLiteral, semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } 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) {
@@ -34,14 +34,12 @@ const assignedSourceIs = (node, source) => {
     while (true) {
         if (t.isAwaitExpression(value))
             value = value.argument;
-        else if (t.isParenthesizedExpression(value) ||
-            t.isTSAsExpression(value) ||
-            t.isTSTypeAssertion(value) ||
-            t.isTypeCastExpression(value) ||
-            t.isTSSatisfiesExpression(value))
-            value = value.expression;
-        else
-            break;
+        else {
+            const unwrapped = unwrapJavaScriptExpression(value).node;
+            if (unwrapped === value)
+                break;
+            value = unwrapped;
+        }
     }
     return value === node;
 };

package/dist/domain/javascript/javascriptSemanticDataEffects.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
-import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -101,14 +101,7 @@ const collectDefaults = (program, context, configurations) => {
         if (!t.isLogicalExpression(node) ||
             (node.operator !== "??" && node.operator !== "||"))
             return;
-        let source = node.left;
-        while (t.isParenthesizedExpression(source) ||
-            t.isTSAsExpression(source) ||
-            t.isTSTypeAssertion(source) ||
-            t.isTypeCastExpression(source) ||
-            t.isTSSatisfiesExpression(source) ||
-            t.isTSNonNullExpression(source))
-            source = source.expression;
+        const source = unwrapJavaScriptExpression(node.left).node;
         const candidate = configurationsByNode.get(source);
         if (candidate === undefined)
             return;
@@ -197,7 +190,7 @@ const collectResponseConsumers = (program, context, requests) => {
             projectedResultBindings: semanticProjectedBindingFacts(assignedSemanticResultBindings(node, context.ancestors, context.state).filter(({ projectionPath }) => projectionPath.length > 0)),
             linkedRequestIds: linked
                 .map(({ operation }) => operation.requestId)
-                .sort(compareCodePoints),
+                .sort(compareUnicodeCodePoints),
             endpoint: null,
             fields: [],
             resolution: linked.length === 1 &&

package/dist/domain/javascript/javascriptSemanticFingerprints.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 /** Build bounded rename- and formatting-resistant components per callable. */
@@ -38,7 +38,7 @@ export const collectJavaScriptSemanticFingerprints = (input) => {
                     normalizedAstSha256: digest(syntax.normalizedTokens),
                     controlFlowSha256: digest(syntax.controlFlowTokens),
                     relationShapeSha256: digest(relationShape(callable, callSitesByCaller.get(callable.callableId) ?? [], captureCountByCallable.get(callable.callableId) ?? 0, promiseEffects)),
-                    literalSetSha256: digest([...new Set(syntax.literals)].sort(compareCodePoints)),
+                    literalSetSha256: digest([...new Set(syntax.literals)].sort(compareUnicodeCodePoints)),
                     effects: [
                         ...(isAsyncCallable(node) ? ["async"] : []),
                         ...(childProcessEffects.length > 0