rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptSemanticValues.js

@@ -1,13 +1,23 @@
 import * as t from "@babel/types";
-import { invalidateSemanticMutationPath } from "./javascriptSemanticMutationValues.js";
+import { semanticCapturePosition, semanticEscapeFollowsCapture, semanticBindingPrecedesCapture, } from "./javascriptSemanticMutationInitializers.js";
+import { semanticSlotAtPath } from "./javascriptSemanticSlots.js";
+import { invalidateSemanticEscapedPath, invalidateSemanticMutationPath, } from "./javascriptSemanticMutationValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { semanticAmbiguousProvenance, semanticLocalProvenance, semanticOriginsProvenance, semanticUnresolvedProvenance, uniqueSemanticOrigins, } from "./javascriptSemanticProvenance.js";
-import { MAX_SEMANTIC_PRIMITIVE_CANDIDATES, semanticPrimitiveCandidates as primitiveCandidates, semanticPrimitiveSet as primitiveSet, semanticPrimitiveValue as primitiveValue, } from "./javascriptSemanticPrimitives.js";
+import { semanticPrimitiveCandidates as primitiveCandidates, semanticPrimitiveSet as primitiveSet, } from "./javascriptSemanticPrimitives.js";
 import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveAdditionByteBudget, exceedsSemanticTemplateByteBudget, semanticResourceLimitUnknown, semanticResourceLimitReason, } from "./javascriptSemanticResourceLimits.js";
 const primitiveBindingValuesByState = new WeakMap();
+const 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)
@@ -25,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,
@@ -42,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;
@@ -50,6 +73,16 @@ const evaluateBinding = (binding, context) => {
             status: "unknown",
             reason: `Binding ${binding.name} has no constant initializer.`,
         };
