rea-agents 6.2.0 → 6.3.0

package/dist/domain/javascript/javascriptSemanticQuerySchemas.js

@@ -1,16 +1,14 @@
 import { z } from "zod";
-import { JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATIONS, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
-import { jsonValueSchema } from "../jsonValue.js";
+import { JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATIONS, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
 import { digestSchema } from "../digests.js";
 import { prefixedDigestSchema } from "../digests.js";
 const semanticNodeIdSchema = prefixedDigestSchema("jsrg_node");
-const literalValueSchema = jsonValueSchema.refine((value) => value === null ||
-    typeof value === "string" ||
-    typeof value === "number" ||
-    typeof value === "boolean", "Literal seeds accept only JSON primitive values");
-// Zod derivations drop the shared schema's JSON Schema projection override;
-// re-apply it so MCP catalog generation keeps projecting `{}`.
-literalValueSchema._zod.toJSONSchema = () => ({});
+const literalValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+]);
 const literalSeedSchema = z.strictObject({
     kind: z.literal("literal"),
     value: literalValueSchema,
@@ -77,6 +75,7 @@ export const javaScriptSemanticQueryResultSchema = z.strictObject({
     direction: javaScriptSemanticQueryInputSchema.shape.direction,
     status: z.enum(["found", "no-match", "ambiguous", "partial", "unsupported"]),
     seed_node_ids: z.array(semanticNodeIdSchema),
+    evidence_contexts: z.array(javaScriptSemanticEvidenceContextSchema),
     nodes: z.array(javaScriptSemanticNodeSchema),
     relations: z.array(javaScriptSemanticRelationSchema),
     unknowns: z.array(javaScriptSemanticUnknownSchema),

package/dist/domain/javascript/javascriptSemanticRequireOrigin.js

@@ -1,24 +1,30 @@
 import * as t from "@babel/types";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { stringValue } from "./javascriptStaticAnalysisHelpers.js";
 /** Recover an unshadowed literal require origin and its exact member path. */
 export const semanticRequireOrigin = (node, state) => {
     const members = [];
-    while (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const member = semanticStaticPropertyKey(node.property, node.computed);
-        if (member === null || !t.isNode(node.object))
+    let current = node;
+    while (current !== null && current !== undefined) {
+        current = unwrapJavaScriptExpression(current).node;
+        if (!t.isMemberExpression(current) &&
+            !t.isOptionalMemberExpression(current))
+            break;
+        const member = semanticStaticPropertyKey(current.property, current.computed);
+        if (member === null || !t.isNode(current.object))
             return undefined;
         members.push(member);
-        node = node.object;
+        current = current.object;
     }
-    if (!t.isCallExpression(node) ||
-        !t.isIdentifier(node.callee, { name: "require" }))
+    if (!t.isCallExpression(current) ||
+        !t.isIdentifier(current.callee, { name: "require" }))
         return undefined;
-    if (resolveSemanticBindingState(state, node.callee, "require") !== undefined ||
-        semanticResolutionBlocked(state, node.callee, "require"))
+    if (resolveSemanticBindingState(state, current.callee, "require") !==
+        undefined ||
+        semanticResolutionBlocked(state, current.callee, "require"))
         return undefined;
-    const specifier = stringValue(node.arguments[0]);
+    const specifier = stringValue(current.arguments[0]);
     return specifier === undefined
         ? undefined
         : { specifier, importedPath: members.reverse() };

package/dist/domain/javascript/javascriptSemanticReturns.js

@@ -1,12 +1,13 @@
 import * as t from "@babel/types";
 import { semanticContainer, semanticPropertyPointer, } from "./javascriptSemanticSlots.js";
-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 { evaluateSemanticExpression } from "./javascriptSemanticValues.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { semanticReturnCoverage } from "./javascriptSemanticCoverage.js";
-import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { childNodes, traverseJavaScriptAst, } from "./javascriptSemanticTraversal.js";
 /** Evaluate direct returns while excluding every nested callable. */
 export const collectSemanticReturns = (program, state, parserPartial) => {
     const nodes = callableNodes(program);
@@ -46,16 +47,14 @@ const semanticReturnSiteId = (callableId, location) => `${callableId}:return:${S
 /** Link exports to callables only when lexical resolution is unique and exact. */
 export const resolveSemanticModuleCallables = (state, callables) => {
     const callableIds = new Set(callables.map(({ callableId }) => callableId));
-    const root = state.scopes.find(({ kind }) => kind === "program");
     return state.moduleLinks.map((link) => {
-        if (link.callableId !== null && callableIds.has(link.callableId))
-            return link;
-        if (link.localName === null || root === undefined)
-            return { ...link, callableId: null };
-        const named = callables.filter(({ name, containerScopeId }) => name === link.localName && containerScopeId === root.scopeId);
-        if (named.length === 1)
-            return { ...link, callableId: named[0]?.callableId ?? null };
-        const binding = root.bindings.get(link.localName);
+        // Named exports follow their lexical binding, including every assignment.
+        // A declaration's ID or a callable's display name cannot prove that link.
+        if (link.localName === null)
+            return link.callableId !== null && callableIds.has(link.callableId)
+                ? link
+                : { ...link, callableId: null };
+        const binding = state.moduleLinkBindings.get(link);
         const resolved = binding === undefined
             ? []
             : callableIdsForBinding(binding, state, callableIds, new Set());
@@ -97,23 +96,24 @@ const directReturnExpressions = (callable) => {
         visit(child);
     return output;
 };
-const childNodes = (node) => (t.VISITOR_KEYS[node.type] ?? []).flatMap((key) => {
-    const value = Reflect.get(node, key);
-    if (t.isNode(value))
-        return [value];
-    return Array.isArray(value)
-        ? value.filter((item) => t.isNode(item))
-        : [];
-});
 const callableIdsForBinding = (binding, state, admitted, seen) => {
-    if (seen.has(binding.bindingId) || binding.initializers.length !== 1)
+    // A single initializer does not prove an assignment executes or replace
+    // the unknown incoming value of a parameter/catch binding.
+    if (seen.has(binding.bindingId) ||
+        binding.initializers.length !== 1 ||
+        binding.definitions.some(({ kind }) => kind === "assignment" || kind === "parameter" || kind === "catch"))
         return [];
     const initializer = binding.initializers[0];
-    if (initializer === undefined || initializer.projection.length > 0)
+    if (initializer === undefined ||
+        initializer.projection.length > 0 ||
+        state.conditionalInitializers.has(initializer.node))
         return [];
     return callableIdsForNode(initializer.node, state, admitted, new Set([...seen, binding.bindingId]));
 };
 const callableIdsForNode = (node, state, admitted, seen) => {
+    const unwrapped = unwrapJavaScriptExpression(node).node;
+    if (unwrapped !== node)
+        return callableIdsForNode(unwrapped, state, admitted, seen);
     const direct = semanticCallableIdForNode(node);
     if (direct !== null && admitted.has(direct))
         return [direct];
@@ -123,10 +123,6 @@ const callableIdsForNode = (node, state, admitted, seen) => {
             ? []
             : callableIdsForBinding(binding, state, admitted, seen);
     }
-    if (t.isTSAsExpression(node) ||
-        t.isTSTypeAssertion(node) ||
-        t.isTSNonNullExpression(node))
-        return callableIdsForNode(node.expression, state, admitted, seen);
     return [];
 };
 /** Flatten a semantic value to bounded JSON-pointer leaves for graph projection. */
@@ -134,8 +130,8 @@ export const flattenSemanticReturnValue = (value) => {
     const fields = [];
     const propertyCoverage = [];
     flattenValue(value, "", fields, propertyCoverage);
-    fields.sort((left, right) => compareCodePoints(left.path, right.path));
-    propertyCoverage.sort((left, right) => compareCodePoints(left.path, right.path));
+    fields.sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
+    propertyCoverage.sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
     return { fields, propertyCoverage };
 };
 const flattenValue = (value, path, fields, coverage, presence = "present") => {

package/dist/domain/javascript/javascriptSemanticTraversal.js

@@ -33,7 +33,12 @@ export const traverseJavaScriptAst = (root, visitor) => {
         }
     }
 };
-const childNodes = (node) => {
+/**
+ * Child Babel nodes in `VISITOR_KEYS` order. Single owner for AST child
+ * expansion; bespoke `Object.values` / duplicated `childNodes` walkers must
+ * not be reintroduced (they diverge on loc/comment fields and ordering).
+ */
+export const childNodes = (node) => {
     const keys = t.VISITOR_KEYS[node.type];
     if (keys === undefined)
         return [];

package/dist/domain/javascript/javascriptSemanticValues.js

@@ -1,14 +1,23 @@
 import * as t from "@babel/types";
+import { semanticCapturePosition, semanticEscapeFollowsCapture, semanticBindingPrecedesCapture, } from "./javascriptSemanticMutationInitializers.js";
 import { semanticSlotAtPath } from "./javascriptSemanticSlots.js";
-import { invalidateSemanticMutationPath } from "./javascriptSemanticMutationValues.js";
+import { invalidateSemanticEscapedPath, invalidateSemanticMutationPath, } from "./javascriptSemanticMutationValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
-import { readExactJavaScriptLiteral, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { semanticAmbiguousProvenance, semanticLocalProvenance, semanticOriginsProvenance, semanticUnresolvedProvenance, uniqueSemanticOrigins, } from "./javascriptSemanticProvenance.js";
 import { semanticPrimitiveCandidates as primitiveCandidates, semanticPrimitiveSet as primitiveSet, } from "./javascriptSemanticPrimitives.js";
 import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveAdditionByteBudget, exceedsSemanticTemplateByteBudget, semanticResourceLimitUnknown, semanticResourceLimitReason, } from "./javascriptSemanticResourceLimits.js";
 const primitiveBindingValuesByState = new WeakMap();
+const primitiveExpressionValuesByState = new WeakMap();
+const capturedBindingValuesByState = new WeakMap();
+/** Discard primitive projections evaluated before mutation collection finished. */
+export const clearSemanticPrimitiveBindingValues = (state) => {
+    primitiveBindingValuesByState.delete(state);
+    capturedBindingValuesByState.delete(state);
+    primitiveExpressionValuesByState.delete(state);
+};
 const primitiveBindingValuesFor = (state) => {
     const existing = primitiveBindingValuesByState.get(state);
     if (existing !== undefined)
@@ -26,13 +35,18 @@ export const evaluateSemanticBinding = (binding, state) => evaluateBinding(bindi
     expressionDepth: 0,
     primitiveBindingValues: primitiveBindingValuesFor(state),
 });
-/** Evaluate one arbitrary inert expression in the established lexical state. */
-export const evaluateSemanticExpression = (node, state) => evaluateExpression(node, {
-    state,
-    bindings: new Set(),
-    expressionDepth: 0,
-    primitiveBindingValues: primitiveBindingValuesFor(state),
-});
+/** Evaluate an inert expression, optionally at an earlier reference capture. */
+export const evaluateSemanticExpression = (node, state, capturePoint) => {
+    const context = {
+        state,
+        bindings: new Set(),
+        expressionDepth: 0,
+        primitiveBindingValues: primitiveBindingValuesFor(state),
+    };
+    return evaluateExpression(node, capturePoint === undefined
+        ? context
+        : (captureContextAt(capturePoint, context) ?? context));
+};
 /** Follow module provenance through destructuring, members, and aliases. */
 export const evaluateSemanticProvenance = (binding, state) => provenanceForBinding(binding, {
     state,
@@ -43,6 +57,14 @@ export const evaluateSemanticProvenance = (binding, state) => provenanceForBindi
 const evaluateBinding = (binding, context) => {
     if (context.bindings.has(binding.bindingId))
         return { status: "cycle", reason: `Alias cycle at ${binding.name}.` };
+    if (context.capturePoint !== undefined &&
+        !semanticBindingPrecedesCapture(binding, context.capturePoint, context.state.parentsByNode)) {
+        const { capturePoint: _capturePoint, ...liveContext } = context;
+        return evaluateBinding(binding, {
+            ...liveContext,
+            primitiveBindingValues: primitiveBindingValuesFor(context.state),
+        });
+    }
     const cached = context.primitiveBindingValues.get(binding.bindingId);
     if (cached !== undefined)
         return cached;
@@ -70,9 +92,24 @@ const evaluateBinding = (binding, context) => {
     if (initializer === undefined)
         return { status: "unknown", reason: "Missing binding initializer." };
     const nested = nestedContext(context, binding.bindingId);
-    const value = projectValue(evaluateExpression(initializer.node, nested), initializer.projection);
-    const projected = binding.mutatedPaths.reduce(invalidateSemanticMutationPath, value);
-    if (projected.status === "literal" ||
+    let value = projectValue(evaluateExpression(initializer.node, nested), initializer.projection);
+    if (!isPrimitive(value)) {
+        const captureContext = primitiveCaptureContext(initializer.node, nested);
+        if (captureContext !== undefined) {
+            const captured = projectValue(evaluateExpression(initializer.node, captureContext), initializer.projection);
+            if (isPrimitive(captured))
+                value = captured;
+        }
+    }
+    const mutated = binding.mutatedPaths.reduce(invalidateSemanticMutationPath, value);
+    const projected = binding.escapedPaths.reduce((value, escape) => context.capturePoint !== undefined &&
+        semanticEscapeFollowsCapture(binding, context.capturePoint, escape.node, context.state.parentsByNode)
+        ? value
+        : invalidateSemanticEscapedPath(value, escape.path), mutated);
+    // Point-local memoization also bounds failed speculative captures. Only a
+    // primitive result is allowed back into ordinary value evaluation.
+    if (context.capturePoint !== undefined ||
+        projected.status === "literal" ||
         projected.status === "union" ||
         (isSemanticResourceLimit(projected) &&
             (projected.resourceLimit === "primitive-bytes" ||
@@ -83,9 +120,21 @@ const evaluateBinding = (binding, context) => {
 const evaluateExpression = (node, context) => {
     if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT)
         return semanticResourceLimitUnknown("expression-depth");
+    const unwrapped = unwrapJavaScriptExpression(node);
+    if (unwrapped.depth > 0) {
+        if (context.expressionDepth + unwrapped.depth >
+            SEMANTIC_EXPRESSION_DEPTH_LIMIT)
+            return semanticResourceLimitUnknown("expression-depth");
+        return evaluateExpression(unwrapped.node, {
+            ...context,
+            expressionDepth: context.expressionDepth + unwrapped.depth,
+        });
+    }
     const literal = readExactJavaScriptLiteral(node);
     if (literal.found)
-        return { status: "literal", value: literal.value };
+        return typeof literal.value === "number"
+            ? primitiveSet([literal.value])
+            : { status: "literal", value: literal.value };
     if (t.isIdentifier(node)) {
         const binding = resolveSemanticBindingState(context.state, node, node.name);
         return binding === undefined
@@ -114,11 +163,6 @@ const evaluateExpression = (node, context) => {
         return evaluateAddition(node, context);
     if (t.isUnaryExpression(node))
         return evaluateUnary(node, context);
-    if ((t.isTSAsExpression(node) ||
-        t.isTSTypeAssertion(node) ||
-        t.isTSNonNullExpression(node)) &&
-        t.isExpression(node.expression))
-        return evaluateExpression(node.expression, nestedContext(context));
     return { status: "unknown", reason: `Unsupported ${node.type} value.` };
 };
 const evaluateTemplate = (node, context) => {
@@ -200,14 +244,14 @@ const evaluateObject = (node, context) => {
             name,
             presence: "present",
             value: t.isObjectProperty(property)
-                ? evaluateExpression(property.value, nestedContext(context))
+                ? evaluateCapturedExpression(property.value, nestedContext(context))
                 : {
                     status: "unknown",
                     reason: "Object method or accessor value is not a primitive.",
                 },
         });
     }
-    const properties = [...propertiesByName.values()].sort((left, right) => compareCodePoints(left.name, right.name));
+    const properties = [...propertiesByName.values()].sort((left, right) => compareUnicodeCodePoints(left.name, right.name));
     return unknownProperties
         ? {
             status: "object",
@@ -244,7 +288,7 @@ const evaluateArray = (node, context) => {
         items.push({
             name: String(items.length),
             presence: "present",
-            value: evaluateExpression(element, nestedContext(context)),
+            value: evaluateCapturedExpression(element, nestedContext(context)),
         });
     }
     return unknownItems
@@ -378,6 +422,16 @@ const provenanceForBinding = (binding, context) => {
 const provenanceForExpression = (node, context) => {
     if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT)
         return semanticUnresolvedProvenance("unknown", semanticResourceLimitReason("expression-depth"));
+    const unwrapped = unwrapJavaScriptExpression(node);
+    if (unwrapped.depth > 0) {
+        if (context.expressionDepth + unwrapped.depth >
+            SEMANTIC_EXPRESSION_DEPTH_LIMIT)
+            return semanticUnresolvedProvenance("unknown", semanticResourceLimitReason("expression-depth"));
+        return provenanceForExpression(unwrapped.node, {
+            ...context,
+            expressionDepth: context.expressionDepth + unwrapped.depth,
+        });
+    }
     const required = semanticRequireOrigin(node, context.state);
     if (required !== undefined)
         return semanticOriginsProvenance([required]);
@@ -416,9 +470,14 @@ const provenanceForExpression = (node, context) => {
             provenanceForExpression(left, nestedContext(context)),
             provenanceForExpression(right, nestedContext(context)),
         ];
-        const origins = candidates.flatMap((candidate) => candidate.origins);
+        const origins = uniqueSemanticOrigins(candidates.flatMap((candidate) => candidate.origins));
+        const allModuleOrigins = candidates.every(({ status }) => status === "module");
+        if (allModuleOrigins && origins.length === 1)
+            return semanticOriginsProvenance(origins);
         return origins.length > 0
-            ? semanticAmbiguousProvenance(uniqueSemanticOrigins(origins), "Multiple module origins.")
+            ? semanticAmbiguousProvenance(origins, allModuleOrigins
+                ? "Multiple module origins."
+                : "Conditional provenance includes a non-module alternative.")
             : semanticUnresolvedProvenance("unknown", "Conditional provenance is unresolved.");
     }
     return semanticLocalProvenance();
@@ -435,8 +494,60 @@ const mergeValues = (values) => {
 const nestedContext = (context, bindingId) => ({
     state: context.state,
     primitiveBindingValues: context.primitiveBindingValues,
+    ...(context.capturePoint === undefined
+        ? {}
+        : { capturePoint: context.capturePoint }),
     expressionDepth: context.expressionDepth + 1,
     bindings: bindingId === undefined
         ? context.bindings
         : new Set([...context.bindings, bindingId]),
 });
+const isPrimitive = (value) => value.status === "literal" || value.status === "union";
+const primitiveCaptureContext = (node, context) => {
+    if (t.isObjectExpression(node) || t.isArrayExpression(node))
+        return undefined;
+    return captureContextAt(node, context);
+};
+const captureContextAt = (node, context) => {
+    if (context.capturePoint !== undefined ||
+        semanticCapturePosition(node, context.state.parentsByNode) === null)
+        return undefined;
+    let captures = capturedBindingValuesByState.get(context.state);
+    if (captures === undefined) {
+        captures = new WeakMap();
+        capturedBindingValuesByState.set(context.state, captures);
+    }
+    let values = captures.get(node);
+    if (values === undefined) {
+        values = new Map();
+        captures.set(node, values);
+    }
+    return { ...context, capturePoint: node, primitiveBindingValues: values };
+};
+const evaluateCapturedExpression = (node, context) => {
+    // A literal field captures its primitive at construction, even when its
+    // containing object is subsequently read at another capture point.
+    let values = primitiveExpressionValuesByState.get(context.state);
+    const cached = values?.get(node);
+    if (cached !== undefined)
+        return cached;
+    let value = evaluateExpression(node, context);
+    if (!isPrimitive(value)) {
+        const captureContext = primitiveCaptureContext(node, context);
+        if (captureContext !== undefined) {
+            const captured = evaluateExpression(node, captureContext);
+            if (isPrimitive(captured))
+                value = captured;
+        }
+    }
+    // Never publish values evaluated at somebody else's capture point. Like
+    // binding caches, these entries are discarded whenever effects change.
+    if (context.capturePoint === undefined && isPrimitive(value)) {
+        if (values === undefined) {
+            values = new WeakMap();
+            primitiveExpressionValuesByState.set(context.state, values);
+        }
+        values.set(node, value);
+    }
+    return value;
+};

package/dist/domain/javascript/javascriptSourceMapPaths.js

@@ -1,5 +1,5 @@
 import { posix } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { domainToASCII, fileURLToPath, pathToFileURL } from "node:url";
 import { z } from "zod";
 /** Map-scoped source declaration and its path interpretation for matching. */
 export const javascriptSourceMapReferenceSchema = z.strictObject({
@@ -78,7 +78,17 @@ const resolveJavaScriptSourceMapPath = (source, mapPath) => {
         };
     return { path: value, kind: relative ? "artifact-relative" : "suffix" };
 };
+// Reject URL delimiters/escapes before IDNA can truncate or decode the host.
+const unusableHost = /[\0\t\n\r #/:<>?@[\\\]^|%]/u;
+// URL/IDNA validation also rejects Unicode hosts that normalize to empty.
+const carriesUsableHost = (host) => !unusableHost.test(host) && domainToASCII(host) !== "";
 const windowsFileUrl = (path) => {
+    // A malformed UNC host aborts pathToFileURL() on the Node builds this
+    // package admits, so decline the reference before handing the path over
+    // rather than trusting a TypeError that never arrives.
+    if (path.startsWith("\\\\") &&
+        !carriesUsableHost(path.slice(2).split("\\")[0] ?? ""))
+        return null;
     try {
         return pathToFileURL(path, { windows: true });
     }

package/dist/domain/javascript/javascriptSourceParser.js

@@ -1,4 +1,37 @@
 import { parse } from "@babel/parser";
+/**
+ * Babel plugins for one source path. Single owner for TypeScript/JSX
+ * mode selection (tsc + Babel `typescript` plugin semantics).
+ *
+ * - `dts:true` only for `.d.ts/.d.mts/.d.cts` ambient declarations;
+ *   ordinary `.ts` keeps the missing-initializer diagnostic.
+ * - JSX enabled for `.tsx`, `.jsx`, `.js`, and unknown paths; disabled for
+ *   plain `.ts/.cts/.mts` (angle-bracket assertions, not JSX) and for all
+ *   declaration files. `.mts` (including `.d.mts`) sets
+ *   `disallowAmbiguousJSXLike`, matching tsc's `.mts` mode.
+ * - `decorators-legacy` always present: without it decorated sources fail
+ *   hard instead of reporting recovered syntax, losing every derived fact.
+ * - Unknown paths retain the existing JSX-capable contract (best-effort
+ *   parse; failures surface via `errorRecovery`, never silent misparse).
+ */
+export const parserPluginsForPath = (sourcePath) => {
+    const path = sourcePath ?? "";
+    const dts = /\.d\.(?:ts|mts|cts)$/iu.test(path);
+    const isTsLike = /\.(?:ts|cts|mts)$/iu.test(path);
+    const isTsx = /\.tsx$/iu.test(path);
+    const isMts = /\.mts$/iu.test(path);
+    const typescript = [
+        "typescript",
+        {
+            dts,
+            ...(isMts ? { disallowAmbiguousJSXLike: true } : {}),
+        },
+    ];
+    const jsxCapable = !dts && (isTsx || !isTsLike);
+    return jsxCapable
+        ? ["decorators-legacy", "jsx", typescript]
+        : ["decorators-legacy", typescript];
+};
 /** Parse JavaScript or TypeScript once without attaching comments to AST nodes. */
 export const parseJavaScriptSource = (source, sourcePath) => {
     try {
@@ -6,15 +39,7 @@ export const parseJavaScriptSource = (source, sourcePath) => {
             sourceType: "unambiguous",
             errorRecovery: true,
             attachComment: false,
-            // "decorators-legacy" admits both the standard and the legacy decorator
-            // forms, including parameter decorators. Without it a decorated
-            // TypeScript source fails to parse at all rather than reporting
-            // recovered syntax, which loses every fact derived from that source.
-            // Plain .ts artifacts admit angle-bracket type assertions instead of JSX.
-            // Unknown paths retain the existing JSX-capable parser contract.
-            plugins: sourcePath?.toLowerCase().endsWith(".ts") === true
-                ? ["decorators-legacy", "typescript"]
-                : ["decorators-legacy", "jsx", "typescript"],
+            plugins: parserPluginsForPath(sourcePath),
         });
     }
     catch (cause) {

package/dist/domain/javascript/javascriptStaticAnalysisBundler.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { collectJavaScriptExports, fingerprintJavaScriptAst, } from "./javascriptAstFingerprint.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { addFindingOnce } from "./javascriptStaticAnalysisFindings.js";
 import { argumentValue, calleeName, chunkRuntime, factoryRequireName, moduleFactory, modulePropertyName, range, registrationKey, sha256Text, sourceSlice, staticArrayValues, } from "./javascriptStaticAnalysisHelpers.js";
 /** Inspect a bundler registration call and recover its module table. */
@@ -39,7 +39,7 @@ export const inspectBundlerRegistration = (source, call, accumulator) => {
         unknown_entry_module_keys: runtimeValue.unknownEntryModuleKeys,
         async_chunk_keys: asyncChunkKeys.values,
         unknown_async_chunk_keys: runtimeValue.unknownAsyncChunkKeys + recovered.unknownAsyncChunkKeys,
-        modules: recovered.modules.sort((left, right) => compareCodePoints(left.module_key, right.module_key)),
+        modules: recovered.modules.sort((left, right) => compareUnicodeCodePoints(left.module_key, right.module_key)),
         location: range(call),
     };
     addFindingOnce(accumulator, `registration\0${registrationKey(registration)}`, () => accumulator.registrations.push(registration));
@@ -70,7 +70,7 @@ export const inspectEsbuildWrapper = (source, call, accumulator) => {
         unknown_entry_module_keys: 0,
         async_chunk_keys: recovered.asyncChunkKeys,
         unknown_async_chunk_keys: recovered.unknownAsyncChunkKeys,
-        modules: recovered.modules.sort((left, right) => compareCodePoints(left.module_key, right.module_key)),
+        modules: recovered.modules.sort((left, right) => compareUnicodeCodePoints(left.module_key, right.module_key)),
         location: range(call),
     };
     addFindingOnce(accumulator, `registration\0${registrationKey(registration)}`, () => accumulator.registrations.push(registration));
@@ -146,7 +146,7 @@ const runtimeMetadata = (node) => {
             asyncChunkKeys: [],
             unknownAsyncChunkKeys: 0,
         };
-    const entries = collectBundlerEntryModuleKeys(node, requireName);
+    const entries = collectBundlerCallArgumentValues(node, requireName);
     const asyncChunks = collectBundlerAsyncChunkKeys(node, requireName);
     return {
         requireName,
@@ -156,7 +156,6 @@ const runtimeMetadata = (node) => {
         unknownAsyncChunkKeys: asyncChunks.unknown,
     };
 };
-const collectBundlerEntryModuleKeys = (factory, requireName) => collectBundlerCallArgumentValues(factory, requireName);
 const collectBundlerAsyncChunkKeys = (factory, requireName) => requireName === null
     ? { values: [], unknown: 0 }
     : collectBundlerCallArgumentValues(factory, `${requireName}.e`);
@@ -183,7 +182,7 @@ const isBundlerFunction = (node) => t.isFunctionExpression(node) ||
     t.isArrowFunctionExpression(node) ||
     t.isObjectMethod(node);
 const uniqueValues = (values, unknown = 0) => {
-    const unique = [...new Set(values)].sort(compareCodePoints);
+    const unique = [...new Set(values)].sort(compareUnicodeCodePoints);
     return {
         values: unique,
         unknown,