@texaryn/schema-json 0.6.3 → 0.7.1

package/dist/projection-shape.js

@@ -0,0 +1,74 @@
+// Every family takes part in detecting a conflict, but only `object` and `array` are ever inferred:
+// a wrong scalar guess selects the wrong widget. `format` is absent because it describes string contents.
+const KEYWORD_FAMILIES = {
+    object: [
+        'properties',
+        'patternProperties',
+        'additionalProperties',
+        'propertyNames',
+        'required',
+        'minProperties',
+        'maxProperties',
+        'dependentSchemas',
+        'dependentRequired',
+        'dependencies',
+        'unevaluatedProperties',
+    ],
+    array: [
+        'items',
+        'prefixItems',
+        'additionalItems',
+        'contains',
+        'minItems',
+        'maxItems',
+        'uniqueItems',
+        'minContains',
+        'maxContains',
+        'unevaluatedItems',
+    ],
+    string: ['minLength', 'maxLength', 'pattern'],
+    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
+};
+export function projectionTypeFamilies(schema) {
+    const families = new Set();
+    for (const [family, keywords] of Object.entries(KEYWORD_FAMILIES)) {
+        if (keywords.some((keyword) => schema[keyword] !== undefined)) {
+            families.add(family);
+        }
+    }
+    return families;
+}
+export function shapeOfFamilies(families) {
+    if (families.size > 1)
+        return { kind: 'ambiguous', families: [...families].sort() };
+    if (families.size === 1) {
+        const [family] = families;
+        if (family === 'object' || family === 'array')
+            return { kind: 'resolved', type: family };
+    }
+    return { kind: 'none' };
+}
+export function inferProjectionShape(schema) {
+    return shapeOfFamilies(projectionTypeFamilies(schema));
+}
+export function shapeDiagnostic(pointer, shape, enumDeclared) {
+    if (shape.kind === 'ambiguous') {
+        return {
+            pointer,
+            code: 'ambiguous-projection-shape',
+            message: `No explicit "type", and keywords from more than one type apply ` +
+                `(${shape.families.join(', ')}), so the shape to render is undecidable. ` +
+                `Declare "type" on this schema to resolve it.`,
+        };
+    }
+    return {
+        pointer,
+        code: 'unresolved-projection-shape',
+        message: `No explicit "type", and no keyword that implies one, so there is no ` +
+            `shape to render. Declare "type" on this schema.` +
+            (enumDeclared
+                ? ` An "enum" alone does not imply a type, because its members may be of different types.`
+                : ''),
+    };
+}
+//# sourceMappingURL=projection-shape.js.map

package/dist/projection-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-shape.js","sourceRoot":"","sources":["../src/projection-shape.ts"],"names":[],"mappings":"AAEA,oGAAoG;AACpG,0GAA0G;AAC1G,MAAM,gBAAgB,GAAG;IACvB,MAAM,EAAE;QACN,YAAY;QACZ,mBAAmB;QACnB,sBAAsB;QACtB,eAAe;QACf,UAAU;QACV,eAAe;QACf,eAAe;QACf,kBAAkB;QAClB,mBAAmB;QACnB,cAAc;QACd,uBAAuB;KACxB;IACD,KAAK,EAAE;QACL,OAAO;QACP,aAAa;QACb,iBAAiB;QACjB,UAAU;QACV,UAAU;QACV,UAAU;QACV,aAAa;QACb,aAAa;QACb,aAAa;QACb,kBAAkB;KACnB;IACD,MAAM,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,SAAS,CAAC;IAC7C,MAAM,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,YAAY,CAAC;CAChC,CAAA;AAStD,MAAM,UAAU,sBAAsB,CAAC,MAA+B;IACpE,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAiB,CAAA;IACzC,KAAK,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAClE,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,SAAS,CAAC,EAAE,CAAC;YAC9D,QAAQ,CAAC,GAAG,CAAC,MAAuB,CAAC,CAAA;QACvC,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,QAAoC;IAClE,IAAI,QAAQ,CAAC,IAAI,GAAG,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE,CAAA;IAEnF,IAAI,QAAQ,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAA;QACzB,IAAI,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,OAAO;YAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;IAC1F,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;AACzB,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,MAA+B;IAClE,OAAO,eAAe,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC,CAAA;AACxD,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,OAAoB,EACpB,KAAqD,EACrD,YAAqB;IAErB,IAAI,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QAC/B,OAAO;YACL,OAAO;YACP,IAAI,EAAE,4BAA4B;YAClC,OAAO,EACL,iEAAiE;gBACjE,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,4CAA4C;gBACzE,8CAA8C;SACjD,CAAA;IACH,CAAC;IACD,OAAO;QACL,OAAO;QACP,IAAI,EAAE,6BAA6B;QACnC,OAAO,EACL,sEAAsE;YACtE,iDAAiD;YACjD,CAAC,YAAY;gBACX,CAAC,CAAC,wFAAwF;gBAC1F,CAAC,CAAC,EAAE,CAAC;KACV,CAAA;AACH,CAAC"}

