rea-agents 6.2.0 → 6.3.0

package/dist/domain/javascript/javascriptStaticAnalysisHelpers.js

@@ -2,8 +2,8 @@ import { createHash } from "node:crypto";
 import { posix } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as t from "@babel/types";
-import { readExactJavaScriptLiteral, semanticStaticPropertyName, } from "./javascriptAstValues.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { compareUnicodeCodePoints, compositeKey, } from "../unicodeCodePointOrder.js";
 /** Explicit result for source text that Babel cannot parse. */
 export const failedJavaScriptStaticAnalysis = () => ({
     parse_status: "failed",
@@ -67,8 +67,9 @@ const findChunkRuntime = (node) => {
             pending.push(current.right, current.left);
             continue;
         }
-        if (t.isParenthesizedExpression(current) || t.isTSAsExpression(current))
-            pending.push(current.expression);
+        const unwrapped = unwrapJavaScriptExpression(current).node;
+        if (unwrapped !== current)
+            pending.push(unwrapped);
     }
     return undefined;
 };
@@ -102,26 +103,25 @@ export const staticArrayValues = (array) => {
         const value = argumentValue(element);
         return value === undefined ? [] : [value];
     });
-    const values = [...new Set(staticValues)].sort(compareCodePoints);
+    const values = [...new Set(staticValues)].sort(compareUnicodeCodePoints);
     return {
         values,
         unknown: array.elements.length - staticValues.length,
     };
 };
-/** Resolve a path composed only from inert literal syntax. */
-export const staticPath = (node) => staticPathAt(node);
 /** Classify whether inert path syntax is a module specifier or file expression. */
 export const staticPathResolutionContext = (node) => isFilesystemPathExpression(node)
     ? "filesystem-expression"
     : "module-specifier";
