rea-agents 6.2.0 → 6.4.0

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, invalidateSemanticMutationPaths, } 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;
@@ -69,10 +91,37 @@ const evaluateBinding = (binding, context) => {
     const initializer = binding.initializers[0];
     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" ||
+    context.bindings.add(binding.bindingId);
+    let value;
+    try {
+        const nested = nestedContext(context);
+        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;
+            }
+        }
+    }
+    finally {
+        context.bindings.delete(binding.bindingId);
+    }
+    let projected = invalidateSemanticMutationPaths(value, binding.mutatedPaths);
+    for (const escape of binding.escapedPaths) {
+        // Escapes only invalidate object references; other lattice values survive.
+        if (projected.status !== "object" && projected.status !== "array")
+            break;
+        if (context.capturePoint !== undefined &&
+            semanticEscapeFollowsCapture(binding, context.capturePoint, escape.node, context.state.parentsByNode))
+            continue;
+        projected = invalidateSemanticEscapedPath(projected, escape.path);
+    }
+    // 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 +132,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 +175,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 +256,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 +300,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
@@ -351,6 +407,17 @@ const projectValue = (value, projection) => {
         };
 };
 const provenanceForBinding = (binding, context) => {
+    const provenance = provenanceForBindingValue(binding, context);
+    const assigned = binding.definitions.some(({ kind }) => kind === "assignment");
+    const conditionallyInitialized = binding.initializers.some(({ node }) => context.state.conditionalInitializers.has(node));
+    if (provenance.status !== "module" ||
+        (!assigned && !conditionallyInitialized))
+        return provenance;
+    return semanticAmbiguousProvenance(provenance.origins, assigned
+        ? `Binding ${binding.name} may be reassigned.`
+        : `Binding ${binding.name} is conditionally initialized.`);
+};
+const provenanceForBindingValue = (binding, context) => {
     if (context.bindings.has(binding.bindingId))
         return semanticUnresolvedProvenance("cycle", `Alias cycle at ${binding.name}.`);
     if (binding.directOrigins.length > 0)
@@ -364,7 +431,14 @@ const provenanceForBinding = (binding, context) => {
         return semanticUnresolvedProvenance("unknown", "Missing binding initializer.");
     if (initializer.projection.includes(null))
         return semanticUnresolvedProvenance("unknown", "Dynamic provenance projection.");
-    const resolved = provenanceForExpression(initializer.node, nestedContext(context, binding.bindingId));
+    context.bindings.add(binding.bindingId);
+    let resolved;
+    try {
+        resolved = provenanceForExpression(initializer.node, nestedContext(context));
+    }
+    finally {
+        context.bindings.delete(binding.bindingId);
+    }
     if (resolved.status !== "module" || initializer.projection.length === 0)
         return resolved;
     return semanticOriginsProvenance(resolved.origins.map((origin) => ({
@@ -378,6 +452,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 +500,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();
@@ -432,11 +521,61 @@ const mergeValues = (values) => {
         ? primitiveSet(primitives)
         : { status: "ambiguous", reason: "Branches have incompatible values." };
 };
-const nestedContext = (context, bindingId) => ({
+const nestedContext = (context) => ({
     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]),
+    bindings: context.bindings,
 });
+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/javascriptSourceAnalysis.js

@@ -0,0 +1 @@
+export {};

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/javascriptStaticAnalysis.js

@@ -1,13 +1,15 @@
 import * as t from "@babel/types";
-import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { ELECTRON_IDENTITY_LIMITATION, ELECTRON_MODULE, } from "./javascriptElectronMemberWrites.js";
+import { completeSemanticSteps, traverseJavaScriptAstSteps, } from "./javascriptSemanticTraversal.js";
 import { inspectElectronStaticNode } from "./electronStaticAnalysis.js";
 import { detectVendors, failedJavaScriptStaticAnalysis, registrationKey, sortedUnique, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
-import { addReference, addSourceMapDirectives, inspectCall, inspectRouteProperty, inspectRoleProperty, } from "./javascriptStaticAnalysisCalls.js";
+import { addReference, addSourceMapDirectives, inspectCall, inspectRouteProperty, inspectRoleProperty, inspectRpcNode, } from "./javascriptStaticAnalysisCalls.js";
 import { inspectBundlerRegistration, inspectEsbuildWrapper, } from "./javascriptStaticAnalysisBundler.js";
 import { finalizeLocatedFindings } from "./javascriptStaticAnalysisFindings.js";
 import { createJavaScriptAnalysisAccumulator, } from "./javascriptStaticAnalysisState.js";
-import { classifyParsedJavaScriptOpenReceivers, } from "./javascriptSemanticAnalysis.js";
+import { classifyParsedJavaScriptElectronBindingsSteps, classifyParsedJavaScriptRpcClientRootsSteps, classifyParsedJavaScriptOpenReceivers, } from "./javascriptSemanticAnalysis.js";
 import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
+import { createJavaScriptRpcScan } from "./javascriptRpcEndpoints.js";
 /** Parse one JavaScript artifact and recover static structure only. */
 export const analyzeJavaScriptStaticSource = (source) => {
     const file = parseJavaScriptSource(source);
@@ -16,21 +18,31 @@ export const analyzeJavaScriptStaticSource = (source) => {
         : analyzeParsedJavaScriptStaticSource(source, file, classifyParsedJavaScriptOpenReceivers(file));
 };
 /** Recover static structure from an already parsed JavaScript artifact. */
-export const analyzeParsedJavaScriptStaticSource = (source, file, openReceiverFacts) => {
+export const analyzeParsedJavaScriptStaticSource = (source, file, openReceiverFacts) => completeSemanticSteps(analyzeParsedJavaScriptStaticSourceSteps(source, file, openReceiverFacts));
+/** Static analysis that yields during its source traversal; results are unchanged. */
+export function* analyzeParsedJavaScriptStaticSourceSteps(source, file, openReceiverFacts) {
     const accumulator = createJavaScriptAnalysisAccumulator(source.length);
-    traverseStaticSource(source, file, accumulator, openReceiverFacts);
+    const electronBindings = yield* classifyParsedJavaScriptElectronBindingsSteps(file);
+    const clientRoots = yield* classifyParsedJavaScriptRpcClientRootsSteps(file);
+    yield* traverseStaticSourceSteps(file, {
+        source,
+        accumulator,
+        ...(openReceiverFacts === undefined ? {} : { openReceiverFacts }),
+        electronBindings,
+        rpcScan: createJavaScriptRpcScan(source, clientRoots),
+    });
     addSourceMapDirectives(source, file.comments ?? [], accumulator);
     return finalizeStaticAnalysis(source, file, accumulator);
-};
-const traverseStaticSource = (source, file, accumulator, openReceiverFacts) => {
-    traverseJavaScriptAst(file, {
+}
+function* traverseStaticSourceSteps(file, findings) {
+    yield* traverseJavaScriptAstSteps(file, {
         enter: (node) => {
-            accumulator.visitedNodes += 1;
-            inspectNode(source, node, accumulator, openReceiverFacts);
+            findings.accumulator.visitedNodes += 1;
+            inspectNode(node, findings);
             return undefined;
         },
     });
-};
+}
 const finalizeStaticAnalysis = (source, file, accumulator) => {
     const parserErrors = file.errors.length;
     const limitations = [
@@ -44,6 +56,9 @@ const finalizeStaticAnalysis = (source, file, accumulator) => {
             : [
                 "One or more static keys, expressions, or Electron boundary values were dynamic and remain unknown.",
             ]),
+        ...(accumulator.references.some(({ value }) => value.specifier !== null && ELECTRON_MODULE.test(value.specifier))
+            ? [ELECTRON_IDENTITY_LIMITATION]
+            : []),
         "JavaScript syntax was parsed as data and was never evaluated.",
     ];
     return {
@@ -70,12 +85,8 @@ const finalizeStaticAnalysis = (source, file, accumulator) => {
         limitations,
     };
 };
-const inspectNode = (source, node, accumulator, openReceiverFacts) => {
-    const findings = {
-        source,
-        accumulator,
-        ...(openReceiverFacts === undefined ? {} : { openReceiverFacts }),
-    };
+const inspectNode = (node, findings) => {
+    const { source, accumulator } = findings;
     inspectElectronStaticNode(node, findings);
     if (t.isCallExpression(node)) {
         inspectBundlerRegistration(source, node, accumulator);
@@ -110,4 +121,5 @@ const inspectNode = (source, node, accumulator, openReceiverFacts) => {
         inspectRouteProperty(node, findings);
         inspectRoleProperty(node, findings);
     }
+    inspectRpcNode(node, findings);
 };

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. */
@@ -15,7 +15,7 @@ export const inspectBundlerRegistration = (source, call, accumulator) => {
     const runtimeValue = runtimeMetadata(entry.elements[2]);
     if (!t.isArrayExpression(chunkIds) || !t.isObjectExpression(table))
         return;
-    const recovered = recoverBundlerModules(source, table, accumulator);
+    const recovered = recoverBundlerModules(source, table, runtime, accumulator);
     const chunkKeys = staticArrayValues(chunkIds);
     accumulator.unknownFindings += chunkKeys.unknown;
     accumulator.unknownFindings +=
@@ -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));
@@ -55,13 +55,14 @@ export const inspectEsbuildWrapper = (source, call, accumulator) => {
     const table = call.arguments[0];
     if (wrapperKind === null || !t.isObjectExpression(table))
         return;
-    const recovered = recoverBundlerModules(source, table, accumulator);
+    const runtime = `esbuild-${wrapperKind}`;
+    const recovered = recoverBundlerModules(source, table, runtime, accumulator);
     if (recovered.modules.length === 0)
         return;
     accumulator.unknownFindings += recovered.unknownAsyncChunkKeys;
     const registration = {
         bundler: "esbuild",
-        runtime: `esbuild-${wrapperKind}`,
+        runtime,
         chunk_keys: [`${wrapperKind}@${String(call.start ?? 0)}`],
         unknown_chunk_keys: 0,
         runtime_require_name: null,
@@ -70,17 +71,17 @@ 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));
 };
-const recoverBundlerModules = (source, table, accumulator) => {
+const recoverBundlerModules = (source, table, runtime, accumulator) => {
     const modules = [];
     const asyncChunkKeys = [];
     let unknownAsyncChunkKeys = 0;
     for (const property of table.properties) {
-        const recovered = recoverBundlerModule(source, property, accumulator);
+        const recovered = recoverBundlerModule(source, property, runtime, accumulator);
         if (recovered === null)
             continue;
         modules.push(recovered.module);
@@ -93,7 +94,7 @@ const recoverBundlerModules = (source, table, accumulator) => {
         unknownAsyncChunkKeys,
     };
 };
-const recoverBundlerModule = (source, property, accumulator) => {
+const recoverBundlerModule = (source, property, runtime, accumulator) => {
     const factory = moduleFactory(property);
     if (factory === undefined)
         return null;
@@ -109,6 +110,7 @@ const recoverBundlerModule = (source, property, accumulator) => {
             start: factory.start,
             end: factory.end,
             key,
+            runtime,
             requireName,
         };
         accumulator.moduleRangeIndex.add(moduleRange);
@@ -146,7 +148,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 +158,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 +184,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,