package/dist/projection.d.ts

@@ -1,5 +1,11 @@
 import { type SchemaNode } from 'json-schema-library';
 import type { SchemaProjection } from '@texaryn/core';
+import { type ProjectionCache } from './identity.js';
+export interface ProjectionLimits {
+    readonly objects: number;
+    readonly nodes: number;
+}
+export declare const DEFAULT_LIMITS: ProjectionLimits;
 /**
  * Maps a compiled json-schema-library root node to a SchemaProjection.
  * Called by adapter.project() on every data change.
@@ -10,5 +16,5 @@ import type { SchemaProjection } from '@texaryn/core';
  * contract), while array items are walked from `data` (an array's length is a data-time
  * fact, not a schema-time one). $ref is resolved transparently via node.resolveRef().
  */
-export declare function buildProjection(root: SchemaNode, data: unknown): SchemaProjection;
+export declare function buildProjection(root: SchemaNode, data: unknown, cache: ProjectionCache, limits?: ProjectionLimits): SchemaProjection;
 //# sourceMappingURL=projection.d.ts.map

package/dist/projection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../src/projection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,KAAK,EACV,gBAAgB,EASjB,MAAM,eAAe,CAAA;AA4nCtB;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAKjF"}
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../src/projection.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAC9E,OAAO,KAAK,EACV,gBAAgB,EAUjB,MAAM,eAAe,CAAA;AACtB,OAAO,EAQL,KAAK,eAAe,EACrB,MAAM,eAAe,CAAA;AAwJtB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED,eAAO,MAAM,cAAc,EAAE,gBAA8C,CAAA;AAqiC3E;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,eAAe,EACtB,MAAM,GAAE,gBAAiC,GACxC,gBAAgB,CAiDlB"}

package/dist/projection.js

