@texaryn/schema-json 0.7.1 → 0.8.0

package/dist/projection.js

@@ -1,5 +1,5 @@
-import { mergeNode, isSchemaNode } from 'json-schema-library';
-import { childDeclaring, followRef, itemDeclaring, locationInfo, onlyPoints, positionOf, } from './identity.js';
+import { mergeNode, isSchemaNode } from './vendor/json-schema-library/index.mjs';
+import { authoredSchema, childDeclaring, extendDeclaring, followRef, itemDeclaring, locationInfo, onlyPoints, positionOf, referenceKeywords, referenceOf, } from './identity.js';
 import { inferProjectionShape, shapeDiagnostic } from './projection-shape.js';
 import { POSITION } from './schema-graph.js';
 const VALID_TYPES = new Set([
@@ -11,6 +11,18 @@ const VALID_TYPES = new Set([
     'array',
     'null',
 ]);
+const NON_ASSERTION_REFERENCE_SIBLINGS = new Set([
+    '$id',
+    '$anchor',
+    '$dynamicAnchor',
+    '$recursiveAnchor',
+    '$schema',
+    '$vocabulary',
+    '$comment',
+    '$defs',
+    'definitions',
+    POSITION,
+]);
 function toPointer(value) {
     return value;
 }
@@ -84,8 +96,8 @@ function extractAnnotations(schema,
  * Set where two declarations apply to this location whatever the instance is
  * and disagree. The merged schema still carries one of them, and which one is
  * the merge's traversal order rather than an answer.
- */
-omitDefault = false) {
+*/
+omitDefault = false, defaultOverride) {
     const annotations = {};
     if (typeof schema.title === 'string')
         annotations.title = schema.title;
@@ -99,8 +111,15 @@ omitDefault = false) {
         annotations.deprecated = schema.deprecated;
     if (Array.isArray(schema.examples))
         annotations.examples = schema.examples;
-    if (!omitDefault && 'default' in schema)
-        annotations.default = schema.default;
+    if (!omitDefault) {
+        if (defaultOverride) {
+            if (defaultOverride.present)
+                annotations.default = defaultOverride.value;
+        }
+        else if ('default' in schema) {
+            annotations.default = schema.default;
+        }
+    }
     return annotations;
 }
 function extractEnumValues(schema) {
@@ -109,30 +128,339 @@ function extractEnumValues(schema) {
     return schema.enum.map((value) => ({ value }));
 }
 function dereferenceChecked(node) {
-    let current = node;
-    const seen = new Set();
-    while (typeof current.$ref === 'string') {
+    const completed = new Set();
+    const active = new Set();
+    const parts = [];
+    let cycle = false;
+    let unresolved = false;
+    const visit = (current, referringSite = false) => {
         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 };
+        if (active.has(position)) {
+            cycle = true;
+            return;
+        }
+        if (completed.has(position))
+            return;
+        const references = referenceKeywords(current);
+        if (references.length === 0) {
+            parts.push(current);
+            completed.add(position);
+            return;
+        }
+        if (!referringSite && current.getDraftVersion() !== 'draft-07' && !onlyPoints(current)) {
+            parts.push(current);
+            completed.add(position);
+            return;
+        }
+        active.add(position);
+        for (const keyword of references) {
+            const target = followRef(current, keyword);
+            if (target === undefined || !isSchemaNode(target)) {
+                unresolved = true;
+            }
+            else {
+                visit(target);
+            }
+        }
+        if (current.getDraftVersion() !== 'draft-07') {
+            const sibling = mergeNode(current, current, ...references);
+            const siblingSchema = sibling?.schema;
+            if (isSchemaNode(sibling) &&
+                Object.keys(siblingSchema ?? {}).some((keyword) => !NON_ASSERTION_REFERENCE_SIBLINGS.has(keyword))) {
+                parts.push(sibling);
+            }
+        }
+        active.delete(position);
+        completed.add(position);
+    };
+    visit(node, true);
+    if (cycle)
+        return { node, cycle: true, unresolved: false };
+    if (unresolved || parts.length === 0)
+        return { node, cycle: false, unresolved: true };
+    if (parts.length === 1)
+        return { node: parts[0], cycle: false, unresolved: false };
+    const position = JSON.stringify(parts.map(positionOf));
+    const type = referenceCompositionType(parts);
+    const oneOfSource = parts.find((part) => part.oneOf !== undefined);
+    const anyOfSource = parts.find((part) => part.anyOf !== undefined);
+    const projectionFields = {};
+    const projectionKeys = [
+        'format',
+        'minLength',
+        'maxLength',
+        'pattern',
+        'minimum',
+        'maximum',
+        'exclusiveMinimum',
+        'exclusiveMaximum',
+        'multipleOf',
+        'minItems',
+        'maxItems',
+        'uniqueItems',
+        'enum',
+        'title',
+        'description',
+        'readOnly',
+        'writeOnly',
+        'deprecated',
+        'examples',
+    ];
+    for (const part of parts) {
+        const record = part.schema;
+        if (!record || typeof record !== 'object')
+            continue;
+        for (const keyword of projectionKeys) {
+            if (keyword in record)
+                projectionFields[keyword] = record[keyword];
         }
-        current = next;
-        if (!onlyPoints(current))
-            break;
     }
-    return { node: current, cycle: false };
+    const schema = {
+        ...projectionFields,
+        [POSITION]: `reference-composition:${position}`,
+        ...(type === undefined ? {} : { type }),
+        // Compile a harmless branch so json-schema-library installs the allOf
+        // reducer, then attach the already compiled components below. Recompiling
+        // their raw schemas here would resolve relative references in the first
+        // component's resource scope instead of each component's original scope.
+        allOf: [{}],
+    };
+    const first = parts[0];
+    const composed = first.compileSchema(schema, `${first.evaluationPath}/$ref`, `${first.schemaLocation}/reference-composition`);
+    composed.schema = {
+        ...composed.schema,
+        allOf: parts.map((part) => part.schema),
+        ...(oneOfSource?.oneOf ? { oneOf: oneOfSource.oneOf.map((branch) => branch.schema) } : {}),
+        ...(anyOfSource?.anyOf ? { anyOf: anyOfSource.anyOf.map((branch) => branch.schema) } : {}),
+    };
+    composed.allOf = [...parts];
+    if (oneOfSource?.oneOf)
+        composed.oneOf = [...oneOfSource.oneOf];
+    if (anyOfSource?.anyOf)
+        composed.anyOf = [...anyOfSource.anyOf];
+    composed.reduceNode = (data, options = {}) => {
+        let reduced;
+        let reductionFailed = false;
+        let reductionError;
+        for (const part of parts) {
+            const outcome = part.reduceNode(data, options);
+            if (!isSchemaNode(outcome.node)) {
+                reductionFailed = true;
+                reductionError ??= outcome.error;
+                continue;
+            }
+            const candidate = outcome.node;
+            reduced = reduced ? mergeNode(reduced, candidate) : candidate;
+        }
+        if (reductionFailed)
+            return { node: undefined, error: reductionError };
+        if (!reduced)
+            return { node: composed, error: undefined };
+        const reducedSchema = {
+            ...reduced.schema,
+            [POSITION]: `reference-composition:${position}`,
+        };
+        if (type !== undefined)
+            reducedSchema.type = type;
+        const reducedNode = { ...reduced, schema: reducedSchema, allOf: undefined };
+        if (type !== undefined)
+            reducedNode.type = type;
+        return { node: reducedNode, error: undefined };
+    };
+    return { node: composed, cycle: false, unresolved: false };
 }
 /** Follows a $ref to the node it points at; returns the node unchanged otherwise. */
 function dereference(node) {
     return dereferenceChecked(node).node;
 }
+function visitReferenceDefaultSites(node, cache, visitor, dynamicReferenceProjection = false) {
+    if (cache.dialect === 'draft-07' || referenceOf(node) === undefined)
+        return;
+    const pending = [node];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const current = pending.pop();
+        const position = positionOf(current);
+        if (visited.has(position))
+            continue;
+        visited.add(position);
+        const authored = authoredSchema(current, cache);
+        if (authored !== null &&
+            typeof authored === 'object' &&
+            'default' in authored) {
+            visitor(current);
+        }
+        for (const keyword of referenceKeywords(current)) {
+            if (dynamicReferenceProjection && (keyword === '$dynamicRef' || keyword === '$recursiveRef'))
+                continue;
+            const target = followRef(current, keyword);
+            if (target)
+                pending.push(target);
+        }
+    }
+}
+function traversalKey(node) {
+    const parent = node.parent;
+    const isInPlaceBranch = parent !== undefined &&
+        ['if', 'then', 'else', 'contains'].some((keyword) => parent[keyword] === node || node.evaluationPath === `${parent.evaluationPath}/${keyword}`);
+    if (isInPlaceBranch) {
+        return positionOf(node);
+    }
+    const location = node.schemaLocation;
+    return typeof location === 'string' ? location : positionOf(node);
+}
+function allOfExplicitType(node, visited = new Set()) {
+    const position = positionOf(node);
+    if (visited.has(position))
+        return undefined;
+    visited.add(position);
+    for (const branch of node.allOf ?? []) {
+        const reference = referenceOf(branch) !== undefined ? dereferenceChecked(branch) : undefined;
+        if (reference?.unresolved || (reference && !isSchemaNode(reference.node)))
+            continue;
+        const target = reference?.node ?? branch;
+        const schema = target.schema;
+        if (schema && typeof schema === 'object') {
+            const type = resolveExplicitType(schema);
+            if (type)
+                return type;
+        }
+        const nested = allOfExplicitType(target, visited);
+        if (nested)
+            return nested;
+    }
+    return undefined;
+}
+function declaresObject(node, visited = new Set()) {
+    const resolved = dereference(node);
+    if (!isSchemaNode(resolved))
+        return false;
+    const position = positionOf(resolved);
+    if (visited.has(position))
+        return false;
+    visited.add(position);
+    const schema = resolved.schema;
+    if (!schema || typeof schema !== 'object')
+        return false;
+    const explicitType = resolveExplicitType(schema);
+    if (explicitType)
+        return explicitType === 'object';
+    const allOfType = allOfExplicitType(resolved);
+    if (allOfType)
+        return allOfType === 'object';
+    const shape = inferProjectionShape(schema);
+    if (shape.kind === 'resolved')
+        return shape.type === 'object';
+    return (resolved.allOf ?? []).some((branch) => declaresObject(branch, visited));
+}
+function declaresArray(node, visited = new Set()) {
+    const resolved = dereference(node);
+    if (!isSchemaNode(resolved))
+        return false;
+    const position = positionOf(resolved);
+    if (visited.has(position))
+        return false;
+    visited.add(position);
+    const schema = resolved.schema;
+    if (!schema || typeof schema !== 'object')
+        return false;
+    const explicitType = resolveExplicitType(schema);
+    if (explicitType)
+        return explicitType === 'array';
+    const allOfType = allOfExplicitType(resolved);
+    if (allOfType)
+        return allOfType === 'array';
+    const shape = inferProjectionShape(schema);
+    if (shape.kind === 'resolved')
+        return shape.type === 'array';
+    return (resolved.allOf ?? []).some((branch) => declaresArray(branch, visited));
+}
+function referenceCompositionType(parts) {
+    const explicit = new Set(parts
+        .map((part) => {
+        const schema = part.schema;
+        return (schema && typeof schema === 'object' ? resolveExplicitType(schema) : undefined) ?? allOfExplicitType(part);
+    })
+        .filter((type) => type !== undefined));
+    if (explicit.size === 1)
+        return [...explicit][0];
+    if (explicit.size > 1)
+        return undefined;
+    const object = parts.some((part) => declaresObject(part));
+    const array = parts.some((part) => declaresArray(part));
+    if (object === array)
+        return undefined;
+    return object ? 'object' : 'array';
+}
+function hasReferencedAllOf(node, visited = new Set()) {
+    const position = positionOf(node);
+    if (visited.has(position))
+        return false;
+    visited.add(position);
+    for (const branch of node.allOf ?? []) {
+        if (referenceOf(branch) !== undefined)
+            return true;
+        if (hasReferencedAllOf(branch, visited))
+            return true;
+    }
+    return false;
+}
+function hasUnresolvedAllOfReference(node, visited = new Set()) {
+    const position = positionOf(node);
+    if (visited.has(position))
+        return false;
+    visited.add(position);
+    for (const branch of node.allOf ?? []) {
+        const source = referenceOf(branch) !== undefined ? dereferenceChecked(branch) : undefined;
+        if (source?.unresolved || (source && !isSchemaNode(source.node)))
+            return true;
+        const target = source?.node ?? branch;
+        if (hasUnresolvedAllOfReference(target, visited))
+            return true;
+    }
+    return false;
+}
+function expandAllOfReferences(node, stack = new Set()) {
+    const position = positionOf(node);
+    if (stack.has(position))
+        return node;
+    const nextStack = new Set(stack).add(position);
+    const branches = [];
+    let changed = false;
+    for (const branch of node.allOf ?? []) {
+        if (referenceOf(branch) !== undefined) {
+            const { node: target, unresolved } = dereferenceChecked(branch);
+            if (unresolved || !isSchemaNode(target))
+                return undefined;
+            if (nextStack.has(positionOf(target))) {
+                branches.push(branch);
+                continue;
+            }
+            const expanded = expandAllOfReferences(target, nextStack);
+            if (!expanded)
+                return undefined;
+            branches.push(expanded);
+            changed = true;
+            continue;
+        }
+        const expanded = expandAllOfReferences(branch, nextStack);
+        if (!expanded)
+            return undefined;
+        branches.push(expanded);
+        changed ||= expanded !== branch;
+    }
+    return changed ? { ...node, allOf: branches } : node;
+}
+function reduceAllOfForProjection(node, data, scope = []) {
+    if (hasUnresolvedAllOfReference(node))
+        return undefined;
+    if (node.getDraftVersion() !== 'draft-07')
+        return node.reduceNode(data, { path: [...scope] }).node;
+    const expanded = expandAllOfReferences(node);
+    return expanded?.reduceNode(data, { path: [...scope] }).node;
+}
 // A dialect whose reducer leaves $ref unresolved reduces a selected `{ $ref }` branch to `{}`.
-function resolveSelectedBranch(original, reduced, data) {
+function resolveSelectedBranch(original, reduced, data, scope = [], branchApplicability) {
     const reducedSchema = reduced.schema;
     if (reducedSchema && typeof reducedSchema === 'object') {
         if (resolveExplicitType(reducedSchema) || inferProjectionShape(reducedSchema).kind === 'resolved') {
@@ -141,26 +469,41 @@ function resolveSelectedBranch(original, reduced, data) {
     }
     const selected = [];
     if (original.oneOf) {
-        const matching = original.oneOf.filter((branch) => branchApplies(branch, data));
+        const matching = original.oneOf.filter((branch) => branchApplies(branch, data, scope, branchApplicability));
         if (matching.length === 1)
             selected.push(matching[0]);
     }
     for (const branch of original.anyOf ?? []) {
-        if (branchApplies(branch, data))
+        if (branchApplies(branch, data, scope, branchApplicability))
             selected.push(branch);
     }
-    if (!selected.some((branch) => typeof branch.$ref === 'string'))
+    if (!selected.some((branch) => referenceOf(branch) !== undefined))
         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;
+        const targetReduced = target.reduceNode(data, { path: [...scope] }).node ?? target;
         merged = mergeNode(merged, targetReduced) ?? merged;
     }
     return merged;
 }
+/** Fills properties a selected Draft 7 conditional `$ref` loses during reduction. */
+function resolveSelectedConditionalReference(original, reduced, data, scope = [], branchApplicability) {
+    if (original.getDraftVersion() !== 'draft-07' || !original.if)
+        return reduced;
+    const selected = branchApplies(original.if, data, scope, branchApplicability) ? original.then : original.else;
+    if (!selected || typeof selected.$ref !== 'string')
+        return reduced;
+    const target = dereference(selected);
+    if (!isSchemaNode(target))
+        return reduced;
+    const targetReduced = reduceAllOfForProjection(target, data, scope) ?? target;
+    const reducedProperties = reduced.properties ?? {};
+    const hasUnprojectedProperty = Object.keys(targetReduced.properties ?? {}).some((key) => !Object.hasOwn(reducedProperties, key));
+    return hasUnprojectedProperty ? mergeNode(reduced, targetReduced) ?? reduced : reduced;
+}
 export const DEFAULT_LIMITS = { objects: 16, nodes: 512 };
 function walkOrder(a, b) {
     for (let i = 0; i < Math.min(a.length, b.length); i++)
@@ -168,10 +511,19 @@ function walkOrder(a, b) {
             return a[i] - b[i];
     return a.length - b.length;
 }
-function addBoundary(ctx, pointer, reason) {
+function boundaryToken(pointer, schemaKey, generation) {
+    return JSON.stringify([pointer, schemaKey, generation]);
+}
+function addBoundary(ctx, pointer, reason, targetPointer, schemaKey) {
     const reasons = ctx.boundaries.get(pointer) ?? new Set();
     reasons.add(reason);
     ctx.boundaries.set(pointer, reasons);
+    const targets = ctx.boundaryTargets.get(pointer) ?? new Map();
+    if (![...targets.values()].some((target) => target.reason === reason)) {
+        const token = boundaryToken(targetPointer, schemaKey, ctx.boundaryGeneration);
+        targets.set(token, { pointer: toPointer(targetPointer), reason, token });
+    }
+    ctx.boundaryTargets.set(pointer, targets);
 }
 // A leaf needs no reduction, so it rides with its parent's budget unit.
 function isLeafSchema(schema) {
@@ -184,17 +536,14 @@ function isLeafSchema(schema) {
     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
- * Pointer with the root as the empty string.
- *
- * `schemaLocation` is already that, prefixed with the `#` of a URI fragment,
- * and it names what a `$ref` resolves to rather than the reference. Both
- * adapters report sources in this form so a diagnostic means the same thing
- * whichever one produced it.
+ * The authored schema position as a JSON Pointer with the root as the empty
+ * string. Reference sites and targets keep separate positions, and encoded
+ * reference segments use their document spelling. Both adapters report
+ * sources in this form so diagnostics mean the same thing whichever produced
+ * them.
  */
 function documentPointer(node) {
-    const location = node.schemaLocation;
-    return typeof location === 'string' ? location.replace(/^#/, '') : '';
+    return positionOf(node).replace(/^#/, '');
 }
 /**
  * Visits every schema position that applies to one location whatever the
@@ -217,16 +566,13 @@ function documentPointer(node) {
  * several places at once: `properties/x` on the node's own schema and on each
  * of its `allOf` branches are all declarations of the same location.
  */
-function eachUnconditional(roots, visitor) {
+function eachUnconditional(roots, visitor, referenceVisitor, cache) {
     const visited = new Set();
     const visit = (current) => {
+        if (referenceVisitor && cache)
+            visitReferenceDefaultSites(current, cache, referenceVisitor);
         const resolved = dereference(current);
-        // The same guard, and for the same measured reason, as
-        // `collectCandidateProperties`: `resolveRef()` returns a fresh node every
-        // call, so identity alone never closes a cycle, and an inline branch has no
-        // location of its own to key on.
-        const location = resolved.schemaLocation;
-        const key = typeof location === 'string' ? location : resolved;
+        const key = traversalKey(resolved);
         if (visited.has(key))
             return;
         visited.add(key);
@@ -249,9 +595,15 @@ function eachUnconditional(roots, visitor) {
  * own descent already survives the shapes that throw (#119, #121), and a
  * conflict is the wrong place to surface one.
  */
-function branchApplies(branch, data) {
+function branchApplies(branch, data, scope = [], branchApplicability) {
+    if (data === undefined && branchApplicability?.has(branch)) {
+        return branchApplicability.get(branch);
+    }
     try {
-        return branch.validate(data).valid === true;
+        const applies = branch.validate(data, '#', [...scope]).valid === true;
+        if (data === undefined)
+            branchApplicability?.set(branch, applies);
+        return applies;
     }
     catch {
         return false;
@@ -270,18 +622,23 @@ function branchApplies(branch, data) {
  * rule the projection uses to expose that branch, so the two cannot disagree
  * about which branch it is.
  */
-function eachApplicable(roots, data, visitor) {
+function eachApplicable(roots, data, branchApplicability, visitor, referenceVisitor, cache, scope = [], dynamicReferenceProjection = false) {
     const visited = new Set();
-    const visit = (current) => {
-        const resolved = dereference(current);
-        const location = resolved.schemaLocation;
-        const key = typeof location === 'string' ? location : resolved;
+    const visit = (current, parentScope) => {
+        if (referenceVisitor && cache)
+            visitReferenceDefaultSites(current, cache, referenceVisitor, dynamicReferenceProjection);
+        const entered = dynamicReferenceProjection
+            ? enterDynamicScope(current, parentScope)
+            : { node: dereference(current), path: parentScope, dynamicReference: false };
+        const resolved = entered.node;
+        const currentScope = entered.path;
+        const key = traversalKey(resolved);
         if (visited.has(key))
             return;
         visited.add(key);
         visitor(resolved);
         for (const branch of resolved.allOf ?? [])
-            visit(branch);
+            visit(branch, currentScope);
         // `oneOf` contributes the one branch it selects, which is the evaluator's
         // rule and not "every branch the data matches": an empty object matches
         // every permissive branch, and treating all of them as applicable would
@@ -290,82 +647,123 @@ function eachApplicable(roots, data, visitor) {
         // branch stands in, which is what the projection exposes.
         const oneOf = resolved.oneOf ?? [];
         if (oneOf.length > 0) {
-            const matching = oneOf.filter((branch) => branchApplies(branch, data));
+            const matching = oneOf.filter((branch) => branchApplies(branch, data, currentScope, branchApplicability));
             const selected = matching.length === 1
                 ? matching[0]
                 : selectProvisionalBranch(resolved, typeof data === 'object' && data !== null
                     ? data
                     : undefined);
             if (selected)
-                visit(selected);
+                visit(selected, currentScope);
         }
         // `anyOf` is the opposite case and needs no such rule: several of its
         // branches applying at once is ordinary, and each that validates
         // contributes its annotations, so each competes.
         for (const branch of resolved.anyOf ?? []) {
-            if (branchApplies(branch, data))
-                visit(branch);
+            if (branchApplies(branch, data, currentScope, branchApplicability))
+                visit(branch, currentScope);
         }
         if (resolved.if) {
-            const taken = branchApplies(resolved.if, data) ? resolved.then : resolved.else;
+            const taken = branchApplies(resolved.if, data, currentScope, branchApplicability) ? resolved.then : resolved.else;
             if (taken)
-                visit(taken);
+                visit(taken, currentScope);
         }
         const dependent = resolved.dependentSchemas;
         if (dependent && typeof data === 'object' && data !== null && !Array.isArray(data)) {
             for (const [dependency, subschema] of Object.entries(dependent)) {
                 if (Object.prototype.hasOwnProperty.call(data, dependency))
-                    visit(subschema);
+                    visit(subschema, currentScope);
             }
         }
     };
     for (const root of roots)
-        visit(root);
+        visit(root, scope);
 }
-function declarationsFrom(walkRoots) {
-    const declarations = [];
-    walkRoots((node) => {
-        const schema = node.schema;
-        if (schema !== null && typeof schema === 'object' && 'default' in schema) {
-            declarations.push({ value: schema.default, source: documentPointer(node) });
+function enterDynamicScope(node, scope) {
+    const path = [...scope];
+    let current = node;
+    let dynamicReference = false;
+    const seen = new Set();
+    while (typeof current.$ref === 'string' ||
+        typeof current.schema.$dynamicRef === 'string' ||
+        typeof current.schema.$recursiveRef === 'string') {
+        const position = positionOf(current);
+        if (seen.has(position))
+            break;
+        seen.add(position);
+        const resolved = current.resolveRef({ pointer: '#', path });
+        if (!isSchemaNode(resolved))
+            break;
+        const schema = current.schema;
+        if (typeof schema.$dynamicRef === 'string' || typeof schema.$recursiveRef === 'string') {
+            dynamicReference = true;
         }
-    });
+        if (resolved === current)
+            break;
+        if (typeof current.$ref === 'string' &&
+            current.getDraftVersion() !== 'draft-07' &&
+            !onlyPoints(current)) {
+            return { node: dereference(current), path, dynamicReference };
+        }
+        current = resolved;
+    }
+    if (path[path.length - 1]?.node !== current)
+        path.push({ pointer: '#', node: current });
+    return { node: current, path, dynamicReference };
+}
+function declarationsFrom(walkRoots, cache) {
+    const declarations = [];
+    const seen = new Set();
+    const add = (node) => {
+        const schema = authoredSchema(node, cache);
+        if (schema === null || typeof schema !== 'object' || !('default' in schema))
+            return;
+        const record = schema;
+        if (typeof record.$ref === 'string' && cache.dialect === 'draft-07')
+            return;
+        const source = documentPointer(node);
+        if (seen.has(source))
+            return;
+        seen.add(source);
+        declarations.push({ value: record.default, source });
+    };
+    walkRoots(add, add);
     return declarations;
 }
-function collectUnconditionalDefaults(roots) {
-    return declarationsFrom((visitor) => eachUnconditional(roots, visitor));
+function collectUnconditionalDefaults(roots, cache) {
+    return declarationsFrom((visitor, referenceVisitor) => eachUnconditional(roots, visitor, referenceVisitor, cache), cache);
 }
-function collectApplicableDefaults(roots, data) {
-    return declarationsFrom((visitor) => eachApplicable(roots, data, visitor));
+function collectApplicableDefaults(roots, data, cache, scope = [], dynamicReferenceProjection = false, branchApplicability) {
+    return declarationsFrom((visitor, referenceVisitor) => eachApplicable(roots, data, branchApplicability, visitor, referenceVisitor, cache, scope, dynamicReferenceProjection), cache);
 }
 /** The positions that declare one property of `roots`, by both reachability rules. */
-function childPositions(roots, key, data, declaring) {
+function childPositions(roots, key, data, declaring, scope = [], dynamicReferenceProjection = false, branchApplicability) {
     const unconditional = [];
     eachUnconditional(roots.unconditional, (node) => {
-        const child = node.properties?.[key];
+        const child = memberSchema(node, key);
         if (child)
             unconditional.push(child);
     });
     const applicable = [];
-    eachApplicable(roots.applicable, data, (node) => {
-        const child = node.properties?.[key];
+    eachApplicable(roots.applicable, data, branchApplicability, (node) => {
+        const child = memberSchema(node, key);
         if (child)
             applicable.push(child);
-    });
+    }, undefined, undefined, scope, dynamicReferenceProjection);
     return { unconditional, applicable, declaring };
 }
 /** The positions that declare the elements of `roots`, by both reachability rules. */
-function itemPositions(roots, data, declaring) {
+function itemPositions(roots, data, declaring, scope = [], dynamicReferenceProjection = false, branchApplicability) {
     const unconditional = [];
     eachUnconditional(roots.unconditional, (node) => {
         if (node.items)
             unconditional.push(node.items);
     });
     const applicable = [];
-    eachApplicable(roots.applicable, data, (node) => {
+    eachApplicable(roots.applicable, data, branchApplicability, (node) => {
         if (node.items)
             applicable.push(node.items);
-    });
+    }, undefined, undefined, scope, dynamicReferenceProjection);
     return { unconditional, applicable, declaring };
 }
 /**
@@ -380,16 +778,75 @@ function disagreeingDefaults(declarations) {
     const [first, ...rest] = declarations;
     return rest.every((other) => deepEqual(other.value, first.value)) ? undefined : declarations;
 }
+function additionalPropertyKeys(node, data) {
+    if (!node?.additionalProperties)
+        return [];
+    const keys = new Set([...Object.keys(data ?? {}), ...(node.required ?? [])]);
+    return [...keys].filter((key) => !Object.hasOwn(node.properties ?? {}, key) &&
+        !node.patternProperties?.some(({ pattern }) => pattern.test(key)));
+}
+function additionalPropertySchema(node, key) {
+    if (!node || Object.hasOwn(node.properties ?? {}, key))
+        return undefined;
+    if (node.patternProperties?.some(({ pattern }) => pattern.test(key)))
+        return undefined;
+    return node.additionalProperties;
+}
+function memberSchema(node, key) {
+    if (!node)
+        return undefined;
+    if (Object.hasOwn(node.properties ?? {}, key))
+        return node.properties?.[key];
+    return additionalPropertySchema(node, key);
+}
+function applicableAdditionalPropertySchemas(roots, key, data, scope = [], dynamicReferenceProjection = false, branchApplicability) {
+    const schemas = [];
+    const seen = new Set();
+    eachApplicable(roots, data, branchApplicability, (node) => {
+        const schema = additionalPropertySchema(node, key);
+        if (!schema)
+            return;
+        const position = positionOf(schema);
+        if (seen.has(position))
+            return;
+        seen.add(position);
+        schemas.push(schema);
+    }, undefined, undefined, scope, dynamicReferenceProjection);
+    return schemas;
+}
+function applicableRequiredKeys(roots, data, scope = [], dynamicReferenceProjection = false, branchApplicability) {
+    const keys = new Set();
+    eachApplicable(roots, data, branchApplicability, (node) => {
+        for (const key of node.required ?? [])
+            keys.add(key);
+    }, undefined, undefined, scope, dynamicReferenceProjection);
+    return keys;
+}
+function unconditionalRequiredKeys(roots) {
+    const keys = new Set();
+    eachUnconditional(roots, (node) => {
+        for (const key of node.required ?? [])
+            keys.add(key);
+    });
+    return keys;
+}
+function reduceAdditionalPropertySchema(source, data, scope = []) {
+    if (source.getDraftVersion() !== 'draft-07')
+        return source.reduceNode(data, { path: [...scope] }).node ?? source;
+    const { node, unresolved } = dereferenceChecked(source);
+    if (unresolved || !isSchemaNode(node))
+        return source;
+    return reduceAllOfForProjection(node, data) ?? node;
+}
+const candidatePropertyCache = new WeakMap();
 /**
- * Every property key that could appear at this node's own instance location,
- * across every branch that might apply to it.
+ * Property keys that might need to appear at this instance location.
  *
- * This is the static half of the inactive-node contract: a branch the data does
- * not currently select still contributes its property pointers, which then
- * project with `active: false`. The dynamic half is `reduceNode`, which decides
- * which of them apply now, and the two must stay separate. Making the candidate
- * set data-driven would delete a pointer the moment its branch stopped
- * matching, which is exactly the flicker the contract exists to prevent.
+ * Declared keys remain static candidates across all branches. Keys governed
+ * only by `additionalProperties` come from the current data, since the schema
+ * has no finite set of names to enumerate; required names are candidates too.
+ * `reduceNode` decides which candidates apply now, so an inactive branch keeps
+ * its declared pointers with `active: false`.
  *
  * **Recursion is through applicators only, and only those acting on this same
  * instance location**: `if`, `then`, `else`, `allOf`, `anyOf`, `oneOf`,
@@ -409,20 +866,20 @@ function disagreeingDefaults(declarations) {
  * - **`items` and `prefixItems`**, for the same reason: an array's items are
  *   their own locations.
  *
- * The cycle guard keys on `schemaLocation` rather than on node identity, which
- * was measured rather than assumed and is the opposite of what it looks like it
- * should be: `resolveRef()` returns a fresh `SchemaNode` on every call, and the
- * raw `schema` object it wraps is fresh too, so an identity `Set` never matches
- * and a recursive `$ref` would not terminate. `schemaLocation` is stable, is
- * distinct for each inline branch position, and repeats when a reference closes
- * a cycle, which is precisely the three properties needed. The set is per call,
- * because deduplicating a schema location is only sound while collecting names
- * for one instance location; the same schema legitimately recurs at a deeper
- * pointer, and `walk` visits it again there.
+ * Inline conditional branches use `positionOf` because the library can assign
+ * `if`, `then` and `else` the same `schemaLocation` after resolving a
+ * reference. Other nodes keep their location key, so references still close
+ * at the same point in the traversal as before.
  */
-function collectCandidateProperties(node) {
+function collectCandidateProperties(node, data, declarations = []) {
+    if (declarations.length === 0 && candidatePropertyCache.has(node)) {
+        const cached = candidatePropertyCache.get(node);
+        if (cached)
+            return cached;
+    }
     const candidates = new Map();
     const visited = new Set();
+    const scopes = [];
     const record = (key, propNode, direct) => {
         const entry = candidates.get(key) ?? { alternatives: [] };
         if (direct)
@@ -433,26 +890,11 @@ function collectCandidateProperties(node) {
     };
     const visit = (current, own) => {
         const resolved = dereference(current);
-        // Keyed on `schemaLocation` where there is one, and on the node itself
-        // where there is not, which together cover every way the traversal can
-        // come back to where it started.
-        //
-        // Neither alone is sufficient and each covers what the other cannot. A
-        // cycle requires a `$ref`, because an inline schema cannot nest into
-        // itself, and `resolveRef()` returns a fresh `SchemaNode` on every call
-        // whose raw `schema` object is fresh too, so identity never matches across
-        // one; those nodes do carry a location. An inline branch is never resolved
-        // through a ref, so its identity is stable within one traversal.
-        //
-        // This deliberately replaced a depth cap. A cap terminates, but it does so
-        // by dropping candidates a valid schema declared, which is the silent
-        // disappearance the whole projection-diagnostic design exists to prevent:
-        // a field nested under 70 applicators is still a field.
-        const location = resolved.schemaLocation;
-        const key = typeof location === 'string' ? location : resolved;
+        const key = traversalKey(resolved);
         if (visited.has(key))
             return;
         visited.add(key);
+        scopes.push({ node: resolved, own });
         for (const [key, propNode] of Object.entries(resolved.properties ?? {})) {
             record(key, propNode, own);
         }
@@ -460,7 +902,9 @@ function collectCandidateProperties(node) {
             if (branch)
                 visit(branch, false);
         }
-        for (const branches of [resolved.allOf, resolved.anyOf, resolved.oneOf]) {
+        for (const branch of resolved.allOf ?? [])
+            visit(branch, own);
+        for (const branches of [resolved.anyOf, resolved.oneOf]) {
             for (const branch of branches ?? [])
                 visit(branch, false);
         }
@@ -471,8 +915,32 @@ function collectCandidateProperties(node) {
         }
     };
     visit(node, true);
+    for (const declaration of declarations)
+        visit(declaration, false);
+    const memberKeys = new Set(Object.keys(data ?? {}));
+    for (const scope of scopes)
+        for (const key of scope.node.required ?? [])
+            memberKeys.add(key);
+    for (const { node: scope, own } of scopes) {
+        for (const key of memberKeys) {
+            const propNode = additionalPropertySchema(scope, key);
+            if (propNode)
+                record(key, propNode, own);
+        }
+    }
+    const hasDataDependentAdditionalProperties = scopes.some(({ node: scope }) => Boolean(scope.additionalProperties));
+    if (declarations.length === 0) {
+        candidatePropertyCache.set(node, hasDataDependentAdditionalProperties ? null : candidates);
+    }
     return candidates;
 }
+function hasRetainedDescendant(position, cache) {
+    for (const retained of cache.retainedPositions) {
+        if (retained === position || retained.startsWith(`${position}/`))
+            return true;
+    }
+    return false;
+}
 /**
  * The schema to project for a candidate when no branch is active.
  *
@@ -646,6 +1114,96 @@ function computeRequiredSet(resolved, reducedSchema, dataRecord) {
     }
     return required;
 }
+// reduceNode recompiles a subtree when any descendant has reduction work.
+const REDUCE_NODE_SCHEMA_FIELDS = [
+    '$ref',
+    '$dynamicRef',
+    '$recursiveRef',
+    '$defs',
+    'if',
+    'then',
+    'else',
+    'allOf',
+    'anyOf',
+    'oneOf',
+    'contains',
+    'dependentSchemas',
+    'dependentRequired',
+    'definitions',
+    'dependencies',
+    'patternProperties',
+    'propertyDependencies',
+];
+const SCHEMA_MAP_KEYWORDS = [
+    '$defs',
+    'definitions',
+    'dependentSchemas',
+    'patternProperties',
+    'properties',
+];
+const SCHEMA_SINGLE_KEYWORDS = [
+    'additionalItems',
+    'additionalProperties',
+    'contains',
+    'if',
+    'items',
+    'not',
+    'propertyNames',
+    'then',
+    'else',
+    'unevaluatedItems',
+    'unevaluatedProperties',
+];
+const SCHEMA_ARRAY_KEYWORDS = ['allOf', 'anyOf', 'oneOf', 'prefixItems'];
+const reductionRequirementCache = new WeakMap();
+function schemaRequiresReduction(schema, visiting = new WeakSet()) {
+    if (schema === true)
+        return true;
+    if (typeof schema !== 'object' || schema === null)
+        return false;
+    const cached = reductionRequirementCache.get(schema);
+    if (cached !== undefined)
+        return cached;
+    if (visiting.has(schema))
+        return false;
+    visiting.add(schema);
+    const record = schema;
+    const direct = REDUCE_NODE_SCHEMA_FIELDS.some((field) => Object.prototype.hasOwnProperty.call(record, field)) ||
+        Object.prototype.hasOwnProperty.call(record, 'oneOfProperty') ||
+        Array.isArray(record.type);
+    const children = [];
+    for (const keyword of SCHEMA_MAP_KEYWORDS) {
+        const value = record[keyword];
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            children.push(...Object.values(value));
+        }
+    }
+    for (const keyword of SCHEMA_SINGLE_KEYWORDS) {
+        const value = record[keyword];
+        if (keyword === 'items' && Array.isArray(value))
+            children.push(...value);
+        else if (value !== undefined)
+            children.push(value);
+    }
+    for (const keyword of SCHEMA_ARRAY_KEYWORDS) {
+        const value = record[keyword];
+        if (Array.isArray(value))
+            children.push(...value);
+    }
+    for (const value of Object.values(record.dependencies ?? {}))
+        children.push(value);
+    for (const values of Object.values(record.propertyDependencies ?? {})) {
+        if (typeof values === 'object' && values !== null)
+            children.push(...Object.values(values));
+    }
+    const required = direct || children.some((child) => schemaRequiresReduction(child, visiting));
+    visiting.delete(schema);
+    reductionRequirementCache.set(schema, required);
+    return required;
+}
+function requiresReduction(node) {
+    return node.reducers.length > 0 || schemaRequiresReduction(node.schema);
+}
 // An unreadable identity is never a repeat, and is budgeted so it cannot expand without end.
 const budgeted = (info) => info.cyclic || info.key === '';
 /**
@@ -675,9 +1233,15 @@ 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) {
+lineage, path, scope, dynamicReferenceAtLocation = false) {
+    if (ctx.cache.dynamicReferenceProjection) {
+        const entered = enterDynamicScope(node, scope);
+        node = entered.node;
+        scope = entered.path;
+        dynamicReferenceAtLocation ||= entered.dynamicReference;
+    }
     const info = locationInfo(declaredAt.declaring, ctx.cache);
-    const { node: original, cycle: referenceCycle } = dereferenceChecked(node);
+    const { node: original, cycle: referenceCycle, unresolved: unresolvedReference } = dereferenceChecked(node);
     if (info.cycle || referenceCycle) {
         diagnostics.push({
             pointer: toPointer(pointer),
@@ -688,10 +1252,13 @@ lineage, path) {
         return;
     }
     const pastData = member && (data === undefined || data === null);
-    const recursive = pastData && ((lineage?.recursive ?? false) || budgeted(info));
+    const token = boundaryToken(pointer, info.key, ctx.boundaryGeneration);
+    const recursive = pastData && !unresolvedReference && ((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');
+        if (info.key !== '' &&
+            ancestor.key === info.key &&
+            !ctx.expandedBoundaryTokens.has(token)) {
+            addBoundary(ctx, ancestor.pointer, 'recursion', pointer, info.key);
             ctx.removed.add(pointer);
             return;
         }
@@ -702,21 +1269,29 @@ lineage, path) {
         let admit;
         if (isLeafSchema(originalSchema)) {
             const covered = ctx.reserved.has(parent);
-            admit = covered || ctx.nodesUsed < ctx.limits.nodes;
+            admit = ctx.expandedBoundaryTokens.has(token) || 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;
+            const explicitlyExpanded = ctx.expandedBoundaryTokens.has(token);
+            const retainedDeclarations = declaredAt.declaring.filter((declaration) => hasRetainedDescendant(positionOf(declaration), ctx.cache));
+            const candidateDeclarations = dynamicReferenceAtLocation
+                ? []
+                : [...declaredAt.applicable, ...retainedDeclarations];
+            const leaves = [...collectCandidateProperties(original, undefined, candidateDeclarations).values()].filter((candidate) => isLeafSchema(dereference(candidatePrototype(candidate)).schema)).length;
+            admit =
+                explicitlyExpanded ||
+                    (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);
+                ctx.nodesUsed += explicitlyExpanded ? 1 : 1 + leaves;
+                if (!explicitlyExpanded)
+                    ctx.reserved.add(pointer);
             }
         }
         if (!admit) {
-            addBoundary(ctx, parent, 'budget');
+            addBoundary(ctx, parent, 'budget', pointer, info.key);
             ctx.removed.add(pointer);
             return;
         }
@@ -727,6 +1302,36 @@ lineage, path) {
     let resolved = original;
     let schema = originalSchema;
     let type = resolveExplicitType(schema);
+    const localShape = inferProjectionShape(schema);
+    const allOfType = original.allOf ? allOfExplicitType(original) : undefined;
+    const hasReferencedAllOfBranch = original.allOf ? hasReferencedAllOf(original) : false;
+    if (original.allOf &&
+        !original.oneOf &&
+        !original.anyOf &&
+        !type &&
+        (localShape.kind !== 'resolved' || allOfType !== undefined) &&
+        (hasReferencedAllOfBranch || allOfType !== undefined)) {
+        const reductionData = (allOfType === 'object' || declaresObject(original)) &&
+            (data === undefined || data === null)
+            ? {}
+            : data;
+        const reduced = reduceAllOfForProjection(original, reductionData, scope);
+        const reducedSchema = reduced?.schema;
+        if (reduced && reducedSchema && typeof reducedSchema === 'object') {
+            resolved = reduced;
+            schema = reducedSchema;
+            if (!type)
+                type = resolveExplicitType(schema);
+        }
+    }
+    if (!type && ctx.cache.dynamicReferenceProjection && original.allOf?.length) {
+        const reduced = original.reduceNode(data, { path: [...scope] }).node;
+        if (reduced) {
+            resolved = reduced;
+            schema = reduced.schema;
+            type = resolveExplicitType(schema);
+        }
+    }
     // Whether this node's own active branch could be determined. Stays true for every
     // node except a typeless oneOf/anyOf wrapper whose branch could not be resolved
     // (see below), where the node's own presence in the projection is the thing in
@@ -750,9 +1355,9 @@ lineage, path) {
     let wrapperIdentified = false;
     if (!type && (original.oneOf || original.anyOf)) {
         composedAgainstData = true;
-        const { node: branchNode } = original.reduceNode(data);
+        const { node: branchNode } = original.reduceNode(data, { path: [...scope] });
         if (branchNode) {
-            resolved = resolveSelectedBranch(original, branchNode, data);
+            resolved = resolveSelectedBranch(original, branchNode, data, scope, ctx.branchApplicability);
             schema = resolved.schema;
             type = resolveExplicitType(schema);
         }
@@ -834,6 +1439,15 @@ lineage, path) {
             diagnostics.push(shapeDiagnostic(toPointer(pointer), shape, schema.enum !== undefined));
         }
     }
+    // Arrays do not pass through the object path that reduces the active schema.
+    if (type === 'array' && resolved === original && original.allOf) {
+        const reduced = reduceAllOfForProjection(original, data, scope);
+        const reducedSchema = reduced?.schema;
+        if (reduced && reducedSchema && typeof reducedSchema === 'object') {
+            resolved = reduced;
+            schema = reducedSchema;
+        }
+    }
     if (!type)
         return;
     const selfLineage = pastData
@@ -843,7 +1457,7 @@ lineage, path) {
     // 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
     // all would be the same schema reported twice.
-    const ambiguousDefault = disagreeingDefaults(collectUnconditionalDefaults(declaredAt.unconditional));
+    const ambiguousDefault = disagreeingDefaults(collectUnconditionalDefaults(declaredAt.unconditional, ctx.cache));
     if (ambiguousDefault) {
         diagnostics.push({
             pointer: toPointer(pointer),
@@ -858,13 +1472,18 @@ lineage, path) {
     // 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 applicableDeclarations = collectApplicableDefaults(declaredAt.applicable, data);
+    const applicableData = type === 'object' && !(typeof data === 'object' && data !== null) ? {} : data;
+    const applicableDeclarations = collectApplicableDefaults(declaredAt.applicable, applicableData, ctx.cache, scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability);
     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
+    const defaultSources = !conflictedDefault && applicableDeclarations.length > 0 && info.cyclic
         ? [...new Set(applicableDeclarations.map((declaration) => declaration.source))].sort()
         : undefined;
+    const defaultOverride = {
+        present: applicableDeclarations.length > 0,
+        value: applicableDeclarations[0]?.value,
+    };
     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
@@ -889,19 +1508,73 @@ lineage, path) {
         // 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.
-        let reducedNode = resolved === original ? resolved.reduceNode(dataRecord ?? {}).node : resolved;
+        let reducedNode = resolved === original
+            ? requiresReduction(resolved)
+                ? original.allOf && hasReferencedAllOf(original)
+                    ? reduceAllOfForProjection(resolved, dataRecord ?? {}, scope)
+                    : resolved.reduceNode(dataRecord ?? {}, { path: [...scope] }).node
+                : resolved
+            : resolved;
+        if (reducedNode && resolved === original && (!member || data !== undefined)) {
+            // Missing child data has no evaluated conditional branch to recover.
+            reducedNode = resolveSelectedConditionalReference(original, reducedNode, dataRecord ?? {}, scope, ctx.branchApplicability);
+        }
         if (reducedNode &&
             resolved === original &&
             !resolveExplicitType(originalSchema) &&
             (original.oneOf || original.anyOf)) {
-            reducedNode = resolveSelectedBranch(original, reducedNode, dataRecord ?? {});
+            reducedNode = resolveSelectedBranch(original, reducedNode, dataRecord ?? {}, scope, ctx.branchApplicability);
         }
         const reducedSchema = reducedNode?.schema;
         const reducedProperties = reducedSchema?.properties ??
             schema.properties ??
             {};
-        const activeKeys = new Set(Object.keys(reducedProperties));
+        // Dynamic applicability is rebuilt below; only retained declarations belong beside it here.
+        const retainedDeclarations = declaredAt.declaring.filter((declaration) => hasRetainedDescendant(positionOf(declaration), ctx.cache));
+        const candidateDeclarations = dynamicReferenceAtLocation
+            ? []
+            : [...declaredAt.applicable, ...retainedDeclarations];
+        let candidateProps = collectCandidateProperties(original, dataRecord, candidateDeclarations);
+        const activeKeys = new Set([
+            ...Object.keys(reducedProperties),
+            ...additionalPropertyKeys(reducedNode, dataRecord),
+        ]);
+        if (!reducedNode) {
+            for (const [key, candidate] of candidateProps) {
+                if (candidate.direct)
+                    activeKeys.add(key);
+            }
+        }
         const requiredSet = computeRequiredSet(resolved, reducedSchema, dataRecord);
+        const dynamicApplicableNodes = [];
+        if (ctx.cache.dynamicReferenceProjection) {
+            eachApplicable([original], data, ctx.branchApplicability, (applicableNode) => {
+                dynamicApplicableNodes.push(applicableNode);
+                for (const key of Object.keys(applicableNode.properties ?? {}))
+                    activeKeys.add(key);
+                for (const key of applicableNode.required ?? [])
+                    requiredSet.add(key);
+            }, undefined, undefined, scope, true);
+            const expandedCandidates = new Map(candidateProps);
+            const activeCandidateNode = reducedNode ?? resolved;
+            if (activeCandidateNode !== original) {
+                for (const [key, candidate] of collectCandidateProperties(activeCandidateNode, dataRecord)) {
+                    if (!expandedCandidates.has(key))
+                        expandedCandidates.set(key, candidate);
+                }
+            }
+            for (const applicableNode of dynamicApplicableNodes) {
+                for (const [key, propertyNode] of Object.entries(applicableNode.properties ?? {})) {
+                    if (!expandedCandidates.has(key))
+                        expandedCandidates.set(key, { direct: propertyNode, alternatives: [] });
+                }
+            }
+            candidateProps = expandedCandidates;
+        }
+        if (!reducedNode) {
+            for (const key of unconditionalRequiredKeys(declaredAt.unconditional))
+                requiredSet.add(key);
+        }
         // Two conditions, and they are not the same kind of condition.
         //
         // Exposure is load-bearing. Selection is local, but whether this node is
@@ -921,11 +1594,32 @@ lineage, path) {
             : undefined;
         const provisionalSchema = provisionalBranch?.schema;
         const provisionalKeys = new Set(Object.keys(provisionalSchema?.properties ?? {}));
+        for (const key of additionalPropertyKeys(provisionalBranch, dataRecord))
+            provisionalKeys.add(key);
         const provisionalRequired = new Set(Array.isArray(provisionalSchema?.required) ? provisionalSchema.required : []);
         // Candidates are collected from `original`, not `resolved`, so every oneOf/anyOf
         // branch's properties are represented (the matching branch alone, via `resolved`,
         // would only expose its own properties).
-        const candidateProps = collectCandidateProperties(original);
+        const applicableRequired = applicableRequiredKeys(declaredAt.applicable, applicableData, scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability);
+        const provisionalRequiredKeys = provisionalBranch
+            ? applicableRequiredKeys([provisionalBranch], applicableData, scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability)
+            : new Set();
+        for (const key of candidateProps.keys()) {
+            const present = dataRecord !== undefined && Object.hasOwn(dataRecord, key);
+            if ((present || applicableRequired.has(key)) &&
+                applicableAdditionalPropertySchemas(declaredAt.applicable, key, applicableData, scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability).length > 0) {
+                activeKeys.add(key);
+            }
+        }
+        if (provisionalBranch) {
+            for (const key of candidateProps.keys()) {
+                if (provisionalRequiredKeys.has(key) &&
+                    (applicableAdditionalPropertySchemas(declaredAt.applicable, key, applicableData, scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability).length > 0 ||
+                        applicableAdditionalPropertySchemas([provisionalBranch], key, applicableData, scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability).length > 0)) {
+                    provisionalKeys.add(key);
+                }
+            }
+        }
         const propKeys = [...candidateProps.keys()];
         const children = propKeys.length > 0
             ? propKeys.map((key) => {
@@ -951,7 +1645,7 @@ lineage, path) {
             active: nodeActive,
             provisional: nodeProvisional ? true : undefined,
             defaultConflict,
-            annotations: extractAnnotations(schema, conflictedDefault),
+            annotations: extractAnnotations(schema, conflictedDefault, defaultOverride),
             ...(defaultSources !== undefined ? { defaultSources } : {}),
         });
         for (const [index, key] of propKeys.entries()) {
@@ -961,29 +1655,89 @@ lineage, path) {
             // selected ancestor its own locally applicable properties are
             // provisional too, while a locally inactive one stays inactive.
             const childProvisional = !childActive && nodeExposed && (activeKeys.has(key) || provisionalKeys.has(key));
-            const reducedChildNode = reducedNode?.properties?.[key];
+            const reducedChildNode = memberSchema(reducedNode, key);
             // Precedence matters as much as the selection does. Marking the right
             // branch provisional while taking its shape from `candidatePrototype`,
             // which is first-wins across branches, would render another branch's
             // widget and annotations under the selected branch's name, and would hand
             // ADR-003's pass another branch's `default`.
-            const provisionalChildNode = provisionalBranch?.properties?.[key];
+            const provisionalChildNode = memberSchema(provisionalBranch, key);
             const candidate = candidateProps.get(key);
-            // Three states, in order of authority. What the evaluator reduced against
-            // the data is the schema as it actually applies. Failing that, the node's
-            // own declaration composed with the selected branch, which is what the
-            // reduction would have produced had the branch been complete. Failing
-            // both, a stated placeholder for a location no branch has claimed.
-            const childNode = reducedChildNode ??
+            const childData = dataRecord !== undefined && Object.hasOwn(dataRecord, key) ? dataRecord[key] : undefined;
+            const sourceChildNode = reducedChildNode ?? candidate.direct ?? candidatePrototype(candidate);
+            const sourceSchema = sourceChildNode.schema;
+            let scopedChildNode;
+            let childScope = scope;
+            if (ctx.cache.dynamicReferenceProjection && childActive) {
+                const nextScope = [...scope];
+                if (typeof sourceSchema.$dynamicAnchor === 'string' ||
+                    typeof sourceSchema.$id === 'string' ||
+                    sourceSchema.$recursiveAnchor === true) {
+                    nextScope.push({ pointer: `#${childPointer}`, node: sourceChildNode });
+                }
+                const result = resolved.getNodeChild(key, dataRecord ?? {}, {
+                    pointer: `#${childPointer}`,
+                    path: nextScope,
+                });
+                if (!result.error && isSchemaNode(result.node)) {
+                    scopedChildNode = result.node;
+                    if (nextScope[nextScope.length - 1]?.node !== scopedChildNode) {
+                        nextScope.push({ pointer: `#${childPointer}`, node: scopedChildNode });
+                    }
+                    childScope = nextScope;
+                }
+            }
+            let applicableChildNode = reducedChildNode;
+            let scopedApplicableChildNode = scopedChildNode;
+            const hasScopedReference = typeof sourceSchema.$dynamicRef === 'string' || typeof sourceSchema.$recursiveRef === 'string';
+            for (const source of applicableAdditionalPropertySchemas(declaredAt.applicable, key, applicableData, scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability)) {
+                const alreadyApplicable = applicableChildNode !== undefined && positionOf(applicableChildNode) === positionOf(source);
+                const alreadyScoped = scopedApplicableChildNode !== undefined && positionOf(scopedApplicableChildNode) === positionOf(source);
+                if (alreadyApplicable && (!scopedApplicableChildNode || alreadyScoped))
+                    continue;
+                const reduced = reduceAdditionalPropertySchema(source, childData, scope);
+                if (!alreadyApplicable) {
+                    applicableChildNode =
+                        applicableChildNode === undefined
+                            ? reduced
+                            : mergeNode(applicableChildNode, reduced) ?? applicableChildNode;
+                }
+                if (scopedApplicableChildNode && !alreadyScoped) {
+                    scopedApplicableChildNode = mergeNode(scopedApplicableChildNode, reduced) ?? scopedApplicableChildNode;
+                }
+            }
+            // Applicable declarations retain their authored scope here. The parent
+            // reducer merges `properties` across `allOf`, which can make an
+            // `additionalProperties` schema in a separate branch appear inapplicable.
+            // Failing that, use the reducer's child, then the selected branch, then a
+            // stable placeholder from the candidate set.
+            const childNode = (hasScopedReference ? scopedApplicableChildNode : undefined) ??
+                applicableChildNode ??
                 composeChild(candidate.direct, provisionalChildNode) ??
                 candidatePrototype(candidate);
-            const positions = childPositions(declaredAt, key, 
+            let 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.
-            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]);
+            // the child's data. `applicableData` is the reducer's object stand-in
+            // when this location has no object value yet.
+            applicableData, childDeclaring(info, key), scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability);
+            const dynamicChildDeclarations = dynamicApplicableNodes.flatMap((applicableNode) => {
+                const dynamicChild = applicableNode.properties?.[key];
+                return dynamicChild ? [dynamicChild] : [];
+            });
+            positions = {
+                ...positions,
+                declaring: extendDeclaring(positions.declaring, dynamicChildDeclarations),
+            };
+            if (scopedChildNode && hasScopedReference && !positions.declaring.includes(scopedChildNode)) {
+                positions = {
+                    ...positions,
+                    applicable: [...positions.applicable, scopedChildNode],
+                    declaring: [...positions.declaring, scopedChildNode],
+                };
+            }
+            const enter = () => walk(childNode, childPointer, childData, childActive, childProvisional, nodes, diagnostics, positions, ctx, true, selfLineage, [...path, index], childScope, hasScopedReference);
             // 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)
@@ -1003,7 +1757,7 @@ lineage, path) {
         active: nodeActive,
         provisional: nodeProvisional ? true : undefined,
         defaultConflict,
-        annotations: extractAnnotations(schema, conflictedDefault),
+        annotations: extractAnnotations(schema, conflictedDefault, defaultOverride),
         ...(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
@@ -1016,9 +1770,9 @@ lineage, path) {
             : undefined,
     });
     if (type === 'array' && resolved.items && Array.isArray(data)) {
-        const elementPositions = itemPositions(declaredAt, data, itemDeclaring(info));
+        const elementPositions = itemPositions(declaredAt, data, itemDeclaring(info), scope, ctx.cache.dynamicReferenceProjection, ctx.branchApplicability);
         data.forEach((item, index) => {
-            walk(resolved.items, `${pointer}/${index}`, item, nodeActive, nodeProvisional, nodes, diagnostics, elementPositions, ctx, false, undefined, [...path, index]);
+            walk(resolved.items, `${pointer}/${index}`, item, nodeActive, nodeProvisional, nodes, diagnostics, elementPositions, ctx, false, undefined, [...path, index], scope);
         });
     }
 }
@@ -1032,13 +1786,17 @@ lineage, path) {
  * 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, cache, limits = DEFAULT_LIMITS) {
+export function buildProjection(root, data, cache, limits = DEFAULT_LIMITS, options = {}) {
     const nodes = new Map();
     const diagnostics = [];
     const ctx = {
         cache,
+        branchApplicability: cache.memoizeUndefinedBranchResults ? new WeakMap() : undefined,
         limits,
         boundaries: new Map(),
+        boundaryTargets: new Map(),
+        expandedBoundaryTokens: options.expandedBoundaryTokens ?? new Set(),
+        boundaryGeneration: options.boundaryGeneration ?? 0,
         removed: new Set(),
         flagged: new Set(),
         reserved: new Set(),
@@ -1046,7 +1804,7 @@ export function buildProjection(root, data, cache, limits = DEFAULT_LIMITS) {
         objectsUsed: 0,
         nodesUsed: 0,
     };
-    walk(root, '', data, true, false, nodes, diagnostics, { unconditional: [root], applicable: [root], declaring: [root] }, ctx, false, undefined, []);
+    walk(root, '', data, true, false, nodes, diagnostics, { unconditional: [root], applicable: [root], declaring: [root] }, ctx, false, undefined, [], [{ pointer: '#', node: root }]);
     for (const level of ctx.queue)
         for (const { enter } of (level ?? []).sort((a, b) => walkOrder(a.path, b.path)))
             enter();
@@ -1066,6 +1824,13 @@ export function buildProjection(root, data, cache, limits = DEFAULT_LIMITS) {
         if (node) {
             ;
             node.boundaries = ['recursion', 'budget'].filter((reason) => reasons.has(reason));
+            const targets = ctx.boundaryTargets.get(pointer);
+            if (targets) {
+                ;
+                node.boundaryTargets = [
+                    ...targets.values(),
+                ];
+            }
         }
     }
     return { nodes, diagnostics };