rea-agents 3.0.0 → 3.2.0

package/dist/domain/javascriptAstFingerprint.js

@@ -1,57 +1,39 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
-/** Derive a rename-resistant, bounded syntax fingerprint without code execution. */
-export const fingerprintJavaScriptAst = (node, maximumTokens) => {
+import { propertyName } from "./javascriptAstValues.js";
+/** Derive a rename-resistant syntax fingerprint without code execution. */
+export const fingerprintJavaScriptAst = (node) => {
     const tokens = [];
-    let truncated = false;
     t.traverseFast(node, (current) => {
-        if (tokens.length >= maximumTokens) {
-            truncated = true;
-            return t.traverseFast.stop;
-        }
         tokens.push(...semanticTokens(current));
-        if (tokens.length > maximumTokens) {
-            tokens.length = maximumTokens;
-            truncated = true;
-            return t.traverseFast.stop;
-        }
         return undefined;
     });
-    return {
-        sha256: createHash("sha256").update(JSON.stringify(tokens)).digest("hex"),
-        truncated,
-    };
+    return createHash("sha256").update(JSON.stringify(tokens)).digest("hex");
 };
 /** Collect statically declared CommonJS/bundler export names from one factory. */
-export const collectJavaScriptExports = (node, maximumExports) => {
+export const collectJavaScriptExports = (node) => {
     const exports = new Set();
-    let truncated = false;
     t.traverseFast(node, (current) => {
-        if (exports.size >= maximumExports) {
-            truncated = true;
-            return t.traverseFast.stop;
-        }
         if (t.isAssignmentExpression(current))
-            collectAssignmentExports(current.left, current.right, exports, maximumExports);
+            collectAssignmentExports(current.left, current.right, exports);
         if (t.isCallExpression(current))
-            collectCallExports(current, exports, maximumExports);
+            collectCallExports(current, exports);
         return undefined;
     });
     return {
         values: [...exports].sort(compareCodePoints),
-        truncated,
     };
 };
 const semanticTokens = (node) => {
     const tokens = [`node:${node.type}`];
     if (t.isStringLiteral(node))
-        tokens.push(`string:${bounded(node.value)}`);
+        tokens.push(`string:${node.value}`);
     else if (t.isNumericLiteral(node))
         tokens.push(`number:${String(node.value)}`);
     else if (t.isBooleanLiteral(node))
         tokens.push(`boolean:${String(node.value)}`);
     else if (t.isRegExpLiteral(node))
-        tokens.push(`regexp:${bounded(node.pattern)}/${node.flags}`);
+        tokens.push(`regexp:${node.pattern}/${node.flags}`);
     else if (t.isBinaryExpression(node) || t.isLogicalExpression(node))
         tokens.push(`operator:${node.operator}`);
     else if (t.isUnaryExpression(node) || t.isUpdateExpression(node))
@@ -59,36 +41,36 @@ const semanticTokens = (node) => {
     if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
         const property = propertyName(node.property);
         if (property !== "")
-            tokens.push(`property:${bounded(property)}`);
+            tokens.push(`property:${property}`);
     }
     if ((t.isObjectProperty(node) || t.isObjectMethod(node)) && !node.computed) {
         const key = propertyName(node.key);
         if (key !== "")
-            tokens.push(`key:${bounded(key)}`);
+            tokens.push(`key:${key}`);
     }
     return tokens;
 };
-const collectAssignmentExports = (left, right, output, maximum) => {
+const collectAssignmentExports = (left, right, output) => {
     const path = memberPath(left);
     if (path === "exports" || path === "module.exports") {
         if (t.isObjectExpression(right))
-            collectObjectKeys(right, output, maximum);
+            collectObjectKeys(right, output);
         else
-            addExport(output, "default", maximum);
+            addExport(output, "default");
         return;
     }
     if (path.startsWith("exports."))
-        addExport(output, path.slice("exports.".length), maximum);
+        addExport(output, path.slice("exports.".length));
     if (path.startsWith("module.exports."))
-        addExport(output, path.slice("module.exports.".length), maximum);
+        addExport(output, path.slice("module.exports.".length));
 };
-const collectCallExports = (call, output, maximum) => {
+const collectCallExports = (call, output) => {
     const callee = memberPath(call.callee);
     if (callee === "Object.defineProperty") {
         const target = memberPath(call.arguments[0]);
         const name = stringValue(call.arguments[1]);
         if ((target === "exports" || target === "module.exports") && name)
-            addExport(output, name, maximum);
+            addExport(output, name);
     }
     if (!callee.endsWith(".d"))
         return;
@@ -96,26 +78,21 @@ const collectCallExports = (call, output, maximum) => {
     const declarations = call.arguments[1];
     if ((target === "exports" || target === "module.exports") &&
         t.isObjectExpression(declarations))
-        collectObjectKeys(declarations, output, maximum);
+        collectObjectKeys(declarations, output);
 };
-const collectObjectKeys = (object, output, maximum) => {
+const collectObjectKeys = (object, output) => {
     for (const property of object.properties) {
-        if (output.size >= maximum)
-            return;
         if (!t.isObjectProperty(property) && !t.isObjectMethod(property))
             continue;
         const name = propertyName(property.key);
         if (name !== "")
-            addExport(output, name, maximum);
+            addExport(output, name);
     }
 };
-const addExport = (output, name, maximum) => {
-    if (output.size < maximum)
-        output.add(name.slice(0, 4_096));
+const addExport = (output, name) => {
+    output.add(name);
 };
-const memberPath = (node, depth = 0) => {
-    if (depth >= 128)
-        return "[deep]";
+const memberPath = (node) => {
     if (node === undefined || node === null)
         return "";
     if (t.isIdentifier(node) || t.isPrivateName(node))
@@ -123,21 +100,11 @@ const memberPath = (node, depth = 0) => {
     if (t.isThisExpression(node))
         return "this";
     if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const object = t.isNode(node.object)
-            ? memberPath(node.object, depth + 1)
-            : "";
+        const object = t.isNode(node.object) ? memberPath(node.object) : "";
         const property = propertyName(node.property);
         return object === "" ? property : `${object}.${property}`;
     }
     return "";
 };
-const propertyName = (node) => {
-    if (t.isIdentifier(node))
-        return node.name;
-    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
-        return String(node.value);
-    return "";
-};
 const stringValue = (node) => t.isStringLiteral(node) ? node.value : undefined;
-const bounded = (value) => value.slice(0, 1_024);
 const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/domain/javascriptAstValues.js

@@ -0,0 +1,9 @@
+import * as t from "@babel/types";
+/** Read an identifier or literal property name without evaluating syntax. */
+export const propertyName = (node) => {
+    if (t.isIdentifier(node))
+        return node.name;
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
+        return String(node.value);
+    return "";
+};

package/dist/domain/javascriptExportInstrumentation.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 export const javascriptExportInstrumentationInputSchema = z.strictObject({
-    artifact_path: z.string().min(1).max(4_096),
+    artifact_path: z.string().min(1),
     artifact_sha256: digestSchema,
     selection: z.strictObject({
         byte_start: z.number().int().min(0),
@@ -12,9 +12,8 @@ export const javascriptExportInstrumentationInputSchema = z.strictObject({
     }),
 });
 export const javascriptExportTransformationManifestSchema = z.strictObject({
-    schema_version: z.literal(1),
     kind: z.literal("commonjs-factory-export-v1"),
-    artifact_path: z.string().min(1).max(4_096),
+    artifact_path: z.string().min(1),
     original_sha256: digestSchema,
     original_byte_length: z.number().int().min(0),
     instrumented_sha256: digestSchema,
@@ -55,7 +54,6 @@ export const instrumentJavaScriptExport = (source, rawInput) => {
     const bindingStart = prefix.byteLength + source.byteLength;
     const suffixStart = bindingStart + binding.byteLength;
     const manifest = javascriptExportTransformationManifestSchema.parse({
-        schema_version: 1,
         kind: "commonjs-factory-export-v1",
         artifact_path: input.artifact_path,
         original_sha256: input.artifact_sha256,

package/dist/domain/javascriptExportShapeComparison.js

@@ -5,10 +5,10 @@ import { retainJavaScriptExportShapes, selectJavaScriptExport, } from "./javascr
 import { buildJavaScriptExportShapeChanges, compareJavaScriptExportShapeChanges, hasPartialJavaScriptExportPropertyCoverage, pairJavaScriptExportShapeVariants, } from "./javascriptExportShapeVariants.js";
 /** Compare exact selected export return shapes without executing JavaScript. */
 export const compareJavaScriptExportShapes = (input) => {
-    const left = selectJavaScriptExport(input.left, input.limits.max_candidate_exports);
-    const right = selectJavaScriptExport(input.right, input.limits.max_candidate_exports);
-    const leftRetained = retainJavaScriptExportShapes(left, input.limits.max_return_variants);
-    const rightRetained = retainJavaScriptExportShapes(right, input.limits.max_return_variants);
+    const left = selectJavaScriptExport(input.left);
+    const right = selectJavaScriptExport(input.right);
+    const leftRetained = retainJavaScriptExportShapes(left);
+    const rightRetained = retainJavaScriptExportShapes(right);
     const pairing = pairJavaScriptExportShapeVariants(leftRetained.shapes, rightRetained.shapes);
     const evidenceLinks = evidencePair(input.left.evidenceId, input.right.evidenceId);
     const allChanges = buildJavaScriptExportShapeChanges({
@@ -19,8 +19,8 @@ export const compareJavaScriptExportShapes = (input) => {
         rightShapes: rightRetained.shapes,
         evidenceLinks,
     }).sort(compareJavaScriptExportShapeChanges);
-    const changes = allChanges.slice(0, input.limits.max_changes);
-    const omittedChanges = allChanges.length - changes.length;
+    const changes = allChanges;
+    const omittedChanges = 0;
     const coverage = comparisonCoverage({
         input,
         left,
@@ -33,7 +33,6 @@ export const compareJavaScriptExportShapes = (input) => {
     });
     const limitations = comparisonLimitations(left, right, coverage.status);
     const semantic = {
-        schema_version: 1,
         left: left.selection,
         right: right.selection,
         summary: summarize(allChanges),

package/dist/domain/javascriptExportShapeComparisonSchemas.js

@@ -3,10 +3,10 @@ import { evidenceSchema } from "./evidence.js";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const graphIdSchema = z.string().regex(/^jag_[a-f0-9]{64}$/u);
 const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
-const selectorTextSchema = z.string().min(1).max(4_096);
+const textSchema = z.string().min(1);
+const selectorTextSchema = textSchema;
 const semanticPrimitiveSchema = z.union([
-    z.string().max(4_096),
+    z.string(),
     z.number().finite(),
     z.boolean(),
     z.null(),
@@ -28,7 +28,6 @@ function isJsonPointer(value) {
 }
 const jsonPointerSchema = z
     .string()
-    .max(4_096)
     .refine(isJsonPointer, "Expected an RFC 6901 JSON Pointer");
 const sourcePointSchema = z.strictObject({
     line: z.number().int().min(1),
@@ -49,12 +48,7 @@ const sourceRangeSchema = z
             message: "Source range end must not precede its start",
         });
 });
-const comparisonLimitsSchema = z.strictObject({
-    max_candidate_exports: z.number().int().min(1).max(1_000).default(100),
-    max_return_variants: z.number().int().min(1).max(1_000).default(128),
-    max_changes: z.number().int().min(1).max(10_000).default(1_000),
-});
-/** Two authenticated application graphs, exact export selectors, and bounds. */
+/** Two authenticated application graphs and exact export selectors. */
 export const compareJavaScriptExportShapesInputSchema = z
     .strictObject({
     left: evidenceSchema,
@@ -63,12 +57,6 @@ export const compareJavaScriptExportShapesInputSchema = z
     left_export_name: selectorTextSchema,
     right_module_path: selectorTextSchema,
     right_export_name: selectorTextSchema,
-    limits: comparisonLimitsSchema.default({
-        max_candidate_exports: 100,
-        max_return_variants: 128,
-        max_changes: 1_000,
-    }),
-    unknown_registry_approved: z.literal(true).optional(),
 })
     .superRefine((input, context) => {
     if (input.left.evidence_id === input.right.evidence_id)
@@ -78,47 +66,39 @@ export const compareJavaScriptExportShapesInputSchema = z
             message: "JavaScript export shape Evidence must be distinct",
         });
 });
-const projectedReturnFieldSchema = z
-    .strictObject({
-    path: jsonPointerSchema,
-    state: z.enum(["literal", "union", "unknown"]),
-    value: z.union([
-        semanticPrimitiveSchema,
-        z.array(semanticPrimitiveSchema).min(1).max(32),
-    ]),
-    reason: boundedTextSchema.nullable(),
-})
-    .superRefine((field, context) => {
-    if (field.state === "union" && !Array.isArray(field.value))
-        context.addIssue({
-            code: "custom",
-            path: ["value"],
-            message: "Union return fields require a primitive value array",
-        });
-    if (field.state !== "union" && Array.isArray(field.value))
-        context.addIssue({
-            code: "custom",
-            path: ["value"],
-            message: "Only union return fields may contain a value array",
-        });
-    if (field.state === "unknown" && field.reason === null)
-        context.addIssue({
-            code: "custom",
-            path: ["reason"],
-            message: "Unknown return fields require a reason",
-        });
-    if (field.state !== "unknown" && field.reason !== null)
-        context.addIssue({
-            code: "custom",
-            path: ["reason"],
-            message: "Known return fields cannot carry an unknown reason",
-        });
-});
-const projectedPropertyCoverageSchema = z.strictObject({
-    path: jsonPointerSchema,
-    status: z.enum(["complete", "partial"]),
-    omitted: z.number().int().min(0).nullable(),
-});
+const projectedReturnFieldShape = { path: jsonPointerSchema };
+const projectedReturnFieldSchema = z.discriminatedUnion("state", [
+    z.strictObject({
+        ...projectedReturnFieldShape,
+        state: z.literal("literal"),
+        value: semanticPrimitiveSchema,
+        reason: z.null(),
+    }),
+    z.strictObject({
+        ...projectedReturnFieldShape,
+        state: z.literal("union"),
+        value: z.array(semanticPrimitiveSchema).min(1),
+        reason: z.null(),
+    }),
+    z.strictObject({
+        ...projectedReturnFieldShape,
+        state: z.literal("unknown"),
+        value: z.null(),
+        reason: textSchema,
+    }),
+]);
+const projectedPropertyCoverageSchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        path: jsonPointerSchema,
+        status: z.literal("complete"),
+        omitted: z.literal(0),
+    }),
+    z.strictObject({
+        path: jsonPointerSchema,
+        status: z.literal("partial"),
+        omitted: z.union([z.number().int().positive(), z.null()]),
+    }),
+]);
 const projectedReturnShapeSchema = z
     .strictObject({
     source_range: sourceRangeSchema,
@@ -130,10 +110,9 @@ const projectedReturnShapeSchema = z
         "unknown",
         "ambiguous",
         "cycle",
-        "limit-reached",
     ]),
-    fields: z.array(projectedReturnFieldSchema).max(64),
-    property_coverage: z.array(projectedPropertyCoverageSchema).max(64),
+    fields: z.array(projectedReturnFieldSchema),
+    property_coverage: z.array(projectedPropertyCoverageSchema),
 })
     .superRefine((shape, context) => {
     const fieldPaths = shape.fields.map(({ path }) => path);
@@ -157,12 +136,12 @@ export const projectedExportReturnShapesSchema = z
     semantic_role: z.literal("export-return-shapes"),
     module_path: selectorTextSchema,
     exported_name: selectorTextSchema,
-    callable_id: boundedTextSchema,
+    callable_id: textSchema,
     callable_kind: z.enum(["function", "class", "method"]),
-    static_return_shapes: z.array(projectedReturnShapeSchema).max(32),
+    static_return_shapes: z.array(projectedReturnShapeSchema),
     return_shape_coverage: z.strictObject({
         status: z.enum(["complete", "partial", "truncated"]),
-        retained_return_sites: z.number().int().min(0).max(32),
+        retained_return_sites: z.number().int().min(0),
         omitted_return_sites: z.number().int().min(0).nullable(),
         omitted_fields: z.number().int().min(0),
         omitted_property_coverage: z.number().int().min(0),
@@ -185,16 +164,31 @@ const exportCandidateSchema = z.strictObject({
     matches_requested_module: z.boolean(),
     matches_requested_export: z.boolean(),
 });
-const selectorResultSchema = z.strictObject({
+const selectorResultShape = {
     evidence_id: evidenceIdSchema,
     graph_id: graphIdSchema,
     requested_module_path: selectorTextSchema,
     requested_export_name: selectorTextSchema,
-    status: z.enum(["selected", "missing", "ambiguous", "unavailable"]),
-    selected_node_id: nodeIdSchema.nullable(),
-    candidates: z.array(exportCandidateSchema).max(1_000),
+    candidates: z.array(exportCandidateSchema),
     omitted_candidates: z.number().int().min(0),
-});
+};
+const selectorResultSchema = z.union([
+    z.strictObject({
+        ...selectorResultShape,
+        status: z.literal("selected"),
+        selected_node_id: nodeIdSchema,
+    }),
+    z.strictObject({
+        ...selectorResultShape,
+        status: z.enum(["missing", "ambiguous"]),
+        selected_node_id: z.null(),
+    }),
+    z.strictObject({
+        ...selectorResultShape,
+        status: z.literal("unavailable"),
+        selected_node_id: nodeIdSchema.nullable(),
+    }),
+]);
 const valueAvailabilitySchema = z.discriminatedUnion("availability", [
     z.strictObject({ availability: z.literal("absent") }),
     z.strictObject({
@@ -203,11 +197,11 @@ const valueAvailabilitySchema = z.discriminatedUnion("availability", [
     }),
     z.strictObject({
         availability: z.literal("union"),
-        values: z.array(semanticPrimitiveSchema).min(1).max(32),
+        values: z.array(semanticPrimitiveSchema).min(1),
     }),
     z.strictObject({
         availability: z.literal("unknown"),
-        reason: boundedTextSchema,
+        reason: textSchema,
     }),
 ]);
 const discriminantSchema = z.strictObject({
@@ -223,12 +217,11 @@ const comparisonChangeSchema = z.strictObject({
     right: valueAvailabilitySchema,
     left_source_range: sourceRangeSchema.nullable(),
     right_source_range: sourceRangeSchema.nullable(),
-    evidence_links: z.tuple([evidenceIdSchema, evidenceIdSchema]),
-    limitations: z.array(boundedTextSchema).max(20),
+    evidence_links: z.array(evidenceIdSchema).length(2),
+    limitations: z.array(textSchema),
 });
-/** Bounded static export-return comparison with explicit unknown semantics. */
+/** Static export-return comparison with explicit unknown semantics. */
 export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     comparison_id: z.string().regex(/^jesc_[a-f0-9]{64}$/u),
     left: selectorResultSchema,
     right: selectorResultSchema,
@@ -238,7 +231,7 @@ export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
         changed: z.number().int().min(0),
         unknown: z.number().int().min(0),
     }),
-    changes: z.array(comparisonChangeSchema).max(10_000),
+    changes: z.array(comparisonChangeSchema),
     coverage: z.strictObject({
         status: z.enum(["complete-within-inputs", "partial", "truncated"]),
         left_graph_status: z.enum([
@@ -267,8 +260,8 @@ export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
         omitted_candidates: z.number().int().min(0),
         omitted_changes: z.number().int().min(0),
     }),
-    evidence_links: z.tuple([evidenceIdSchema, evidenceIdSchema]),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    evidence_links: z.array(evidenceIdSchema).length(2),
+    limitations: z.array(textSchema),
     runtime_validation: z.strictObject({
         recommended_tool: z.literal("run_controlled_replay"),
         automatically_started: z.literal(false),

package/dist/domain/javascriptExportShapeSelection.js

@@ -1,7 +1,7 @@
 import { compareCodePoints } from "./javascriptApplicationGraph.js";
 import { projectedExportReturnShapesSchema, } from "./javascriptExportShapeComparisonSchemas.js";
 /** Select one exact trusted export and its exact static return-shape observation. */
-export const selectJavaScriptExport = (side, maxCandidates) => {
+export const selectJavaScriptExport = (side) => {
     const candidates = exportCandidates(side.graph);
     const exact = candidates.filter(({ modulePath, exportName }) => modulePath === side.modulePath && exportName === side.exportName);
     const matchingOneSelector = candidates.filter(({ modulePath, exportName }) => modulePath === side.modulePath || exportName === side.exportName);
@@ -10,26 +10,26 @@ export const selectJavaScriptExport = (side, maxCandidates) => {
         : matchingOneSelector.length > 0
             ? matchingOneSelector
             : candidates;
-    const retainedCandidates = diagnosticPool.slice(0, maxCandidates);
-    const base = selectorBase(side, diagnosticPool, retainedCandidates);
+    const base = selectorBase(side, diagnosticPool);
     if (exact.length === 0)
-        return unresolvedSelection(base, "missing", null, [
+        return unresolvedSelection(base, { status: "missing", selected_node_id: null }, [
             `No exact export binding matched ${side.modulePath}:${side.exportName}.`,
         ]);
     if (exact.length > 1)
-        return unresolvedSelection(base, "ambiguous", null, [
+        return unresolvedSelection(base, { status: "ambiguous", selected_node_id: null }, [
             `Multiple exact export bindings matched ${side.modulePath}:${side.exportName}; none was selected.`,
         ]);
     const selected = exact[0];
     if (selected === undefined || !selected.trusted)
-        return unresolvedSelection(base, "unavailable", selected?.node.node_id ?? null, [
+        return unresolvedSelection(base, {
+            status: "unavailable",
+            selected_node_id: selected?.node.node_id ?? null,
+        }, [
             "The exact export binding lacks the expected static-analysis authority.",
         ]);
     const returnShape = returnShapeFor(selected.node, side);
     if (returnShape.projection === null)
-        return unresolvedSelection(base, "unavailable", selected.node.node_id, [
-            returnShape.reason,
-        ]);
+        return unresolvedSelection(base, { status: "unavailable", selected_node_id: selected.node.node_id }, [returnShape.reason]);
     return {
         selection: {
             ...base,
@@ -41,28 +41,27 @@ export const selectJavaScriptExport = (side, maxCandidates) => {
         limitations: [],
     };
 };
-/** Apply the caller's explicit return-variant limit. */
-export const retainJavaScriptExportShapes = (selection, maximum) => {
+/** Retain every projected return variant. */
+export const retainJavaScriptExportShapes = (selection) => {
     const shapes = selection.projection?.static_return_shapes ?? [];
-    const retained = shapes.slice(0, maximum);
-    return { shapes: retained, omitted: shapes.length - retained.length };
+    return { shapes, omitted: 0 };
 };
-const selectorBase = (side, candidates, retained) => ({
+const selectorBase = (side, candidates) => ({
     evidence_id: side.evidenceId,
     graph_id: side.graph.graph_id,
     requested_module_path: side.modulePath,
     requested_export_name: side.exportName,
-    candidates: retained.map((candidate) => ({
+    candidates: candidates.map((candidate) => ({
         node_id: candidate.node.node_id,
         module_path: candidate.modulePath,
         export_name: candidate.exportName,
         matches_requested_module: candidate.modulePath === side.modulePath,
         matches_requested_export: candidate.exportName === side.exportName,
     })),
-    omitted_candidates: candidates.length - retained.length,
+    omitted_candidates: 0,
 });
-const unresolvedSelection = (base, status, nodeId, limitations) => ({
-    selection: { ...base, status, selected_node_id: nodeId },
+const unresolvedSelection = (base, resolution, limitations) => ({
+    selection: { ...base, ...resolution },
     projection: null,
     observationComplete: false,
     limitations,
@@ -122,7 +121,6 @@ const returnShapeFor = (node, side) => {
         projection: selected.result.data,
         observationComplete: observation.evidence.coverage.status === "complete" &&
             !observation.evidence.coverage.truncated,
-        reason: "",
     };
 };
 const unavailableReturnShape = (reason) => ({

package/dist/domain/javascriptFeatureSeed.js

@@ -113,23 +113,31 @@ const identityFields = (node) => {
 };
 const propertyFields = (value, prefix) => {
     const output = [];
-    const visit = (current, path, depth) => {
-        if (output.length >= 512 || depth > 6)
-            return;
+    const pending = [
+        { current: value, path: prefix },
+    ];
+    while (pending.length > 0) {
+        const next = pending.pop();
+        if (next === undefined)
+            continue;
+        const { current, path } = next;
         if (typeof current === "string") {
             output.push({ basis: "property", field: path, value: current });
-            return;
+            continue;
         }
         if (Array.isArray(current)) {
-            for (const [index, item] of current.entries())
-                visit(item, `${path}[${String(index)}]`, depth + 1);
-            return;
+            for (let index = current.length - 1; index >= 0; index -= 1) {
+                const item = current[index];
+                if (item !== undefined)
+                    pending.push({ current: item, path: `${path}[${String(index)}]` });
+            }
+            continue;
+        }
+        if (current !== null && typeof current === "object") {
+            for (const key of Object.keys(current).sort(compareCodePoints).reverse())
+                pending.push({ current: current[key] ?? null, path: `${path}.${key}` });
         }
-        if (current !== null && typeof current === "object")
-            for (const key of Object.keys(current).sort(compareCodePoints))
-                visit(current[key] ?? null, `${path}.${key}`, depth + 1);
-    };
-    visit(value, prefix, 0);
+    }
     return output;
 };
 const normalized = (value, caseSensitive) => {