Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

perf(domain): order JSON shapes through their structural tree

morluto31bfff6fdff0
diff --git a/src/domain/jsonShape.test.ts b/src/domain/jsonShape.test.ts
index 136c58381..ba0165ffa 100644
--- a/src/domain/jsonShape.test.ts
+++ b/src/domain/jsonShape.test.ts
@@ -1,6 +1,6 @@
import { describe, expect, it } from "vitest";
-import { inferJsonShape } from "./jsonShape.js";
+import { inferJsonShape, jsonShapeSchema } from "./jsonShape.js";
const property = (name: string) => ({ kind: "property" as const, name });
const element = { kind: "array-element" as const };
@@ -68,6 +68,40 @@ describe("inferJsonShape", () => {
it("rejects malformed JSON", () => {
expect(inferJsonShape("not-json")).toBeNull();
});
+
+ it("orders mixed array and property descendants with parents first", () => {
+ const shape = inferJsonShape('[{"z":1,"a":{"x":true}},[null],{"a":2}]');
+
+ expect(shape?.properties.map(({ path }) => path)).toEqual([
+ [element],
+ [element, element],
+ [element, property("a")],
+ [element, property("a"), property("x")],
+ [element, property("z")],
+ ]);
+ expect(shape?.properties[2]).toMatchObject({
+ types: ["number", "object"],
+ observations: 2,
+ });
+ });
+
+ it("retains deep coverage and independently owned path segments", () => {
+ const depth = 512;
+ const shape = inferJsonShape("[".repeat(depth) + "1" + "]".repeat(depth));
+ expect(shape).not.toBeNull();
+ if (shape === null) return;
+
+ expect(shape.node_count).toBe(depth + 1);
+ expect(shape.max_depth_observed).toBe(depth);
+ expect(shape.properties).toHaveLength(depth);
+ expect(shape.properties.at(-1)).toEqual({
+ path: Array.from({ length: depth }, () => element),
+ types: ["number"],
+ observations: 1,
+ });
+ expect(jsonShapeSchema.parse(shape)).toEqual(shape);
+ expect(shape.properties[0]?.path[0]).not.toBe(shape.properties[1]?.path[0]);
+ });
});
describe("JSON shape completeness and ordering", () => {
diff --git a/src/domain/jsonShape.ts b/src/domain/jsonShape.ts
index 1772585d1..9e158a718 100644
--- a/src/domain/jsonShape.ts
+++ b/src/domain/jsonShape.ts
@@ -52,7 +52,6 @@ export const inferJsonShape = (text: string): JsonShape | null => {
void cause;
return null;
}
- const properties: ShapeNode[] = [];
const rootShape: ShapeNode = {
path: [],
types: new Set(),
@@ -77,7 +76,6 @@ export const inferJsonShape = (text: string): JsonShape | null => {
observations: 0,
};
children.set(key, node);
- properties.push(node);
return node;
};
const pending: Array<{
@@ -109,18 +107,26 @@ export const inferJsonShape = (text: string): JsonShape | null => {
pending.push({ value, shape: childShape(current.shape, name) });
}
}
- return jsonShapeSchema.parse({
+ // Preorder over sorted siblings gives canonical paths without repeatedly
+ // comparing their shared prefixes. Each returned path owns its segments.
+ const properties: JsonShape["properties"] = [];
+ const shapes = orderedChildren(rootShape);
+ while (shapes.length > 0) {
+ const shape = shapes.pop();
+ if (shape === undefined) break;
+ properties.push({
+ path: shape.path.map((segment) => ({ ...segment })),
+ types: [...shape.types].sort(),
+ observations: shape.observations,
+ });
+ for (const child of orderedChildren(shape)) shapes.push(child);
+ }
+ return {
root_type: jsonValueType(root),
node_count: nodeCount,
max_depth_observed: maxDepthObserved,
- properties: properties
- .map((value) => ({
- path: value.path,
- types: [...value.types].sort(),
- observations: value.observations,
- }))
- .sort((left, right) => compareShapePaths(left.path, right.path)),
- });
+ properties,
+ };
};
const jsonValueType = (value: unknown): JsonValueType => {
@@ -141,20 +147,16 @@ const jsonValueType = (value: unknown): JsonValueType => {
const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
typeof value === "object" && value !== null && !Array.isArray(value);
-const compareShapePaths = (
- left: readonly JsonShapePathSegment[],
- right: readonly JsonShapePathSegment[],
-): number => {
- 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;
-};
+/** Reverse sibling order for the traversal stack; array elements sort first. */
+const orderedChildren = (node: ShapeNode): ShapeNode[] =>
+ [...(node.children ?? [])]
+ .sort(([left], [right]) =>
+ left === right
+ ? 0
+ : left === arrayElementKey
+ ? 1
+ : right === arrayElementKey
+ ? -1
+ : compareUnicodeCodePoints(right, left),
+ )
+ .map(([, child]) => child);