@@ -1,4 +1,7 @@
-import { mergeNode } from 'json-schema-library';
+import { mergeNode, isSchemaNode } from 'json-schema-library';
+import { childDeclaring, followRef, itemDeclaring, locationInfo, onlyPoints, positionOf, } from './identity.js';
+import { inferProjectionShape, shapeDiagnostic } from './projection-shape.js';
+import { POSITION } from './schema-graph.js';
 const VALID_TYPES = new Set([
     'string',
     'number',
@@ -25,64 +28,6 @@ function resolveExplicitType(schema) {
     }
     return undefined;
 }
-/**
- * Keywords that apply to exactly one JSON type, grouped by that type.
- *
- * Two different jobs are done with these, and only one of them infers
- * anything. Every family takes part in detecting a conflict, because a schema
- * drawing keywords from two families implies no single shape. Only `object`
- * and `array` are shapes a form can be given, so those are the only two ever
- * inferred: `string` and `number` are here to be noticed, not chosen.
- *
- * Inferring a scalar would need a rule that is right rather than symmetrical,
- * and there is not one. `minimum` cannot tell `number` from `integer`, and a
- * wrong scalar guess selects the wrong widget, which is harder to notice than
- * a field that never appeared at all.
- *
- * `format` is deliberately absent: it annotates a string's contents rather
- * than describing structure, and schemas apply it to non-strings in practice.
- */
-const KEYWORD_FAMILIES = {
-    object: [
-        'properties',
-        'patternProperties',
-        'additionalProperties',
-        'propertyNames',
-        'required',
-        'minProperties',
-        'maxProperties',
-        'dependentSchemas',
-        'dependentRequired',
-        // json-schema-library normalises draft-07 `dependencies` into the two
-        // above at parse time. Listed anyway, so the rule does not rely on that.
-        'dependencies',
-        'unevaluatedProperties',
-    ],
-    array: [
-        'items',
-        'prefixItems',
-        'additionalItems',
-        'contains',
-        'minItems',
-        'maxItems',
-        'uniqueItems',
-        'minContains',
-        'maxContains',
-        'unevaluatedItems',
-    ],
-    string: ['minLength', 'maxLength', 'pattern'],
-    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
-};
-/** Which families a schema draws keywords from, computed over all of them at once. */
-function projectionTypeFamilies(schema) {
-    const families = new Set();
-    for (const [family, keywords] of Object.entries(KEYWORD_FAMILIES)) {
-        if (keywords.some((keyword) => schema[keyword] !== undefined)) {
-            families.add(family);
-        }
-    }
-    return families;
-}
 /**
  * Whether any branch of this node's `oneOf`/`anyOf` could be given a shape at
  * all, for some value.
@@ -104,17 +49,6 @@ function compositionHasRenderableAlternative(node) {
         return inferProjectionShape(schema).kind === 'resolved';
     });
 }
-function inferProjectionShape(schema) {
-    const families = projectionTypeFamilies(schema);
-    if (families.size > 1)
-        return { kind: 'ambiguous', families: [...families].sort() };
-    if (families.size === 1) {
-        const [family] = families;
-        if (family === 'object' || family === 'array')
-            return { kind: 'resolved', type: family };
-    }
-    return { kind: 'none' };
-}
 function extractConstraints(schema) {
     const constraints = {};
     if (typeof schema.minLength === 'number')
@@ -174,9 +108,80 @@ function extractEnumValues(schema) {
         return undefined;
     return schema.enum.map((value) => ({ value }));
 }
+function dereferenceChecked(node) {
+    let current = node;
+    const seen = new Set();
+    while (typeof current.$ref === 'string') {
+        const position = positionOf(current);
+        if (seen.has(position))
+            return { node: current, cycle: true };
+        seen.add(position);
+        const next = followRef(current);
+        if (!next) {
+            const raw = current.resolveRef();
+            return { node: (raw ?? current), cycle: false };
+        }
+        current = next;
+        if (!onlyPoints(current))
+            break;
+    }
+    return { node: current, cycle: false };
+}
 /** Follows a $ref to the node it points at; returns the node unchanged otherwise. */
 function dereference(node) {
-    return node.$ref ? node.resolveRef() : node;
+    return dereferenceChecked(node).node;
+}
+// A dialect whose reducer leaves $ref unresolved reduces a selected `{ $ref }` branch to `{}`.
+function resolveSelectedBranch(original, reduced, data) {
+    const reducedSchema = reduced.schema;
+    if (reducedSchema && typeof reducedSchema === 'object') {
+        if (resolveExplicitType(reducedSchema) || inferProjectionShape(reducedSchema).kind === 'resolved') {
+            return reduced;
+        }
+    }
+    const selected = [];
+    if (original.oneOf) {
+        const matching = original.oneOf.filter((branch) => branchApplies(branch, data));
+        if (matching.length === 1)
+            selected.push(matching[0]);
+    }
+    for (const branch of original.anyOf ?? []) {
+        if (branchApplies(branch, data))
+            selected.push(branch);
+    }
+    if (!selected.some((branch) => typeof branch.$ref === 'string'))
+        return reduced;
+    let merged = reduced;
+    for (const branch of selected) {
+        const target = dereference(branch);
+        if (!isSchemaNode(target))
+            continue;
+        const targetReduced = target.reduceNode(data).node ?? target;
+        merged = mergeNode(merged, targetReduced) ?? merged;
+    }
+    return merged;
+}
+export const DEFAULT_LIMITS = { objects: 16, nodes: 512 };
+function walkOrder(a, b) {
+    for (let i = 0; i < Math.min(a.length, b.length); i++)
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    return a.length - b.length;
+}
+function addBoundary(ctx, pointer, reason) {
+    const reasons = ctx.boundaries.get(pointer) ?? new Set();
+    reasons.add(reason);
+    ctx.boundaries.set(pointer, reasons);
+}
+// A leaf needs no reduction, so it rides with its parent's budget unit.
+function isLeafSchema(schema) {
+    if (typeof schema !== 'object' || schema === null)
+        return true;
+    const record = schema;
+    const type = resolveExplicitType(record);
+    if (type !== undefined)
+        return type !== 'object';
+    return ('enum' in record || 'const' in record) && !('properties' in record);
 }
 /**
  * The position of a schema within the document it was authored in, as a JSON
@@ -334,7 +339,7 @@ function collectApplicableDefaults(roots, data) {
     return declarationsFrom((visitor) => eachApplicable(roots, data, visitor));
 }
 /** The positions that declare one property of `roots`, by both reachability rules. */
-function childPositions(roots, key, data) {
+function childPositions(roots, key, data, declaring) {
     const unconditional = [];
     eachUnconditional(roots.unconditional, (node) => {
         const child = node.properties?.[key];
@@ -347,10 +352,10 @@ function childPositions(roots, key, data) {
         if (child)
             applicable.push(child);
     });
-    return { unconditional, applicable };
+    return { unconditional, applicable, declaring };
 }
 /** The positions that declare the elements of `roots`, by both reachability rules. */
-function itemPositions(roots, data) {
+function itemPositions(roots, data, declaring) {
     const unconditional = [];
     eachUnconditional(roots.unconditional, (node) => {
         if (node.items)
@@ -361,7 +366,7 @@ function itemPositions(roots, data) {
         if (node.items)
             applicable.push(node.items);
     });
-    return { unconditional, applicable };
+    return { unconditional, applicable, declaring };
 }
 /**
  * The declarations to report, or nothing where the schema states one answer.
@@ -641,6 +646,8 @@ function computeRequiredSet(resolved, reducedSchema, dataRecord) {
     }
     return required;
 }
+// An unreadable identity is never a repeat, and is budgeted so it cannot expand without end.
+const budgeted = (info) => info.cyclic || info.key === '';
 /**
  * Walks the compiled schema statically (via node.properties/node.items plus every
  * conditional branch), only descending into array items that are actually present in
@@ -664,9 +671,57 @@ provisional, nodes, diagnostics,
  * supply: by the time the caller has a node to walk it holds the merge of
  * them, and the merge is what loses a disagreement.
  */
-declaredAt) {
-    const original = dereference(node);
+declaredAt, ctx, 
+/** Entered as an object member, which is the only way to be past the data. */
+member, 
+/** The past-the-data ancestors, nearest first, up to the nearest location holding data. */
+lineage, path) {
+    const info = locationInfo(declaredAt.declaring, ctx.cache);
+    const { node: original, cycle: referenceCycle } = dereferenceChecked(node);
+    if (info.cycle || referenceCycle) {
+        diagnostics.push({
+            pointer: toPointer(pointer),
+            code: 'unresolved-projection-shape',
+            message: `A "$ref" or in-place applicator cycle never leaves this location, so there is no ` +
+                `shape to render.`,
+        });
+        return;
+    }
+    const pastData = member && (data === undefined || data === null);
+    const recursive = pastData && ((lineage?.recursive ?? false) || budgeted(info));
+    for (let ancestor = pastData ? lineage : undefined; ancestor; ancestor = ancestor.parent) {
+        if (info.key !== '' && ancestor.key === info.key) {
+            addBoundary(ctx, ancestor.pointer, 'recursion');
+            ctx.removed.add(pointer);
+            return;
+        }
+    }
     const originalSchema = original.schema;
+    if (recursive && lineage !== undefined) {
+        const parent = pointer.slice(0, pointer.lastIndexOf('/'));
+        let admit;
+        if (isLeafSchema(originalSchema)) {
+            const covered = ctx.reserved.has(parent);
+            admit = covered || ctx.nodesUsed < ctx.limits.nodes;
+            if (admit && !covered)
+                ctx.nodesUsed += 1;
+        }
+        else {
+            const leaves = [...collectCandidateProperties(original).values()].filter((candidate) => isLeafSchema(dereference(candidatePrototype(candidate)).schema)).length;
+            admit = ctx.objectsUsed < ctx.limits.objects && ctx.nodesUsed + 1 + leaves <= ctx.limits.nodes;
+            if (admit) {
+                ctx.objectsUsed += 1;
+                ctx.nodesUsed += 1 + leaves;
+                ctx.reserved.add(pointer);
+            }
+        }
+        if (!admit) {
+            addBoundary(ctx, parent, 'budget');
+            ctx.removed.add(pointer);
+            return;
+        }
+        ctx.flagged.add(pointer);
+    }
     if (typeof originalSchema !== 'object' || originalSchema === null)
         return;
     let resolved = original;
@@ -697,8 +752,8 @@ declaredAt) {
         composedAgainstData = true;
         const { node: branchNode } = original.reduceNode(data);
         if (branchNode) {
-            resolved = branchNode;
-            schema = branchNode.schema;
+            resolved = resolveSelectedBranch(original, branchNode, data);
+            schema = resolved.schema;
             type = resolveExplicitType(schema);
         }
         else {
@@ -751,7 +806,7 @@ declaredAt) {
      * this adapter renders, because scalar shapes are deliberately not inferred.
      * That schema is genuinely unprojectable and has to be reported.
      */
-    const isTransientBranchMiss = () => Object.keys(schema).length === 0 && compositionHasRenderableAlternative(original);
+    const isTransientBranchMiss = () => Object.keys(schema).every((keyword) => keyword === POSITION) && compositionHasRenderableAlternative(original);
     // Last resort, after the oneOf/anyOf branch above has had its chance: that
     // path handles a typeless wrapper whose type only exists once a branch is
     // chosen, and inferring first would take a schema carrying both `properties`
@@ -776,30 +831,14 @@ declaredAt) {
             // without a shape, so the caller is told which pointer was skipped and
             // why, instead of finding out from a form that never collected the
             // value.
-            diagnostics.push(shape.kind === 'ambiguous'
-                ? {
-                    pointer: toPointer(pointer),
-                    code: 'ambiguous-projection-shape',
-                    message: `No explicit "type", and keywords from more than one type apply ` +
-                        `(${shape.families.join(', ')}), so the shape to render is undecidable. ` +
-                        `Declare "type" on this schema to resolve it.`,
-                }
-                : {
-                    pointer: toPointer(pointer),
-                    code: 'unresolved-projection-shape',
-                    message: `No explicit "type", and no keyword that implies one, so there is no ` +
-                        `shape to render. Declare "type" on this schema.` +
-                        // Said only where it applies, because inferring `string` from
-                        // an enum is the tempting wrong rule and the reason deserves
-                        // to travel with the case rather than every message.
-                        (schema.enum !== undefined
-                            ? ` An "enum" alone does not imply a type, because its members may be of different types.`
-                            : ''),
-                });
+            diagnostics.push(shapeDiagnostic(toPointer(pointer), shape, schema.enum !== undefined));
         }
     }
     if (!type)
         return;
+    const selfLineage = pastData
+        ? { key: info.key, pointer, recursive, depth: (lineage?.depth ?? 0) + 1, parent: lineage }
+        : undefined;
     // Reported at the location it is about, and after the shape gate above: a
     // pointer with no node has nothing to omit an annotation from, and saying
     // that its `default` is undecidable on top of saying it cannot be drawn at
@@ -819,9 +858,13 @@ declaredAt) {
     // selects. A superset of the diagnostic's: every unconditional disagreement
     // is also an applicable one, so the node carries both kinds and a consumer
     // reads one place.
-    const applicableConflict = disagreeingDefaults(collectApplicableDefaults(declaredAt.applicable, data));
+    const applicableDeclarations = collectApplicableDefaults(declaredAt.applicable, data);
+    const applicableConflict = disagreeingDefaults(applicableDeclarations);
     const conflictedDefault = applicableConflict !== undefined || ambiguousDefault !== undefined;
     const defaultConflict = (applicableConflict ?? ambiguousDefault)?.map((declaration) => declaration.source);
+    const defaultSources = !conflictedDefault && 'default' in schema && info.cyclic
+        ? [...new Set(applicableDeclarations.map((declaration) => declaration.source))].sort()
+        : undefined;
     const nodeActive = active && branchResolved;
     // A node the schema applies is never also provisional; the two report
     // different facts and only the second is a choice this projection made. The
@@ -846,7 +889,13 @@ declaredAt) {
         // wrapper case), it has already been reduced against the real `data` at this
         // pointer; re-reducing it against `dataRecord ?? {}` here would be redundant (and,
         // for a branch with no dynamic keywords of its own, a no-op), so it is skipped.
-        const reducedNode = resolved === original ? resolved.reduceNode(dataRecord ?? {}).node : resolved;
+        let reducedNode = resolved === original ? resolved.reduceNode(dataRecord ?? {}).node : resolved;
+        if (reducedNode &&
+            resolved === original &&
+            !resolveExplicitType(originalSchema) &&
+            (original.oneOf || original.anyOf)) {
+            reducedNode = resolveSelectedBranch(original, reducedNode, dataRecord ?? {});
+        }
         const reducedSchema = reducedNode?.schema;
         const reducedProperties = reducedSchema?.properties ??
             schema.properties ??
@@ -903,8 +952,9 @@ declaredAt) {
             provisional: nodeProvisional ? true : undefined,
             defaultConflict,
             annotations: extractAnnotations(schema, conflictedDefault),
+            ...(defaultSources !== undefined ? { defaultSources } : {}),
         });
-        for (const key of propKeys) {
+        for (const [index, key] of propKeys.entries()) {
             const childPointer = `${pointer}/${escapeSegment(key)}`;
             const childActive = nodeActive && activeKeys.has(key);
             // A descendant inherits exposure, not activity: under a provisionally
@@ -927,15 +977,23 @@ declaredAt) {
             const childNode = reducedChildNode ??
                 composeChild(candidate.direct, provisionalChildNode) ??
                 candidatePrototype(candidate);
-            walk(childNode, childPointer, dataRecord?.[key], childActive, childProvisional, nodes, diagnostics, 
+            const positions = childPositions(declaredAt, key, 
             // This node's own data, not the child's: the branches being entered
             // are this location's, so they are decided by the instance here. The
             // child's own conditional edges are entered by the child's walk, with
             // the child's data.
-            childPositions(declaredAt, key, data));
+            data, childDeclaring(info, key));
+            const enter = () => walk(childNode, childPointer, dataRecord !== undefined && Object.hasOwn(dataRecord, key) ? dataRecord[key] : undefined, childActive, childProvisional, nodes, diagnostics, positions, ctx, true, selfLineage, [...path, index]);
+            // Deferring the children the budget counts, by depth below the anchor, admits it breadth first.
+            const counted = selfLineage && (recursive || budgeted(locationInfo(positions.declaring, ctx.cache)));
+            if (counted)
+                (ctx.queue[selfLineage.depth] ??= []).push({ path: [...path, index], enter });
+            else
+                enter();
         }
         return;
     }
+    const itemSchema = type === 'array' && resolved.items ? dereference(resolved.items).schema : undefined;
     nodes.set(toPointer(pointer), {
         type,
         format: typeof schema.format === 'string' ? schema.format : undefined,
@@ -946,20 +1004,21 @@ declaredAt) {
         provisional: nodeProvisional ? true : undefined,
         defaultConflict,
         annotations: extractAnnotations(schema, conflictedDefault),
+        ...(defaultSources !== undefined ? { defaultSources } : {}),
         // Deliberately not given the flag above. A conflict under `items` belongs
         // to the element locations, and each of those reports its own; this field
         // describes the item schema rather than being one of those locations, so
         // omitting its `default` would be an omission no pointer could report. It
         // is also the only annotation set nothing reads a `default` from, and the
         // only one the other adapter does not produce at all.
-        itemAnnotations: type === 'array' && resolved.items
-            ? extractAnnotations(dereference(resolved.items).schema)
+        itemAnnotations: typeof itemSchema === 'object' && itemSchema !== null
+            ? extractAnnotations(itemSchema)
             : undefined,
     });
     if (type === 'array' && resolved.items && Array.isArray(data)) {
-        const elementPositions = itemPositions(declaredAt, data);
+        const elementPositions = itemPositions(declaredAt, data, itemDeclaring(info));
         data.forEach((item, index) => {
-            walk(resolved.items, `${pointer}/${index}`, item, nodeActive, nodeProvisional, nodes, diagnostics, elementPositions);
+            walk(resolved.items, `${pointer}/${index}`, item, nodeActive, nodeProvisional, nodes, diagnostics, elementPositions, ctx, false, undefined, [...path, index]);
         });
     }
 }
@@ -973,10 +1032,42 @@ declaredAt) {
  * contract), while array items are walked from `data` (an array's length is a data-time
  * fact, not a schema-time one). $ref is resolved transparently via node.resolveRef().
  */