+    if (binding.initializers.some(({ node }) => t.isUpdateExpression(node) ||
+        (t.isAssignmentExpression(node) &&
+            node.operator !== "=" &&
+            node.operator !== "&&=" &&
+            node.operator !== "||=" &&
+            node.operator !== "??=")))
+        return {
+            status: "unknown",
+            reason: `Binding ${binding.name} has a compound or update write.`,
+        };
     if (binding.initializers.length > 1)
         return {
             status: "ambiguous",
@@ -59,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" ||
@@ -72,9 +120,21 @@ const evaluateBinding = (binding, context) => {
 const evaluateExpression = (node, context) => {
     if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT)
         return semanticResourceLimitUnknown("expression-depth");
-    const literal = primitiveValue(node);
+    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
@@ -103,20 +163,18 @@ 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) => {
     let candidates = [""];
     for (let index = 0; index < node.quasis.length; index += 1) {
         const quasi = node.quasis[index];
-        // Semantic template evaluation retains its established raw fallback for
-        // synthetic AST inputs; exact atom readers remain cooked-only.
-        const text = quasi?.value.cooked ?? quasi?.value.raw ?? "";
+        const text = quasi?.value.cooked;
+        if (text === undefined || text === null)
+            return {
+                status: "unknown",
+                reason: "Template text has no cooked representation.",
+            };
         if (exceedsSemanticTemplateByteBudget(candidates, [text]))
             return semanticResourceLimitUnknown("primitive-bytes");
         candidates = candidates.map((prefix) => `${prefix}${text}`);
@@ -150,6 +208,7 @@ const evaluateObject = (node, context) => {
         for (const [name] of propertiesByName)
             propertiesByName.set(name, {
                 name,
+                presence: "present",
                 value: {
                     status: "unknown",
                     reason: "A later property may overwrite this value.",
@@ -183,15 +242,16 @@ const evaluateObject = (node, context) => {
         }
         propertiesByName.set(name, {
             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",
@@ -218,20 +278,27 @@ const evaluateArray = (node, context) => {
             break;
         }
         if (element === null) {
-            unknownItems = true;
-            if (omittedItems !== null)
-                omittedItems += 1;
             items.push({
-                status: "unknown",
-                reason: "Array hole has no primitive value.",
+                name: String(items.length),
+                presence: "absent",
+                value: { status: "unknown", reason: "Array hole has no own value." },
             });
             continue;
         }
-        items.push(evaluateExpression(element, nestedContext(context)));
+        items.push({
+            name: String(items.length),
+            presence: "present",
+            value: evaluateCapturedExpression(element, nestedContext(context)),
+        });
     }
     return unknownItems
         ? { status: "array", items, unknownItems: true, omittedItems }
-        : { status: "array", items, unknownItems: false, omittedItems: 0 };
+        : {
+            status: "array",
+            items,
+            unknownItems: false,
+            omittedItems: 0,
+        };
 };
 const evaluateMember = (node, context) => {
     const keys = [];
@@ -290,7 +357,7 @@ const addPrimitiveValues = (leftValue, rightValue) => {
             return rightValue;
         return { status: "unknown", reason: "Non-primitive addition." };
     }
-    if (left.length > MAX_SEMANTIC_PRIMITIVE_CANDIDATES / right.length)
+    if (left.length > SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT / right.length)
         return semanticResourceLimitUnknown("primitive-candidates");
     if (exceedsSemanticPrimitiveAdditionByteBudget(left, right))
         return semanticResourceLimitUnknown("primitive-bytes");
@@ -316,46 +383,16 @@ const evaluateUnary = (node, context) => {
     return { status: "unknown", reason: `Unsupported unary ${node.operator}.` };
 };
 const projectValue = (value, projection) => {
-    let current = value;
-    for (const key of projection) {
-        if (key === null)
-            return {
-                status: "unknown",
-                reason: "Cannot project a dynamic property.",
-            };
-        if (current.status === "object" && typeof key === "string") {
-            const property = current.properties.find(({ name }) => name === key);
-            if (property === undefined)
-                return {
-                    status: current.unknownProperties ? "unknown" : "unknown",
-                    reason: `Object property ${key} was not observed.`,
-                };
-            current = property.value;
-        }
-        else if (current.status === "array") {
-            const index = typeof key === "number" ? key : Number(key);
-            if (!Number.isSafeInteger(index) ||
-                index < 0 ||
-                String(index) !== String(key))
-                return {
-                    status: "unknown",
-                    reason: `Array property ${String(key)} is not a canonical index.`,
-                };
-            const item = current.items[index];
-            if (item === undefined)
-                return {
-                    status: "unknown",
-                    reason: `Array item ${String(key)} missing.`,
-                };
-            current = item;
-        }
-        else
-            return {
-                status: "unknown",
-                reason: `Cannot project ${String(key)} from ${current.status}.`,
-            };
-    }
-    return current;
+    if (projection.includes(null))
+        return { status: "unknown", reason: "Cannot project a dynamic property." };
+    const path = projection.map((key) => String(key));
+    const slot = semanticSlotAtPath(value, path);
+    return slot.presence === "present"
+        ? slot.value
+        : {
+            status: "unknown",
+            reason: `Own property ${path.join("/")} is ${slot.presence}.`,
+        };
 };
 const provenanceForBinding = (binding, context) => {
     if (context.bindings.has(binding.bindingId))
@@ -385,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]);
@@ -423,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();
@@ -442,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

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

package/dist/domain/javascript/javascriptSourceParser.js

@@ -1,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,

package/dist/domain/javascript/javascriptStaticAnalysisCalls.js

@@ -1,7 +1,8 @@
 import * as t from "@babel/types";
 import { sanitizeEndpointCandidate } from "../browserObservation.js";
 import { addFindingOnce, addLocatedFinding, } from "./javascriptStaticAnalysisFindings.js";
-import { STATIC_ROUTE_CALL_NAMES, argumentValue, calleeName, endpointArgument as endpointArgumentHelper, prefixedArgument, semanticStaticPropertyName, range, rangeForOffsets, sourceSlice, staticPath, staticPathResolutionContext, storageKind, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
+import { STATIC_ROUTE_CALL_NAMES, argumentValue, calleeName, endpointArgument as endpointArgumentHelper, prefixedArgument, range, rangeForOffsets, sourceSlice, staticPath, staticPathResolutionContext, storageKind, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 /** Inspect one call or new expression for references, endpoints, storage, and roles. */
 export const inspectCall = (source, node, context) => {
     const { accumulator } = context;