@depup/typebox 1.3.27-depup.0 → 1.3.34-depup.0

package/build/schema/resolve/resolve.mjs

@@ -1,49 +1,67 @@
-// deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Pointer } from '../pointer/index.mjs';
 import * as Schema from '../types/index.mjs';
-export const DefaultBase = 'https://json-schema.org';
+import * as Stack from '../engine/_stack.mjs';
 // ------------------------------------------------------------------
-// Find: FindDynamicAnchor
+// Helpers
+//
+// Utilities to compute schema base URIs, normalize absolute URLs,
+// strip URL fragments for canonical hrefs, find target base URIs,
+// resolve $ref root schemas, and identify JSON pointers vs anchors.
+// ------------------------------------------------------------------
+function RelativeBase(schema, base) {
+    return Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? Stack.NextUri(schema.$id, base.href) : base;
+}
+function AbsoluteBase(base) {
+    return Stack.NextUri(base, Stack.DefaultUri);
+}
+function CanonicalHref(url) {
+    return url.href.split('#')[0];
+}
+function Base(schema, base, target) {
+    return SearchBase(schema, AbsoluteBase(base), target);
+}
+function RefRoot(stack, ref) {
+    return (ref.$ref.startsWith('#') || stack.enteredResource) ? stack.lexicalSchema : stack.schema;
+}
+function IsPointerFragment(fragment) {
+    return fragment.startsWith('#/');
+}
+// ------------------------------------------------------------------
+// Search
+//
+// Recursive tree walks that locate things by identity, not URL.
+// SearchDynamicAnchor finds a node with a matching $dynamicAnchor.
+// SearchBase finds a specific target schema (by reference) and
+// returns its base URI, tracking $id rebasing as it descends.
 // ------------------------------------------------------------------