-export function buildProjection(root, data) {
+export function buildProjection(root, data, cache, limits = DEFAULT_LIMITS) {
     const nodes = new Map();
     const diagnostics = [];
-    walk(root, '', data, true, false, nodes, diagnostics, { unconditional: [root], applicable: [root] });
+    const ctx = {
+        cache,
+        limits,
+        boundaries: new Map(),
+        removed: new Set(),
+        flagged: new Set(),
+        reserved: new Set(),
+        queue: [],
+        objectsUsed: 0,
+        nodesUsed: 0,
+    };
+    walk(root, '', data, true, false, nodes, diagnostics, { unconditional: [root], applicable: [root], declaring: [root] }, ctx, false, undefined, []);
+    for (const level of ctx.queue)
+        for (const { enter } of (level ?? []).sort((a, b) => walkOrder(a.path, b.path)))
+            enter();
+    for (const node of nodes.values()) {
+        if (node.children?.some((child) => ctx.removed.has(child.pointer))) {
+            ;
+            node.children = node.children.filter((child) => !ctx.removed.has(child.pointer));
+        }
+    }
+    for (const pointer of ctx.flagged) {
+        const node = nodes.get(toPointer(pointer));
+        if (node)
+            node.recursiveExpansion = true;
+    }
+    for (const [pointer, reasons] of ctx.boundaries) {
+        const node = nodes.get(toPointer(pointer));
+        if (node) {
+            ;
+            node.boundaries = ['recursion', 'budget'].filter((reason) => reasons.has(reason));
+        }
+    }
     return { nodes, diagnostics };
 }
 //# sourceMappingURL=projection.js.map