rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptStaticAnalysisHelpers.js

@@ -2,9 +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";
-export { propertyName, semanticStaticPropertyName, } from "./javascriptAstValues.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",
@@ -68,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;
 };
@@ -103,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}`;
@@ -153,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);
@@ -165,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) => {
@@ -214,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;
@@ -522,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,7 +1,9 @@
-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, candidateIdsForSource, historicalSourceFiles, scoreSourceToBundleCandidate, sourceBearingNodes, } from "./sourceToBundleSignals.js";
+import { buildSourceToBundleCandidateIndex, candidateHasDigest, candidateIdsForSource, historicalSourceFiles, scoreSourceToBundleCandidate, sourceBearingNodes, } from "./sourceToBundleSignals.js";
 /** Compare historical source files to static source-bearing application nodes. */
 export const compareSourceToBundle = (input) => {
     const projection = projectComparison(input);
@@ -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) => {
@@ -63,7 +65,7 @@ const compareMappings = (input, projection) => {
             .map((nodeId) => scoreSourceToBundleCandidate(source, nodeId, projection.index))
             .filter((candidate) => candidate !== null)
             .sort(compareCandidates);
-        const classification = classifyMapping(scored, projection.absenceComplete);
+        const classification = classifyMapping(scored, projection.absenceComplete, (nodeId) => source.sha256 !== null && candidateHasDigest(projection.index, nodeId));
         const semantic = {
             source_path: source.path,
             source_sha256: source.sha256,
@@ -103,7 +105,7 @@ const scoringModel = () => ({
         weight,
     })),
 });
-const classifyMapping = (candidates, absenceComplete) => {
+const classifyMapping = (candidates, absenceComplete, digestComparable) => {
     const exact = candidates.filter((candidate) => hasSignal(candidate, "exact-source-digest"));
     if (exact.length === 1)
         return {
@@ -134,6 +136,15 @@ const classifyMapping = (candidates, absenceComplete) => {
         : pathCandidates.filter(({ score }) => score === topScore);
     if (topPathCandidates.length === 1) {
         const candidate = topPathCandidates[0];
+        if (candidate !== undefined && digestComparable(candidate.current_node_id))
+            return {
+                status: "modified",
+                confidence: candidate.confidence === "high" ? "high" : "medium",
+                currentNodeIds: [candidate.current_node_id],
+                limitations: [
+                    "Location evidence links the source to the current node, but their source digests differ.",
+                ],
+            };
         return {
             status: "unknown",
             confidence: "unknown",
@@ -209,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,
@@ -247,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);
@@ -39,7 +39,9 @@ export const buildSourceToBundleCandidateIndex = (nodes) => {
         for (const digest of projection.digests)
             addIndexValue(byDigest, digest, projection.node.node_id);
         for (const path of projection.paths) {
-            for (const suffix of pathSuffixes(path.value))
+            for (const suffix of path.allowSuffix
+                ? pathSuffixes(path.value)
+                : [path.value])
                 addIndexValue(byPathSuffix, suffix, projection.node.node_id);
             addIndexValue(byBasename, posix.basename(path.value), projection.node.node_id);
         }
@@ -63,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);
@@ -72,6 +74,8 @@ export const candidateIdsForSource = (source, index) => {
     }
     return output;
 };
+/** Whether an indexed candidate carries any content digest to compare. */
+export const candidateHasDigest = (index, nodeId) => (index.nodes.get(nodeId)?.digests.size ?? 0) > 0;
 /** Score one indexed candidate from explicit, caller-visible signals. */
 export const scoreSourceToBundleCandidate = (source, nodeId, index) => {
     const projection = index.nodes.get(nodeId);
@@ -97,16 +101,26 @@ const projectCurrentNode = (node) => {
     if (node.identity.strategy === "source-map-original") {
         if (node.identity.source_sha256 !== null)
             digests.add(node.identity.source_sha256);
-        addPath(paths, "source-map-original", node.identity.original_source);
     }
     if (node.identity.strategy === "canonical-path")
         addPath(paths, "canonical-path", node.identity.path);
     for (const observation of node.observations) {
-        const sourceDigest = observation.properties.source_sha256;
-        if (typeof sourceDigest === "string" && isDigest(sourceDigest))
-            digests.add(sourceDigest);
-        for (const key of PATH_PROPERTIES)
-            addJsonPath(paths, observation.properties[key]);
+        if (node.identity.strategy === "source-map-original") {
+            const resolution = observation.source_map_reference?.resolution;
+            if (resolution !== undefined && resolution.kind !== "unresolved")
+                paths.push({
+                    kind: "source-map-original",
+                    value: resolution.path,
+                    allowSuffix: resolution.kind === "suffix",
+                });
+        }
+        else {
+            const sourceDigest = observation.properties.source_sha256;
+            if (typeof sourceDigest === "string" && isDigest(sourceDigest))
+                digests.add(sourceDigest);
+            for (const key of PATH_PROPERTIES)
+                addJsonPath(paths, observation.properties[key]);
+        }
     }
     return {
         node,
@@ -128,7 +142,9 @@ const candidateSignals = (source, current) => {
     if (exactPaths.length > 0)
         signals.push(signal("current-path-exact", source.path, exactPaths));
     const suffixPaths = otherPaths
-        .filter(({ value }) => value !== source.path && value.endsWith(`/${source.path}`))
+        .filter(({ value, allowSuffix }) => allowSuffix &&
+        value !== source.path &&
+        value.endsWith(`/${source.path}`))
         .map(({ value }) => value);
     if (suffixPaths.length > 0)
         signals.push(signal("current-path-suffix", source.path, suffixPaths));
@@ -150,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));
@@ -161,7 +177,8 @@ const candidateConfidence = (signals) => {
     return kinds.has("current-path-suffix") ? "medium" : "low";
 };
 const matchingPaths = (sourcePath, currentPaths) => currentPaths
-    .filter(({ value }) => value === sourcePath || value.endsWith(`/${sourcePath}`))
+    .filter(({ value, allowSuffix }) => value === sourcePath ||
+    (allowSuffix && value.endsWith(`/${sourcePath}`)))
     .map(({ value }) => value);
 const addJsonPath = (paths, value) => {
     if (typeof value === "string")
@@ -170,28 +187,39 @@ const addJsonPath = (paths, value) => {
 const addPath = (paths, kind, raw) => {
     const value = normalizeCurrentPath(raw);
     if (value !== null)
-        paths.push({ kind, value });
+        paths.push({ kind, value, allowSuffix: true });
 };
-/** Matches a `scheme://...` URL prefix; bare filesystem paths keep `?`/`#`. */
 const SCHEME_URL = /^[a-z][a-z0-9+.-]*:\/\//iu;