-function FindDynamicAnchor(schema, name) {
+function SearchDynamicAnchor(schema, name) {
     if (Guard.IsObject(schema) && Schema.IsDynamicAnchor(schema) && Guard.IsEqual(schema.$dynamicAnchor, name)) {
         return schema;
     }
     if (Guard.IsObject(schema)) {
         for (const key of Guard.Keys(schema)) {
-            const result = FindDynamicAnchor(schema[key], name);
+            const result = SearchDynamicAnchor(schema[key], name);
             if (result)
                 return result;
         }
     }
-    // (no-coverage) - is it even possible to search for an anchor
-    // with embedded logical schema like allOf, anyOf, etc?
-    // if (Guard.IsArray(schema)) { // (no-coverage)
-    //   for (const item of schema) {
-    //     const result = FindDynamicAnchor(item, name)
-    //     if (result) return result
-    //   }
-    // }
     return undefined;
 }
-// ------------------------------------------------------------------
-// Find: FindBase
-// ------------------------------------------------------------------
-function FindBase(schema, base, target) {
+function SearchBase(schema, base, target) {
     if (Guard.IsEqual(schema, target))
         return base.href;
-    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
+    const nextBase = RelativeBase(schema, base);
     if (Guard.IsArray(schema)) {
         for (const item of schema) {
-            const result = FindBase(item, nextBase, target);
+            const result = SearchBase(item, nextBase, target);
             if (!Guard.IsUndefined(result))
                 return result;
         }
     }
     else if (Guard.IsObject(schema)) {
         for (const key of Guard.Keys(schema)) {
-            const result = FindBase(schema[key], nextBase, target);
+            const result = SearchBase(schema[key], nextBase, target);
             if (!Guard.IsUndefined(result))
                 return result;
         }
@@ -51,277 +69,263 @@ function FindBase(schema, base, target) {
     return undefined;
 }
 // ------------------------------------------------------------------
-// Match: MatchId
-// ------------------------------------------------------------------
-function MatchId(schema, base, ref) {
-    // ref is a bare fragment naming this schema's $id directly
+// Match
+//
+// Tests whether a schema node is what a reference URL points to.
+// MatchSchemaObject checks a single node in order: $id, $anchor,
+// $dynamicAnchor, then JSON pointer/hash. MatchFromArray,
+// MatchFromObject, and Match recurse through the tree to try every
+// node, skipping const and enum since their values are user data,
+// not schema.
+// ------------------------------------------------------------------
+function MatchWithHash(schema, ref) {
+    if (ref.href.endsWith('#'))
+        return schema;
+    if (!ref.hash.startsWith('#'))
+        return undefined;
+    const fragment = decodeURIComponent(ref.hash.slice(1));
+    if (!fragment.startsWith('/'))
+        return undefined;
+    return Pointer.Get(schema, fragment);
+}
+function MatchWithId(schema, base, ref) {
+    if (!Schema.IsId(schema))
+        return undefined;
     if (Guard.IsEqual(schema.$id, ref.hash))
         return schema;
     const absoluteRef = new URL(ref.href, base.href);
-    // ref shares this $id's document, so resolve the fragment within it
     if (Guard.IsEqual(base.pathname, absoluteRef.pathname))
-        return ref.hash.startsWith('#') ? MatchHash(schema, ref) : schema;
+        return ref.hash.startsWith('#') ? MatchWithHash(schema, ref) : schema;
     return undefined;
 }
-// ------------------------------------------------------------------
-// Match: MatchAnchor
-// ------------------------------------------------------------------
-function MatchAnchor(schema, base, ref) {
+function MatchWithAnchor(schema, base, ref) {
+    if (!Schema.IsAnchor(schema))
+        return undefined;
     const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
     const absoluteRef = new URL(ref.href, base.href);
     return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
 }
-// ------------------------------------------------------------------
-// Match: MatchDynamicAnchor
-// ------------------------------------------------------------------
-function MatchDynamicAnchor(schema, base, ref) {
+function MatchWithDynamicAnchor(schema, base, ref) {
+    if (!Schema.IsDynamicAnchor(schema))
+        return undefined;
     const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
     const absoluteRef = new URL(ref.href, base.href);
     const isMatch = Guard.IsEqual(absoluteAnchor.href, absoluteRef.href);
     return isMatch ? schema : undefined;
 }
-// ------------------------------------------------------------------
-// Match: MatchHash
-// ------------------------------------------------------------------
-function MatchHash(schema, ref) {
-    if (ref.href.endsWith('#'))
-        return schema;
-    if (!ref.hash.startsWith('#'))
-        return undefined;
-    const fragment = decodeURIComponent(ref.hash.slice(1));
-    if (!fragment.startsWith('/'))
+function MatchSchemaObject(schema, base, ref) {
+    if (!Schema.IsSchemaObject(schema))
         return undefined;
-    const result = Pointer.Get(schema, fragment);
-    return result;
+    return MatchWithId(schema, base, ref) ??
+        MatchWithAnchor(schema, base, ref) ??
+        MatchWithDynamicAnchor(schema, base, ref) ??
+        MatchWithHash(schema, ref);
 }
-// ------------------------------------------------------------------
-// Match: Match
-// ------------------------------------------------------------------
-function Match(schema, base, ref) {
-    if (Schema.IsId(schema)) {
-        const result = MatchId(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Schema.IsAnchor(schema)) {
-        const result = MatchAnchor(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Schema.IsDynamicAnchor(schema)) {
-        const result = MatchDynamicAnchor(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    return MatchHash(schema, ref);
-}
-// ------------------------------------------------------------------
-// FromArray
-// ------------------------------------------------------------------
-function FromArray(schema, base, ref) {
+function MatchFromArray(schema, base, ref) {
+    if (!Guard.IsArray(schema))
+        return undefined;
     return schema.reduce((result, item) => {
-        const match = FromValue(item, base, ref);
+        const match = Match(item, base, ref);
         return !Guard.IsUndefined(match) ? match : result;
     }, undefined);
 }
-// ------------------------------------------------------------------
-// FromObject
-// ------------------------------------------------------------------
-function SkipProperty(key) {
-    return Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum');
-}
-function FromObject(schema, base, ref) {
+function MatchFromObject(schema, base, ref) {
+    if (!Guard.IsObject(schema))
+        return undefined;
     return Guard.Keys(schema).reduce((result, key) => {
-        if (SkipProperty(key))
+        if (Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum'))
             return result;
-        const match = FromValue(schema[key], base, ref);
+        const match = Match(schema[key], base, ref);
         return !Guard.IsUndefined(match) ? match : result;
     }, undefined);
 }
-// ------------------------------------------------------------------
-// FromValue
-// ------------------------------------------------------------------
-function FromValue(schema, base, ref) {
-    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
-    if (Schema.IsSchemaObject(schema)) {
-        const result = Match(schema, nextBase, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Guard.IsArray(schema))
-        return FromArray(schema, nextBase, ref);
-    if (Guard.IsObject(schema))
-        return FromObject(schema, nextBase, ref);
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Base
-// ------------------------------------------------------------------
-export function Base(schema, base, target) {
-    return FindBase(schema, new URL(base || '.', DefaultBase), target);
+function Match(schema, base, ref) {
+    const relativeBase = RelativeBase(schema, base);
+    return MatchSchemaObject(schema, relativeBase, ref) ??
+        MatchFromArray(schema, relativeBase, ref) ??
+        MatchFromObject(schema, relativeBase, ref);
 }
 // ------------------------------------------------------------------
 // Resource
+//
+// Wraps RefInternal to check whether the resolved schema is itself
+// a resource root (carries its own $id). Used by FindResolvedResource
+// to tell a boundary hit from a landing inside a resource.
 // ------------------------------------------------------------------
-export function Resource(context, schema, base, ref) {
-    const result = Ref(context, schema, base, ref, false);
+function Resource(context, schema, base, ref) {
+    const result = RefInternal(context, schema, base, ref);
     return Schema.IsSchemaObject(result) && Schema.IsId(result) ? result : undefined;
 }
 // ------------------------------------------------------------------
-// CanonicalHref
-// ------------------------------------------------------------------
-function CanonicalHref(url) {
-    return url.href.split('#')[0];
-}
-// ------------------------------------------------------------------
-// Ref: RefRemote (Phase 1)
-// ------------------------------------------------------------------
-function RefContext(context, ref) {
-    return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
-}
-// ------------------------------------------------------------------
-// Ref: RefRemote (Phase 2)
-// ------------------------------------------------------------------
-function RefLocal(schema, base, ref) {
-    return FromValue(schema, base, ref);
-}
-// ------------------------------------------------------------------
-// Ref: RefRemote (Phase 3)
-// ------------------------------------------------------------------
-function RefRemote(context, base, ref) {
-    const canonicalHref = CanonicalHref(ref);
-    if (Guard.IsEqual(canonicalHref, CanonicalHref(base)))
-        return undefined;
-    if (!Guard.HasPropertyKey(context, canonicalHref))
-        return undefined;
-    const remoteSchema = context[canonicalHref];
-    const remoteBase = (Schema.IsSchemaObject(remoteSchema) && Schema.IsId(remoteSchema)) ? new URL(remoteSchema.$id, canonicalHref) : new URL(canonicalHref);
-    const result = Guard.IsEqual(ref.hash, '') ? remoteSchema : FromValue(remoteSchema, remoteBase, ref);
-    return result;
-}
-// ------------------------------------------------------------------
-// RetrievedResource: LegacyRetrievedResource
+// FindDeferredResource
 //
-// Draft-4 style schemas (no $schema keyword) treat a nested $id as an
-// in-place base URI change rather than a new resource boundary. A
-// local ('#...') ref that lands somewhere with a different base than
-// the current reference base needs a frame so later anchor/pointer
-// resolution is computed against the right base.
+// Legacy Draft-4 schemas (no $schema keyword) treat a nested $id as
+// an in-place base change, not a new resource. A local ('#...') ref
+// landing at a different base than the current one needs a stack
+// entry so later lookups use the right base.
 // ------------------------------------------------------------------
-function LegacyRetrievedResource(root, lexicalSchema, referenceBase, ref, schema) {
+function FindDeferredResourceLegacy(stack, ref, schema) {
     if (!ref.$ref.startsWith('#'))
         return undefined;
-    if (Guard.HasPropertyKey(root, '$schema'))
+    if (!Schema.IsSchemaObject(stack.schema) || Guard.HasPropertyKey(stack.schema, '$schema'))
         return undefined;
-    const targetBase = Base(lexicalSchema, referenceBase, schema);
-    if (Guard.IsUndefined(targetBase) || Guard.IsEqual(targetBase, referenceBase))
+    const targetBase = Base(stack.lexicalSchema, stack.referenceBase, schema);
+    if (Guard.IsUndefined(targetBase) || Guard.IsEqual(targetBase, stack.referenceBase))
         return undefined;
-    return { target: schema, base: targetBase, root: lexicalSchema };
+    return { target: schema, base: targetBase, root: /* safe-object-root */ stack.lexicalSchema };
 }
-// ------------------------------------------------------------------
-// RetrievedResource: RemoteRetrievedResource
-//
-// The ref's canonical URL names a document already loaded into
-// context. That document becomes the frame's root going forward.
-// ------------------------------------------------------------------
-function RemoteRetrievedResource(context, canonical, schema) {
-    const remoteRoot = context[canonical];
+function FindDeferredResourceModern(stack, canonical, schema) {
+    const remoteRoot = stack.context[canonical];
     if (!Schema.IsSchemaObject(remoteRoot))
         return undefined;
     return { target: schema, base: canonical, root: remoteRoot };
 }
-// ------------------------------------------------------------------
-// RetrievedResource
-//
-// A genuinely remote document frame always wins over a same-document
-// legacy one: only one frame is ever entered per ref.
-// ------------------------------------------------------------------
-function FindRetrievedResource(stackframe, ref, schema, canonical, isRemote) {
-    const remote = isRemote ? RemoteRetrievedResource(stackframe.context, canonical, schema) : undefined;
-    if (!Guard.IsUndefined(remote))
-        return remote;
-    return LegacyRetrievedResource(stackframe.root, stackframe.lexicalSchema, stackframe.referenceBase, ref, schema);
+function FindDeferredResource(stack, ref, schema, canonical, isRemote) {
+    const remote = isRemote ? FindDeferredResourceModern(stack, canonical, schema) : undefined;
+    return Guard.IsUndefined(remote) ? FindDeferredResourceLegacy(stack, ref, schema) : remote;
 }
 // ------------------------------------------------------------------
-// ResolvedResource: FindResolvedResource
+// FindResolvedResource
 //
-// The ref crossed into a different resource but landed on a schema
-// that doesn't itself carry that resource's $id (e.g. a pointer into
-// the middle of a remote document). The enclosing resource still
-// needs to be entered so lexical/base lookups behave as if traversal
-// had walked in from its top.
+// Handles a ref that crossed into a different resource but landed
+// on a schema without that resource's $id (e.g. a pointer into the
+// middle of a remote document). Enters the enclosing resource so
+// lexical/base lookups behave as if traversal walked in from its top.
 // ------------------------------------------------------------------
-function FindResolvedResource(context, root, referenceBase, canonical, schema, ids) {
+function FindResolvedResource(stack, canonical, schema) {
     if (Schema.IsId(schema))
         return undefined;
-    const resource = Resource(context, root, referenceBase, canonical);
-    if (!resource || ids.includes(resource))
+    const resource = Resource(stack.context, /* safe-object-root */ stack.schema, stack.referenceBase, canonical);
+    if (!resource || stack.ids.includes(resource))
         return undefined;
-    return { target: schema, resource };
+    return { resource };
 }
 // ------------------------------------------------------------------
-// Ref
+// RefInternal
+//
+// Shared lookup used by Ref, RecursiveRef, and DynamicRef. Tries,
+// in order: exact match in the pre-registered context, then a local
+// search within the given schema, then a search in a remote
+// document. Returns just the schema; caller-specific bookkeeping
+// (deferred/resolved resources) happens one level up.
 // ------------------------------------------------------------------
-export function Ref(remotes, schema, base, ref, applySchemaId = true) {
-    const initialBase = new URL(base || '.', DefaultBase);
-    const resolvedBase = applySchemaId && Schema.IsId(schema) ? new URL(schema.$id, initialBase) : initialBase;
-    const initialRef = new URL(ref, resolvedBase.href);
-    return RefContext(remotes, ref) ?? RefLocal(schema, resolvedBase, initialRef) ?? RefRemote(remotes, resolvedBase, initialRef);
+function RefInternalWithContext(context, ref) {
+    return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
 }
-// ------------------------------------------------------------------
-// DynamicRef
-// ------------------------------------------------------------------
-export function DynamicRef(context, root, base, schema, dynamicRef, dynamicAnchors) {
-    const initialBase = new URL(base || '.', DefaultBase);
-    const fragmentRoot = dynamicRef.$dynamicRef.startsWith('#') ? schema : root;
-    const fragmentTarget = Ref(context, fragmentRoot, base, dynamicRef.$dynamicRef, false);
-    if (Guard.IsUndefined(fragmentTarget)) {
-        const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
-        if (!fragment.startsWith('#/') && fragment.startsWith('#')) {
-            const name = decodeURIComponent(fragment.slice(1));
-            const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, name)) ?? FindDynamicAnchor(root, name);
-            return anchorTarget;
-        }
+function RefInternalWithLocal(schema, base, ref) {
+    return Match(schema, base, ref);
+}
+function RefInternalWithRemote(context, base, ref) {
+    const canonicalHref = CanonicalHref(ref);
+    if (!Guard.HasPropertyKey(context, canonicalHref) || Guard.IsEqual(canonicalHref, CanonicalHref(base)))
         return undefined;
-    }
-    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
-        return fragmentTarget;
-    const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
-    if (fragment.startsWith('#/'))
-        return fragmentTarget;
-    const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, fragmentTarget.$dynamicAnchor));
-    return anchorTarget ?? fragmentTarget;
+    const remoteSchema = context[canonicalHref];
+    const remoteBase = RelativeBase(remoteSchema, new URL(canonicalHref));
+    return Guard.IsEqual(ref.hash, '') ? remoteSchema : Match(remoteSchema, remoteBase, ref);
+}
+function RefInternal(context, schema, base, ref) {
+    const absoluteBase = AbsoluteBase(base);
+    const target = Stack.NextUri(ref, absoluteBase.href);
+    return RefInternalWithContext(context, ref) ??
+        RefInternalWithLocal(schema, absoluteBase, target) ??
+        RefInternalWithRemote(context, absoluteBase, target);
 }
 // ------------------------------------------------------------------
-// ResolveRef
+// RefNextStack
 //
-// Resolves the schema a $ref points to, and describes whether that
-// crossing implies a "retrieved resource" frame or entering a
-// resource the target doesn't itself carry the $id for. The caller
-// decides whether and how to record these.
+// Computes the next stack state from any deferred or resolved
+// resource found while following a $ref, carrying existing stack
+// state forward rather than rebuilding it.
+// ------------------------------------------------------------------
+function RefNextStackDeferred(stack, deferredResource) {
+    if (!deferredResource)
+        return stack;
+    const resourceEntries = new Map(stack.resourceEntries);
+    resourceEntries.set(deferredResource.target, { base: deferredResource.base, root: deferredResource.root });
+    return { ...stack, resourceEntries };
+}
+function RefNextStackResolved(stack, resolvedResource) {
+    return resolvedResource ? Stack.NextStack(stack, resolvedResource.resource) : stack;
+}
+function RefNextStack(stack, pendingResource, deferredResource, resolvedResource) {
+    const withDeferred = RefNextStackDeferred({ ...stack, pendingResource }, deferredResource);
+    const withResolved = RefNextStackResolved(withDeferred, resolvedResource);
+    return withResolved;
+}
 // ------------------------------------------------------------------
-export function ResolveRef(stackframe, ref) {
-    const source = stackframe.inRetrievedFrame ? stackframe.lexicalSchema : stackframe.root;
-    const refRoot = ref.$ref.startsWith('#') ? stackframe.lexicalSchema : source;
-    const schema = Ref(stackframe.context, refRoot, stackframe.referenceBase, ref.$ref, false);
-    if (!schema || !Schema.IsSchemaObject(schema))
-        return { schema };
-    const canonical = new URL(ref.$ref, stackframe.referenceBase).href.split('#')[0];
-    const isRemote = !Guard.IsEqual(canonical, stackframe.resourceBase);
-    const retrievedResource = FindRetrievedResource(stackframe, ref, schema, canonical, isRemote);
-    const resolvedResource = isRemote ? FindResolvedResource(stackframe.context, stackframe.root, stackframe.referenceBase, canonical, schema, stackframe.ids) : undefined;
-    return { schema, retrievedResource, resolvedResource };
+// RefResult
+//
+// Builds the final XRefResult. RefResultFound gets the canonical
+// URL, checks if it's remote from the current resource, and looks
+// for a deferred or resolved resource crossing accordingly.
+// RefResultNotFound just advances pendingResource if a schema was
+// found without crossing into a resource.
+// ------------------------------------------------------------------
+function RefResultFound(stack, ref, schema) {
+    const canonical = CanonicalHref(Stack.NextUri(ref.$ref, stack.referenceBase));
+    const isRemote = !Guard.IsEqual(canonical, stack.resourceBase);
+    const deferredResource = FindDeferredResource(stack, ref, schema, canonical, isRemote);
+    const resolvedResource = isRemote ? FindResolvedResource(stack, canonical, schema) : undefined;
+    return { schema, stack: RefNextStack(stack, true, deferredResource, resolvedResource) };
+}
+function RefResultNotFound(stack, schema) {
+    return { schema, stack: RefNextStack(stack, !Guard.IsUndefined(schema)) };
 }
 // ------------------------------------------------------------------
-// ResolveRecursiveRef
+// Ref
+//
+// Picks the root to resolve against, and returns a XRefResult
+// containing the resolved schema and the next stack state for
+// subsequent evaluation.
 // ------------------------------------------------------------------
-export function ResolveRecursiveRef(stackframe, recursiveRef) {
-    const refRoot = Schema.IsRecursiveAnchorTrue(stackframe.lexicalSchema) ? stackframe.recursiveAnchors[0] : stackframe.lexicalSchema;
-    return Ref(stackframe.context, refRoot, stackframe.lexicalBase, recursiveRef.$recursiveRef, false);
+export function Ref(stack, ref) {
+    const schema = RefInternal(stack.context, RefRoot(stack, ref), stack.referenceBase, ref.$ref);
+    return Schema.IsSchemaObject(schema) ? RefResultFound(stack, ref, schema) : RefResultNotFound(stack, schema);
 }
 // ------------------------------------------------------------------
-// ResolveDynamicRef
+// RecursiveRef: Draft 2019-09
+//
+// If a $recursiveAnchor is active in scope, it's used as the root
+// instead of the lexical schema, letting the ref bind to the
+// outermost applicable schema rather than the innermost.
+// ------------------------------------------------------------------
+function IsRecursiveAnchorInScope(stack) {
+    return Schema.IsSchemaObject(stack.lexicalSchema) && Schema.IsRecursiveAnchorTrue(stack.lexicalSchema);
+}
+export function RecursiveRef(stack, recursiveRef) {
+    const schema = IsRecursiveAnchorInScope(stack) ? stack.recursiveAnchor : stack.lexicalSchema;
+    return RefInternal(stack.context, schema, stack.lexicalBase, recursiveRef.$recursiveRef);
+}
 // ------------------------------------------------------------------
-export function ResolveDynamicRef(stackframe, dynamicRef) {
-    return DynamicRef(stackframe.context, stackframe.root, stackframe.lexicalBase, stackframe.lexicalSchema, dynamicRef, stackframe.dynamicAnchors);
+// DynamicRef: Draft 2020-12
+//
+// FindScopedDynamicAnchor checks anchors tracked on the stack first,
+// then falls back to a full tree search. If RefInternal finds a target
+// directly, DynamicRefWhenFound only continues the scoped search when
+// that target itself has a $dynamicAnchor. If RefInternal finds nothing,
+// DynamicRefWhenNotFound goes straight to a scoped anchor search
+// by name.
+// ------------------------------------------------------------------
+function DynamicRefFragment(stack, dynamicRef) {
+    return Stack.NextUri(dynamicRef.$dynamicRef, AbsoluteBase(stack.lexicalBase).href).hash;
+}
+function FindScopedDynamicAnchor(stack, name) {
+    return stack.dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, name)) ?? SearchDynamicAnchor(stack.schema, name);
+}
+function DynamicRefWhenFound(stack, dynamicRef, fragmentTarget) {
+    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
+        return fragmentTarget;
+    const fragment = DynamicRefFragment(stack, dynamicRef);
+    return IsPointerFragment(fragment) ? fragmentTarget : FindScopedDynamicAnchor(stack, fragmentTarget.$dynamicAnchor);
+}
+function DynamicRefWhenNotFound(stack, dynamicRef) {
+    const fragment = DynamicRefFragment(stack, dynamicRef);
+    // (review): We never observe this condition, but should be able to reach here in coverage.
+    // if (IsPointerFragment(fragment) || !fragment.startsWith('#')) return undefined
+    return FindScopedDynamicAnchor(stack, decodeURIComponent(fragment.slice(1)));
+}
+export function DynamicRef(stack, dynamicRef) {
+    const fragmentRoot = dynamicRef.$dynamicRef.startsWith('#') ? stack.lexicalSchema : stack.schema;
+    const fragmentTarget = RefInternal(stack.context, fragmentRoot, stack.lexicalBase, dynamicRef.$dynamicRef);
+    return Guard.IsUndefined(fragmentTarget) ? DynamicRefWhenNotFound(stack, dynamicRef) : DynamicRefWhenFound(stack, dynamicRef, fragmentTarget);
 }

package/build/schema/schema.d.mts

@@ -1,5 +1,6 @@
 export * from './engine/index.mjs';
 export * from './intern/index.mjs';
+export * from './meta/index.mjs';
 export * from './pointer/index.mjs';
 export * from './resolve/index.mjs';
 export * from './static/index.mjs';

package/build/schema/schema.mjs

@@ -1,5 +1,6 @@
 export * from './engine/index.mjs';
 export * from './intern/index.mjs';
+export * from './meta/index.mjs';
 export * from './pointer/index.mjs';
 export * from './resolve/index.mjs';
 export * from './static/index.mjs';

package/build/system/settings/internal.d.mts

@@ -0,0 +1,2 @@
+export declare function EnableParseErrors(): void;
+export declare function DisableParseErrors(): void;

package/build/system/settings/internal.mjs

@@ -0,0 +1,20 @@
+import { Get } from './settings.mjs';
+// ------------------------------------------------------------------
+// TempMaxErrors
+// ------------------------------------------------------------------
+let TempMaxErrors = 0;
+// ------------------------------------------------------------------
+// [Internal] EnableParseErrors
+// ------------------------------------------------------------------
+export function EnableParseErrors() {
+    const settings = Get();
+    TempMaxErrors = settings.maxErrors;
+    settings.maxErrors = settings.maxParseErrors;
+}
+// ------------------------------------------------------------------
+// [Internal] DisableParseErrors
+// ------------------------------------------------------------------
+export function DisableParseErrors() {
+    const settings = Get();
+    settings.maxErrors = TempMaxErrors;
+}

package/build/system/settings/settings.d.mts

@@ -16,6 +16,17 @@ export interface TSettings {
      * @default 8
      */
     maxErrors: number;
+    /**
+     * Specifies the maximum number of errors to gather for failed Parse operations. TypeBox will
+     * automatically run an error-gathering pass on failed Parses to attach diagnostics to the
+     * thrown exception. This setting controls the number of errors gathered in that pass. Higher
+     * values will reduce throughput on failure cases, so a maximum of 4 is recommended if more
+     * errors are needed. The default setting of 1 will terminate on the first error, while a
+     * setting of 0 will skip error gathering entirely.
+     *
+     * @default 1
+     */
+    maxParseErrors: number;
     /**
      * Specifies the maximum number of instantiations allowed within a top-level generic instantiation
      * context. This setting can be used to bound generic calls to a fixed count, which can be useful if