-const staticPathAt = (node) => {
+/** Resolve a path composed only from inert literal syntax. */
+export const staticPath = (node) => {
     if (t.isStringLiteral(node))
         return node.value;
     if (t.isTemplateLiteral(node) && node.expressions.length === 0)
         return stringValue(node);
     if (t.isBinaryExpression(node, { operator: "+" })) {
-        const left = staticPathAt(node.left);
-        const right = staticPathAt(node.right);
+        const left = staticPath(node.left);
+        const right = staticPath(node.right);
         return left === undefined || right === undefined
             ? undefined
             : `${left}${right}`;
@@ -152,7 +152,7 @@ const staticCallPath = (node) => {
     for (const argument of node.arguments) {
         if (isDirectoryIdentity(argumentNode(argument)))
             continue;
-        const value = t.isNode(argument) ? staticPathAt(argument) : undefined;
+        const value = t.isNode(argument) ? staticPath(argument) : undefined;
         if (value === undefined)
             return undefined;
         parts.push(value);
@@ -164,7 +164,7 @@ const staticFileUrlPath = (argument) => {
         return undefined;
     return isSourceFileUrl(argument)
         ? sourceRelativeFileUrlPath(argument)
-        : staticPathAt(argument);
+        : staticPath(argument);
 };
 /** Project a known source-relative URL through the actual file URL decoder. */
 const sourceRelativeFileUrlPath = (node) => {
@@ -213,7 +213,7 @@ const staticResolvedPath = (node) => {
             parts.push(null);
             continue;
         }
-        const value = t.isNode(argument) ? staticPathAt(argument) : undefined;
+        const value = t.isNode(argument) ? staticPath(argument) : undefined;
         // Validate every argument, including those before the last anchor.
         if (value === undefined)
             return undefined;
@@ -521,9 +521,20 @@ const pointForOffset = (source, offset) => {
 /** Observe known bundler/framework marker strings without claiming dependency use. */
 export const detectVendors = (source) => vendorPatterns.flatMap(({ name, patterns }) => patterns.some((pattern) => source.includes(pattern)) ? [name] : []);
 /** Commit the static semantic content used to deduplicate registrations. */
-export const registrationKey = (registration) => `${registration.runtime}\0${registration.chunk_keys.join("\0")}\0${String(registration.unknown_chunk_keys)}\0${registration.modules.map(({ module_key: key, source_sha256: digest }) => `${key}:${digest}`).join("\0")}`;
+export const registrationKey = (registration) => 
+// Collision-free tuple: chunk/module keys are variable-length source-derived
+// lists, so NUL-joins would collapse ["a\0b"] with ["a", "b"].
+compositeKey([
+    registration.runtime,
+    registration.chunk_keys,
+    String(registration.unknown_chunk_keys),
+    registration.modules.map(({ module_key: key, source_sha256: digest }) => [
+        key,
+        digest,
+    ]),
+]);
 /** Sort values by a deterministic unique semantic key. */
-export const sortedUnique = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => compareCodePoints(key(left), key(right)));
+export const sortedUnique = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => compareUnicodeCodePoints(key(left), key(right)));
 /** Hash exact UTF-8 source text. */
 export const sha256Text = (value) => createHash("sha256").update(value).digest("hex");
 /** Recognized route-construction call suffixes. */

package/dist/domain/javascript/sourceToBundleComparison.js

@@ -1,5 +1,7 @@
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
-import { absenceClaimable, canonicalDigest } from "../comparisonSemantics.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { absenceClaimable } from "../comparisonSemantics.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
 import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, sourceToBundleComparisonResultSchema, } from "./sourceToBundleComparisonSchemas.js";
 import { buildSourceToBundleCandidateIndex, candidateHasDigest, candidateIdsForSource, historicalSourceFiles, scoreSourceToBundleCandidate, sourceBearingNodes, } from "./sourceToBundleSignals.js";
 /** Compare historical source files to static source-bearing application nodes. */
@@ -33,7 +35,7 @@ export const compareSourceToBundle = (input) => {
     };
     return sourceToBundleComparisonResultSchema.parse({
         ...semanticResult,
-        comparison_id: `stbc_${canonicalDigest(semanticResult, "Source-to-bundle comparison")}`,
+        comparison_id: `stbc_${digestCanonicalValue(semanticResult, "Source-to-bundle comparison")}`,
     });
 };
 const projectComparison = (input) => {
@@ -218,7 +220,7 @@ const markMergedMappings = (input, items) => {
         return { ...semantic, mapping_id: mappingId(input, semantic) };
     });
 };
-const mappingId = (input, item) => `stbc_item_${canonicalDigest({
+const mappingId = (input, item) => `stbc_item_${digestCanonicalValue({
     reference_root_sha256: input.reference.root_sha256,
     application_graph_id: input.application.graph.graph_id,
     ...item,
@@ -256,4 +258,4 @@ const comparisonLimitations = (factors) => uniqueSorted([
 ]);
 const hasSignal = (candidate, kind) => candidate.signals.some((signal) => signal.kind === kind);
 const compareCandidates = (left, right) => right.score - left.score ||
-    compareCodePoints(left.current_node_id, right.current_node_id);
+    compareUnicodeCodePoints(left.current_node_id, right.current_node_id);

package/dist/domain/javascript/sourceToBundleSignals.js

@@ -1,5 +1,5 @@
 import { posix } from "node:path";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints, compositeKey, } from "../unicodeCodePointOrder.js";
 import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, } from "./sourceToBundleComparisonSchemas.js";
 import { isDigest } from "../digests.js";
 const RELEVANT_NODE_KINDS = new Set([
@@ -24,11 +24,11 @@ const signalWeight = (kind) => {
 /** Keep source-bearing application nodes in stable identifier order. */
 export const sourceBearingNodes = (nodes) => nodes
     .filter(({ kind }) => RELEVANT_NODE_KINDS.has(kind))
-    .sort((left, right) => compareCodePoints(left.node_id, right.node_id));
+    .sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id));
 /** Keep historical source files in stable path order. */
 export const historicalSourceFiles = (graph) => graph.entries
     .filter((entry) => entry.kind === "file" && entry.classifications.includes("source"))
-    .sort((left, right) => compareCodePoints(left.path, right.path));
+    .sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
 /** Build deterministic candidate indices without assigning fuzzy matches. */
 export const buildSourceToBundleCandidateIndex = (nodes) => {
     const projections = nodes.map(projectCurrentNode);
@@ -65,7 +65,7 @@ export const candidateIdsForSource = (source, index) => {
     for (const group of groups) {
         if (group === undefined)
             continue;
-        for (const nodeId of [...group].sort(compareCodePoints)) {
+        for (const nodeId of [...group].sort(compareUnicodeCodePoints)) {
             if (seen.has(nodeId))
                 continue;
             seen.add(nodeId);
@@ -166,7 +166,7 @@ const signal = (kind, sourceValue, currentValues) => ({
     kind,
     weight: signalWeight(kind),
     source_value: sourceValue,
-    current_values: [...new Set(currentValues)].sort(compareCodePoints),
+    current_values: [...new Set(currentValues)].sort(compareUnicodeCodePoints),
 });
 const candidateConfidence = (signals) => {
     const kinds = new Set(signals.map(({ kind }) => kind));
@@ -216,10 +216,10 @@ const normalizeCurrentPath = (raw) => {
 };
 const uniquePaths = (paths) => [
     ...new Map(paths.map((path) => [
-        `${path.kind}\0${path.value}\0${String(path.allowSuffix)}`,
+        compositeKey([path.kind, path.value, String(path.allowSuffix)]),
         path,
     ])).values(),
-].sort((left, right) => compareCodePoints(`${left.kind}\0${left.value}`, `${right.kind}\0${right.value}`));
+].sort((left, right) => compareUnicodeCodePoints(compositeKey([left.kind, left.value]), compositeKey([right.kind, right.value])));
 const pathSuffixes = (path) => {
     const parts = path.split("/");
     return parts.map((_, index) => parts.slice(index).join("/"));

package/dist/domain/jsonSerialization.js

@@ -1,10 +1,10 @@
 /** Encode ordinary JSON as bounded string parts without a document-sized allocation. */
 export function* jsonParts(value, pretty = false) {
-    yield* encodeValue(value, pretty, 0, new Set(), false);
+    yield* encodeValue(value, pretty, false);
 }
 /** Encode validated JSON with canonical key ordering without allocating the whole document. */
 export function* canonicalJsonParts(value) {
-    yield* encodeValue(value, false, 0, new Set(), true);
+    yield* encodeValue(value, false, true);
 }
 /** Buffer JSON parts while preserving complete UTF-16 surrogate pairs. */
 export function* bufferedJsonParts(parts) {
@@ -41,69 +41,123 @@ function* encodeString(value) {
     }
     yield '"';
 }
-function* encodeValue(value, pretty, depth, ancestors, canonical) {
-    if (typeof value === "string") {
-        yield* encodeString(value);
-        return;
-    }
-    if (value === null || typeof value === "boolean") {
-        yield value === null ? "null" : String(value);
-        return;
-    }
-    if (typeof value === "number" && Number.isFinite(value)) {
-        yield String(value);
-        return;
-    }
+/** Encoded text accumulated before it is yielded as one part. */
+const PART_CHARACTERS = 16 * 1024;
+const indentation = [];
+const indent = (depth) => (indentation[depth] ??= `\n${"  ".repeat(depth)}`);
+/** Encoded text of a scalar, or undefined for a container or a long string. */
+const scalarText = (value) => {
+    if (typeof value === "string")
+        return value.length <= 8192 ? JSON.stringify(value) : undefined;
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return String(value);
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    return undefined;
+};
+const openContainer = (value, depth, ancestors, canonical) => {
     if (typeof value !== "object" || value === null)
         throw new TypeError("JSON output requires ordinary JSON values");
     if (ancestors.has(value))
         throw new TypeError("JSON output contains a circular reference");
-    if (!Array.isArray(value) &&
-        Object.prototype.toString.call(value) !== "[object Object]")
+    const array = Array.isArray(value);
+    if (!array && Object.prototype.toString.call(value) !== "[object Object]")
         throw new TypeError("JSON output requires ordinary JSON objects");
     ancestors.add(value);
-    try {
-        const array = Array.isArray(value);
-        const keys = array ? undefined : Object.keys(value);
-        if (canonical)
-            keys?.sort();
-        const count = array ? value.length : (keys?.length ?? 0);
-        let written = 0;
-        yield array ? "[" : "{";
-        for (let index = 0; index < count; index += 1) {
-            let item;
-            let key;
-            if (array) {
-                item = value[index];
+    const keys = array ? undefined : Object.keys(value);
+    if (canonical)
+        keys?.sort();
+    const count = array ? value.length : (keys?.length ?? 0);
+    return { value, array, keys, count, depth, index: 0, written: 0 };
+};
+/** The next written member of a container, skipping values JSON omits. */
+const nextMember = (frame) => {
+    while (frame.index < frame.count) {
+        const index = frame.index;
+        frame.index += 1;
+        if (frame.array)
+            return { key: undefined, item: Reflect.get(frame.value, index) };
+        const key = frame.keys?.[index];
+        if (key === undefined)
+            throw new TypeError("JSON object changed during serialization");
+        const item = Reflect.get(frame.value, key);
+        // Incur's filter can select inherited methods. Match native JSON's
+        // omission without eagerly reading the rest of a bounded result.
+        if (item !== undefined &&
+            typeof item !== "function" &&
+            typeof item !== "symbol")
+            return { key, item };
+    }
+    return undefined;
+};
+/**
+ * Encode iteratively into bounded parts. Recursive `yield*` delegation passed
+ * every token through one generator frame per nesting level, which dominated
+ * the cost of writing large nested results.
+ */
+function* encodeValue(root, pretty, canonical) {
+    const ancestors = new Set();
+    const stack = [];
+    let buffer = "";
+    let pending = root;
+    let hasPending = true;
+    while (true) {
+        if (hasPending) {
+            hasPending = false;
+            const text = scalarText(pending);
+            if (text !== undefined)
+                buffer += text;
+            else if (typeof pending === "string") {
+                // A long string is split into surrogate-safe parts of its own.
+                if (buffer !== "")
+                    yield buffer;
+                buffer = "";
+                yield* encodeString(pending);
             }
             else {
-                key = keys?.[index];
-                if (key === undefined)
-                    throw new TypeError("JSON object changed during serialization");
-                item = Reflect.get(value, key);
-                // Incur's filter can select inherited methods. Match native JSON's
-                // omission without eagerly reading the rest of a bounded result.
-                if (item === undefined ||
-                    typeof item === "function" ||
-                    typeof item === "symbol")
-                    continue;
+                const frame = openContainer(pending, stack.length, ancestors, canonical);
+                stack.push(frame);
+                buffer += frame.array ? "[" : "{";
             }
-            if (written > 0)
-                yield ",";
-            if (pretty)
-                yield `\n${"  ".repeat(depth + 1)}`;
-            if (key !== undefined) {
-                yield* encodeString(key);
-                yield pretty ? ": " : ":";
+        }
+        if (buffer.length >= PART_CHARACTERS) {
+            yield buffer;
+            buffer = "";
+        }
+        const frame = stack.at(-1);
+        if (frame === undefined)
+            break;
+        const member = nextMember(frame);
+        if (member === undefined) {
+            if (pretty && frame.written > 0)
+                buffer += indent(frame.depth);
+            buffer += frame.array ? "]" : "}";
+            ancestors.delete(frame.value);
+            stack.pop();
+            continue;
+        }
+        if (frame.written > 0)
+            buffer += ",";
+        if (pretty)
+            buffer += indent(frame.depth + 1);
+        if (member.key !== undefined) {
+            const key = scalarText(member.key);
+            if (key !== undefined)
+                buffer += key;
+            else {
+                if (buffer !== "")
+                    yield buffer;
+                buffer = "";
+                yield* encodeString(member.key);
             }
-            yield* encodeValue(item, pretty, depth + 1, ancestors, canonical);
-            written += 1;
+            buffer += pretty ? ": " : ":";
         }
-        if (pretty && written > 0)
-            yield `\n${"  ".repeat(depth)}`;
-        yield array ? "]" : "}";
-    }
-    finally {
-        ancestors.delete(value);
+        frame.written += 1;
+        pending = member.item;
+        hasPending = true;
     }
+    if (buffer !== "")
+        yield buffer;
 }

package/dist/domain/jsonShape.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 const jsonValueTypeSchema = z.enum([
     "object",
     "array",
@@ -8,13 +8,17 @@ const jsonValueTypeSchema = z.enum([
     "boolean",
     "null",
 ]);
+const jsonShapePathSegmentSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("property"), name: z.string() }),
+    z.object({ kind: z.literal("array-element") }),
+]);
 /** Value-free structural summary of one approved JSON payload. */
 export const jsonShapeSchema = z.object({
     root_type: jsonValueTypeSchema,
     node_count: z.number().int().min(1),
     max_depth_observed: z.number().int().min(0),
     properties: z.array(z.object({
-        path: z.string(),
+        path: z.array(jsonShapePathSegmentSchema).min(1),
         types: z.array(jsonValueTypeSchema).min(1),
         observations: z.number().int().min(1),
     })),
@@ -31,7 +35,7 @@ export const inferJsonShape = (text) => {
         return null;
     }
     const properties = new Map();
-    const pending = [{ value: root, path: "", depth: 0 }];
+    const pending = [{ value: root, path: [], depth: 0 }];
     let nodeCount = 0;
     let maxDepthObserved = 0;
     while (pending.length > 0) {
@@ -40,11 +44,26 @@ export const inferJsonShape = (text) => {
             break;
         nodeCount += 1;
         maxDepthObserved = Math.max(maxDepthObserved, current.depth);
+        if (current.path.length > 0) {
+            const key = JSON.stringify(current.path);
+            const type = jsonValueType(current.value);
+            const existing = properties.get(key);
+            if (existing === undefined)
+                properties.set(key, {
+                    path: current.path,
+                    types: new Set([type]),
+                    observations: 1,
+                });
+            else {
+                existing.types.add(type);
+                existing.observations += 1;
+            }
+        }
         if (Array.isArray(current.value)) {
             for (let index = current.value.length - 1; index >= 0; index -= 1)
                 pending.push({
                     value: current.value[index],
-                    path: `${current.path}/*`,
+                    path: [...current.path, { kind: "array-element" }],
                     depth: current.depth + 1,
                 });
             continue;
@@ -57,15 +76,10 @@ export const inferJsonShape = (text) => {
             if (entry === undefined)
                 continue;
             const [name, value] = entry;
-            const path = `${current.path}/${pointerName(name)}`;
-            const type = jsonValueType(value);
-            const existing = properties.get(path);
-            if (existing === undefined)
-                properties.set(path, { types: new Set([type]), observations: 1 });
-            else {
-                existing.types.add(type);
-                existing.observations += 1;
-            }
+            const path = [
+                ...current.path,
+                { kind: "property", name },
+            ];
             pending.push({ value, path, depth: current.depth + 1 });
         }
     }
@@ -73,14 +87,13 @@ export const inferJsonShape = (text) => {
         root_type: jsonValueType(root),
         node_count: nodeCount,
         max_depth_observed: maxDepthObserved,
-        properties: [...properties.entries()]
-            .map(([path, value]) => ({
-            path,
+        properties: [...properties.values()]
+            .map((value) => ({
+            path: value.path,
             types: [...value.types].sort(),
             observations: value.observations,
         }))
-            .sort((left, right) => left.path.localeCompare(right.path) ||
-            compareCodePoints(left.path, right.path)),
+            .sort((left, right) => compareShapePaths(left.path, right.path)),
     });
 };
 const jsonValueType = (value) => {
@@ -100,4 +113,18 @@ const jsonValueType = (value) => {
     }
 };
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const pointerName = (value) => value.replaceAll("~", "~0").replaceAll("/", "~1");
+const compareShapePaths = (left, right) => {
+    for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+        const a = left[index];
+        const b = right[index];
+        if (a === undefined || b === undefined)
+            break;
+        const order = compareUnicodeCodePoints(a.kind, b.kind) ||
+            (a.kind === "property" && b.kind === "property"
+                ? compareUnicodeCodePoints(a.name, b.name)
+                : 0);
+        if (order !== 0)
+            return order;
+    }
+    return left.length - right.length;
+};

package/dist/domain/localPath.js

@@ -1,12 +1,18 @@
 import { isAbsolute, relative, sep } from "node:path";
 import { z } from "zod";
-/** Preserve selected filesystem names while rejecting OS-invalid NUL bytes. */
+/**
+ * Preserve selected filesystem names while rejecting OS-invalid NUL bytes.
+ *
+ * The pattern spells NUL as `\x00` rather than `\u0000`. Both accept exactly the
+ * same strings. The hex form also avoids the short `\0` spelling rejected by
+ * strict schema consumers. A client can reject its entire tool request when
+ * one advertised pattern cannot compile. See `offsetDateTimeSchema` for the
+ * same hex-escape convention.
+ */
 export const localPathStringSchema = z
     .string()
     .min(1)
-    .regex(/^[^\u0000]*$/u, "Local filesystem paths cannot contain NUL");
-/** True when the value is an absolute filesystem path on the host platform. */
-export const isAbsoluteLocalPath = (value) => isAbsolute(value);
+    .regex(/^[^\x00]*$/u, "Local filesystem paths cannot contain NUL");
 /** Test lexical containment on the host platform; callers must resolve symlinks first. */
 export const isPathWithinRoot = (root, path) => {
     const value = relative(root, path);

package/dist/domain/managed/managedApplicationGraph.js

@@ -82,8 +82,8 @@ export const projectManagedApplicationGraph = (input) => {
     };
     const artifactNode = addArtifactNode(state);
     addArtifactIdentityNodes(state, artifactNode, parsed);
-    const memberCounts = addMemberNodes(state, artifactNode, parsed);
-    const boundaryCounts = addBoundaryNodes(state, artifactNode, parsed);
+    addMemberNodes(state, artifactNode, parsed);
+    addBoundaryNodes(state, artifactNode, parsed);
     const omissions = omittedCounts(parsed);
     const limitations = projectionLimitations(parsed, omissions);
     const graph = createJavaScriptApplicationGraph({
@@ -104,10 +104,13 @@ export const projectManagedApplicationGraph = (input) => {
         summary: {
             graph_nodes: graph.nodes.length,
             graph_edges: graph.edges.length,
-            assemblies: parsed.artifact?.result.assembly === null ? 0 : 1,
-            modules: parsed.artifact?.result.module === null ? 0 : 1,
-            ...memberCounts,
-            ...boundaryCounts,
+            assemblies: countNodes(graph.nodes, "managed-assembly"),
+            modules: countNodes(graph.nodes, "managed-module"),
+            types: countNodes(graph.nodes, "managed-type"),
+            methods: countNodes(graph.nodes, "managed-method"),
+            fields: countNodes(graph.nodes, "managed-field"),
+            pinvoke_imports: countNodes(graph.nodes, "managed-pinvoke-import"),
+            native_implementations: countNodes(graph.nodes, "managed-native-implementation"),
         },
         graph,
         coverage: managedGraphResultCoverage(omissions),
@@ -119,6 +122,7 @@ export const projectManagedApplicationGraph = (input) => {
         projection_id: `magp_${sha256(withoutId)}`,
     });
 };
+const countNodes = (nodes, kind) => nodes.filter((node) => node.kind === kind).length;
 const parseManagedInputs = (input) => ({
     artifact: input.managed_artifact === undefined
         ? null