-/** Matches a `scheme://...` URL prefix with any run of slashes, for stripping. */
 const SCHEME_URL_PREFIX = /^[a-z][a-z0-9+.-]*:\/\/+/iu;
 const normalizeCurrentPath = (raw) => {
     const withoutQuery = SCHEME_URL.test(raw)
         ? (raw.split(/[?#]/u, 1)[0] ?? "")
         : raw;
-    const withoutScheme = withoutQuery.replace(SCHEME_URL_PREFIX, "");
-    const parts = withoutScheme
-        .replaceAll("\\", "/")
-        .split("/")
-        .filter((part) => part !== "" && part !== ".");
-    if (parts.length === 0 || parts.includes(".."))
+    const portable = withoutQuery
+        .replace(SCHEME_URL_PREFIX, "")
+        .replaceAll("\\", "/");
+    const parts = [];
+    for (const part of portable.split("/")) {
+        if (part === "" || part === ".")
+            continue;
+        if (part === "..") {
+            if (parts.length === 0)
+                return null;
+            parts.pop();
+        }
+        else
+            parts.push(part);
+    }
+    if (parts.length === 0)
         return null;
     return parts.join("/");
 };
 const uniquePaths = (paths) => [
-    ...new Map(paths.map((path) => [`${path.kind}\0${path.value}`, path])).values(),
-].sort((left, right) => compareCodePoints(`${left.kind}\0${left.value}`, `${right.kind}\0${right.value}`));
+    ...new Map(paths.map((path) => [
+        compositeKey([path.kind, path.value, String(path.allowSuffix)]),
+        path,
+    ])).values(),
+].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;
+};