typebox 1.3.14 → 1.3.16

package/build/schema/engine/_stack.mjs

@@ -4,7 +4,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors, _Stack_FromContext, _Stack_FromRef;
+var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors;
 import * as Schema from '../types/index.mjs';
 import { Guard as G } from '../../guard/index.mjs';
 import { Resolve } from '../resolve/index.mjs';
@@ -58,23 +58,29 @@ export class Stack {
         if (Schema.IsDynamicAnchor(schema))
             this.dynamicAnchors.pop();
     }
+    // ----------------------------------------------------------------
+    // Ref
+    // ----------------------------------------------------------------
     Ref(ref) {
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromContext).call(this, ref) ?? __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromRef).call(this, ref);
+        const root = this.schema;
+        return !ref.$ref.startsWith('#')
+            ? Resolve.Ref(this.context, root, ref.$ref)
+            : Resolve.Ref(this.context, this.Base(), ref.$ref);
     }
     // ----------------------------------------------------------------
     // RecursiveRef
     // ----------------------------------------------------------------
     RecursiveRef(recursiveRef) {
         return Schema.IsRecursiveAnchorTrue(this.Base())
-            ? Resolve.Ref(this.recursiveAnchors[0], recursiveRef.$recursiveRef)
-            : Resolve.Ref(this.Base(), recursiveRef.$recursiveRef);
+            ? Resolve.Ref(this.context, this.recursiveAnchors[0], recursiveRef.$recursiveRef)
+            : Resolve.Ref(this.context, this.Base(), recursiveRef.$recursiveRef);
     }
     // ----------------------------------------------------------------
     // DynamicRef
     // ----------------------------------------------------------------
     DynamicRef(dynamicRef) {
         const root = this.schema;
-        return Resolve.DynamicRef(root, this.Base(), dynamicRef, this.dynamicAnchors);
+        return Resolve.DynamicRef(this.context, root, this.Base(), dynamicRef, this.dynamicAnchors);
     }
 }
 _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
@@ -97,11 +103,4 @@ _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_P
         this.dynamicAnchors.pop();
     for (const key of G.Keys(current))
         __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
-}, _Stack_FromContext = function _Stack_FromContext(ref) {
-    return G.HasPropertyKey(this.context, ref.$ref) ? this.context[ref.$ref] : undefined;
-}, _Stack_FromRef = function _Stack_FromRef(ref) {
-    const root = this.schema;
-    return !ref.$ref.startsWith('#')
-        ? Resolve.Ref(root, ref.$ref)
-        : Resolve.Ref(this.Base(), ref.$ref);
 };

package/build/schema/resolve/resolve.d.mts

@@ -1 +1,4 @@
-export * from './ref.mjs';
+import * as Schema from '../types/index.mjs';
+export declare const DefaultBase: URL;
+export declare function Ref(context: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
+export declare function DynamicRef(context: Record<string, Schema.XSchema>, root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;

package/build/schema/resolve/resolve.mjs

@@ -1 +1,202 @@
-export * from './ref.mjs';
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+import * as Schema from '../types/index.mjs';
+// ------------------------------------------------------------------
+// DefaultBase
+// ------------------------------------------------------------------
+export const DefaultBase = new URL('https://json-schema.org');
+// ------------------------------------------------------------------
+// Match: Id
+// ------------------------------------------------------------------
+function MatchId(schema, base, ref) {
+    if (schema.$id === ref.hash)
+        return schema;
+    const absoluteId = new URL(schema.$id, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
+        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Match: Anchor
+// ------------------------------------------------------------------
+function MatchAnchor(schema, base, ref) {
+    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: DynamicAnchor
+// ------------------------------------------------------------------
+function MatchDynamicAnchor(schema, base, ref) {
+    const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
+}
+// ------------------------------------------------------------------
+// Match: Hash
+//
+// Resolves JSON Pointer fragments only. Plain anchor-style fragments
+// (no leading '/') are handled exclusively by MatchAnchor and
+// MatchDynamicAnchor to prevent accidentally resolving an anchor name
+// as a pointer into the schema tree.
+//
+// ------------------------------------------------------------------
+function MatchHash(schema, _base, 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);
+}
+// ------------------------------------------------------------------
+// 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, base, ref);
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+function FromArray(schema, base, ref) {
+    return schema.reduce((result, item) => {
+        const match = FromValue(item, base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+function SkipProperty(key) {
+    // these are explicit data encoded in a schema, they should not
+    // be considered valid targets used for de-referencing.
+    return Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum');
+}
+function FromObject(schema, base, ref) {
+    return Guard.Keys(schema).reduce((result, key) => {
+        if (SkipProperty(key))
+            return result;
+        const match = FromValue(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;
+}
+// ------------------------------------------------------------------
+// CanonicalHref
+//
+// Returns the URL's href with its fragment removed, as a string.
+// This is the canonical URI a document is identified and keyed by
+// in context.
+// ------------------------------------------------------------------
+function CanonicalHref(url) {
+    return url.href.split('#')[0];
+}
+// ------------------------------------------------------------------
+// RefContext: Phase 1
+//
+// A ContextRef targets a simple key name in the context and is
+// used for fast resolution of inline referential TypeBox types.
+// ------------------------------------------------------------------
+function RefContext(context, ref) {
+    return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
+}
+// ------------------------------------------------------------------
+// RefLocal: Phase 2
+//
+// Resolves the ref's fragment within the current schema resource,
+// either as a JSON Pointer or a plain-name fragment ($anchor,
+// $dynamicAnchor), per the JSON Schema spec.
+// ------------------------------------------------------------------
+function RefLocal(schema, base, ref) {
+    return FromValue(schema, base, ref);
+}
+// ------------------------------------------------------------------
+// RefRemote: Phase 3
+//
+// Locates the schema resource identified by the ref's base URI, then
+// resolves the ref's fragment within that resource, either as a JSON
+// Pointer or a plain-name fragment, per the JSON Schema spec.
+// ------------------------------------------------------------------
+function RefRemote(context, base, ref) {
+    const targetDocumentHref = CanonicalHref(ref);
+    if (Guard.IsEqual(targetDocumentHref, CanonicalHref(base)))
+        return undefined;
+    if (!Guard.HasPropertyKey(context, targetDocumentHref))
+        return undefined;
+    const remoteSchema = context[targetDocumentHref];
+    const remoteBase = (Schema.IsSchemaObject(remoteSchema) && Schema.IsId(remoteSchema)) ? new URL(remoteSchema.$id, DefaultBase.href) : new URL(targetDocumentHref);
+    return FromValue(remoteSchema, remoteBase, ref);
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+export function Ref(context, schema, ref) {
+    const initialBase = Schema.IsId(schema) ? new URL(schema.$id, DefaultBase.href) : DefaultBase;
+    const initialRef = new URL(ref, initialBase.href);
+    return RefContext(context, ref) ?? RefLocal(schema, initialBase, initialRef) ?? RefRemote(context, initialBase, initialRef);
+}
+// ------------------------------------------------------------------
+// DynamicRef
+// ------------------------------------------------------------------
+export function DynamicRef(context, root, base, dynamicRef, dynamicAnchors) {
+    // Resolve the static target using either the local base (for fragment‑only references)
+    // or the document root (for absolute URI references).
+    const fragmentTarget = dynamicRef.$dynamicRef.startsWith('#')
+        ? Ref(context, base, dynamicRef.$dynamicRef)
+        : Ref(context, root, dynamicRef.$dynamicRef);
+    if (Guard.IsUndefined(fragmentTarget))
+        return undefined;
+    // Dynamic override only applies if the resolved target itself declares a $dynamicAnchor.
+    // If it does not, return the static target unchanged.
+    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
+        return fragmentTarget;
+    // Extract the fragment portion of the reference. According to the test suite,
+    // only plain fragment names (e.g., "#foo") trigger the dynamic scope; JSON 
+    // Pointer fragments (e.g., "#/definitions/foo") bypass dynamic resolution.
+    const fragment = new URL(dynamicRef.$dynamicRef, DefaultBase).hash;
+    if (fragment.startsWith('#/'))
+        return fragmentTarget;
+    // Search the live dynamic anchor stack for a schema whose $dynamicAnchor matches the
+    // target's $dynamicAnchor. The stack reflects the current evaluation path, and
+    // find() returns the outermost (first encountered) match, which is the correct
+    // lexical scope per the specification.
+    const anchorTarget = dynamicAnchors.find(anchor => anchor.$dynamicAnchor === fragmentTarget.$dynamicAnchor);
+    return anchorTarget ?? fragmentTarget;
+}

package/build/schema/static/propertyNames.d.mts

@@ -0,0 +1,5 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticPropertyNames<Stack extends string[], Root extends XSchema, Schema extends XSchema, StaticKey extends unknown = XStaticSchema<Stack, Root, Schema>, Result extends Record<string, unknown> = [StaticKey] extends [PropertyKey] ? {
+    [Key in StaticKey]?: unknown;
+} : {}> = Result;

package/build/schema/static/propertyNames.mjs

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+export {};

package/build/schema/static/schema.d.mts

@@ -9,6 +9,7 @@ import type { XOneOf } from '../types/oneOf.mjs';
 import type { XPatternProperties } from '../types/patternProperties.mjs';
 import type { XPrefixItems } from '../types/prefixItems.mjs';
 import type { XProperties } from '../types/properties.mjs';
+import type { XPropertyNames } from '../types/propertyNames.mjs';
 import type { XRef } from '../types/ref.mjs';
 import type { XRequired } from '../types/required.mjs';
 import type { XSchema } from '../types/schema.mjs';
@@ -25,6 +26,7 @@ import type { XStaticOneOf } from './oneOf.mjs';
 import type { XStaticPatternProperties } from './patternProperties.mjs';
 import type { XStaticPrefixItems } from './prefixItems.mjs';
 import type { XStaticProperties } from './properties.mjs';
+import type { XStaticPropertyNames } from './propertyNames.mjs';
 import type { XStaticRef } from './ref.mjs';
 import type { XStaticRequired } from './required.mjs';
 import type { XStaticType } from './type.mjs';
@@ -41,6 +43,7 @@ type XFromKeywords<Stack extends string[], Root extends XSchema, Schema extends
     Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,
     Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Stack, Root, Schema, Types> : unknown,
     Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Schema, Properties> : unknown,
+    Schema extends XPropertyNames<infer Type extends XSchema> ? XStaticPropertyNames<Stack, Root, Type> : unknown,
     Schema extends XRef<infer Ref extends string> ? XStaticRef<Stack, Root, Ref> : unknown,
     Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Stack, Root, Schema, Keys> : unknown,
     Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.3.14",
+  "version": "1.3.16",
   "keywords": [
     "typescript",
     "jsonschema"

package/readme.md

@@ -231,7 +231,7 @@ const result = Vector.Parse({ x: 1, y: 0, z: 0 })  // const result: {
 
 [JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) | [JSON Schema Compliance Suite](https://github.com/sinclairzx81/json-schema-compliance-suite)
 
-TypeBox supports all major JSON Schema draft versions and tracks compliance against the official JSON Schema Test Suite. It also maintains a separate JavaScript compliance suite to track ecosystem adoption as JSON Schema moves toward the Version 1 candidate. The following table shows TypeBox specification coverage.
+TypeBox supports all major JSON Schema draft versions and tracks compliance against the official JSON Schema Test Suite. It also maintains a separate JavaScript compliance suite to track ecosystem adoption as JSON Schema moves toward the V1 candidate. The following table shows TypeBox specification coverage.
 
 | Spec | 3 | 4 | 6 | 7 | 2019-09 | 2020-12 | v1 |
 |:-----|:--|:--|:--|:--|:--|:--|:--|
@@ -248,7 +248,7 @@ TypeBox supports all major JSON Schema draft versions and tracks compliance agai
 | dependencies | 17/18 | ✅ | ✅ | ✅ | - | - | - |
 | dependentRequired | - | - | - | - | ✅ | ✅ | ✅ |
 | dependentSchemas | - | - | - | - | ✅ | ✅ | ✅ |
-| dynamicRef | - | - | - | - | - | 38/44 | 19/27 |
+| dynamicRef | - | - | - | - | - | 40/44 | 21/27 |
 | enum | 14/16 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMaximum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMinimum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -274,7 +274,7 @@ TypeBox supports all major JSON Schema draft versions and tracks compliance agai
 | properties | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | propertyNames | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | recursiveRef | - | - | - | - | ✅ | - | - |
-| ref | 22/27 | 37/45 | 67/70 | 75/78 | 79/81 | 77/79 | 77/79 |
+| ref | 22/27 | 37/45 | 67/70 | 75/78 | 79/81 | 77/79 | 78/79 |
 | required | 3/4 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | type | 73/80 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | unevaluatedItems | - | - | - | - | ✅ | ✅ | 70/71 |
@@ -283,40 +283,40 @@ TypeBox supports all major JSON Schema draft versions and tracks compliance agai
 
 ### Performance
 
-TypeBox tracks comparative performance against AJV8 as the de facto JSON Schema performance standard. For broader comparative benchmarks, refer to the community maintained projects below.
+TypeBox tracks comparative performance against AJV8 as the de facto performance standard. For broader comparative benchmarks, refer to the community maintained projects below.
 
 [Runtime Benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/) | [Schema Benchmarks](https://schemabenchmarks.dev/)
 
 The following table shows compilation performance for various JSON Schema structures. These benchmarks measure the time required to JIT compile schematics, with faster compilation resulting in faster application startup.
 
 ```python
-┌──────────────────────┬─────────────┬─────────────┐
-│ Compile              │ TB1X        │ AJV8        │
-├──────────────────────┼─────────────┼─────────────┤
-│ Boolean              │ 39.7K ops/s │  6.8K ops/s │
-│ Number               │ 86.2K ops/s │  7.5K ops/s │
-│ String               │ 82.6K ops/s │  8.2K ops/s │
-│ Null                 │   62K ops/s │  7.3K ops/s │
-│ Literal_String       │ 72.1K ops/s │  5.7K ops/s │
-│ Literal_Number       │ 72.7K ops/s │  6.9K ops/s │
-│ Literal_Boolean      │ 80.9K ops/s │    7K ops/s │
-│ Pattern              │ 38.7K ops/s │  5.7K ops/s │
-│ Object_Open          │ 16.3K ops/s │  1.3K ops/s │
-│ Object_Close         │ 15.7K ops/s │   952 ops/s │
-│ Object_Vector3       │ 40.2K ops/s │  3.2K ops/s │
-│ Object_Basis3        │ 16.1K ops/s │   834 ops/s │
-│ Intersect_And        │ 45.7K ops/s │  3.5K ops/s │
-│ Intersect_Structural │   21K ops/s │  1.6K ops/s │
-│ Union_Or             │ 45.1K ops/s │  3.4K ops/s │
-│ Union_Structural     │ 27.6K ops/s │    2K ops/s │
-│ Tuple_Values         │ 14.7K ops/s │    2K ops/s │
-│ Tuple_Objects        │  3.7K ops/s │   380 ops/s │
-│ Array_Numbers_4      │ 73.6K ops/s │  4.3K ops/s │
-│ Array_Numbers_8      │ 50.9K ops/s │  3.8K ops/s │
-│ Array_Numbers_16     │   85K ops/s │  3.9K ops/s │
-│ Array_Objects_Open   │ 18.9K ops/s │   789 ops/s │
-│ Array_Objects_Close  │ 17.9K ops/s │   909 ops/s │
-└──────────────────────┴─────────────┴─────────────┘
+┌──────────────────────┬──────────────┬──────────────┐
+│ Compile              │ TB1X         │ AJV8         │
+├──────────────────────┼──────────────┼──────────────┤
+│ Boolean              │  50.4K ops/s │   7.1K ops/s │
+│ Number               │ 129.9K ops/s │   7.9K ops/s │
+│ String               │ 128.9K ops/s │   9.1K ops/s │
+│ Null                 │  91.3K ops/s │   8.4K ops/s │
+│ Literal_String       │  63.1K ops/s │   7.4K ops/s │
+│ Literal_Number       │  74.5K ops/s │   7.6K ops/s │
+│ Literal_Boolean      │ 143.3K ops/s │   7.7K ops/s │
+│ Pattern              │  94.2K ops/s │   6.4K ops/s │
+│ Object_Open          │  19.4K ops/s │   1.3K ops/s │
+│ Object_Close         │  17.6K ops/s │    991 ops/s │
+│ Object_Vector3       │  46.1K ops/s │   3.3K ops/s │
+│ Object_Basis3        │    16K ops/s │    848 ops/s │
+│ Intersect_And        │  41.3K ops/s │   4.2K ops/s │
+│ Intersect_Structural │  25.3K ops/s │   1.5K ops/s │
+│ Union_Or             │  58.6K ops/s │   2.4K ops/s │
+│ Union_Structural     │  31.5K ops/s │   1.8K ops/s │
+│ Tuple_Values         │  18.2K ops/s │   1.9K ops/s │
+│ Tuple_Objects        │   3.9K ops/s │    437 ops/s │
+│ Array_Numbers_4      │ 114.5K ops/s │   4.2K ops/s │
+│ Array_Numbers_8      │ 128.3K ops/s │   3.9K ops/s │
+│ Array_Numbers_16     │ 128.4K ops/s │     4K ops/s │
+│ Array_Objects_Open   │    22K ops/s │    780 ops/s │
+│ Array_Objects_Close  │    22K ops/s │     1K ops/s │
+└──────────────────────┴──────────────┴──────────────┘
 ```
 
 The following tables shows validation performance for various JSON Schema structures. These benchmarks measure overall validation throughput for JIT compiled schematics.

package/build/schema/resolve/ref.d.mts

@@ -1,4 +0,0 @@
-import * as Schema from '../types/index.mjs';
-export declare const DefaultBase: URL;
-export declare function Ref(schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
-export declare function DynamicRef(root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;

package/build/schema/resolve/ref.mjs

@@ -1,156 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import * as Schema from '../types/index.mjs';
-// ------------------------------------------------------------------
-// DefaultBase
-// ------------------------------------------------------------------
-export const DefaultBase = new URL('https://json-schema.org');
-// ------------------------------------------------------------------
-// Match: Id
-// ------------------------------------------------------------------
-function MatchId(schema, base, ref) {
-    if (schema.$id === ref.hash)
-        return schema;
-    const absoluteId = new URL(schema.$id, base.href);
-    const absoluteRef = new URL(ref.href, base.href);
-    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
-        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
-    }
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Match: Anchor
-// ------------------------------------------------------------------
-function MatchAnchor(schema, base, ref) {
-    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: DynamicAnchor
-// ------------------------------------------------------------------
-function MatchDynamicAnchor(schema, base, ref) {
-    const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
-    const absoluteRef = new URL(ref.href, base.href);
-    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
-}
-// ------------------------------------------------------------------
-// Match: Hash
-//
-// Resolves JSON Pointer fragments only. Plain anchor-style fragments
-// (no leading '/') are handled exclusively by MatchAnchor and
-// MatchDynamicAnchor to prevent accidentally resolving an anchor name
-// as a pointer into the schema tree.
-//
-// ------------------------------------------------------------------
-function MatchHash(schema, _base, 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);
-}
-// ------------------------------------------------------------------
-// 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, base, ref);
-}
-// ------------------------------------------------------------------
-// FromArray
-// ------------------------------------------------------------------
-function FromArray(schema, base, ref) {
-    return schema.reduce((result, item) => {
-        const match = FromValue(item, base, ref);
-        return !Guard.IsUndefined(match) ? match : result;
-    }, undefined);
-}
-// ------------------------------------------------------------------
-// FromObject
-// ------------------------------------------------------------------
-function SkipProperty(key) {
-    // these are explicit data encoded in a schema, they should not
-    // be considered valid targets used for de-referencing.
-    return Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum');
-}
-function FromObject(schema, base, ref) {
-    return Guard.Keys(schema).reduce((result, key) => {
-        if (SkipProperty(key))
-            return result;
-        const match = FromValue(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;
-}
-// ------------------------------------------------------------------
-// Ref
-// ------------------------------------------------------------------
-export function Ref(schema, ref) {
-    const initialBase = Schema.IsId(schema) ? new URL(schema.$id, DefaultBase.href) : DefaultBase;
-    const initialRef = new URL(ref, initialBase.href);
-    return FromValue(schema, initialBase, initialRef);
-}
-// ------------------------------------------------------------------
-// DynamicRef
-// ------------------------------------------------------------------
-export function DynamicRef(root, base, dynamicRef, dynamicAnchors) {
-    // Resolve the static target using either the local base (for fragment‑only references)
-    // or the document root (for absolute URI references).
-    const fragmentTarget = dynamicRef.$dynamicRef.startsWith('#')
-        ? Ref(base, dynamicRef.$dynamicRef)
-        : Ref(root, dynamicRef.$dynamicRef);
-    if (Guard.IsUndefined(fragmentTarget))
-        return undefined;
-    // Dynamic override only applies if the resolved target itself declares a $dynamicAnchor.
-    // If it does not, return the static target unchanged.
-    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
-        return fragmentTarget;
-    // Extract the fragment portion of the reference. According to the test suite,
-    // only plain fragment names (e.g., "#foo") trigger the dynamic scope; JSON 
-    // Pointer fragments (e.g., "#/definitions/foo") bypass dynamic resolution.
-    const fragment = new URL(dynamicRef.$dynamicRef, DefaultBase).hash;
-    if (fragment.startsWith('#/'))
-        return fragmentTarget;
-    // Search the live dynamic anchor stack for a schema whose $dynamicAnchor matches the
-    // target's $dynamicAnchor. The stack reflects the current evaluation path, and
-    // find() returns the outermost (first encountered) match, which is the correct
-    // lexical scope per the specification.
-    const anchorTarget = dynamicAnchors.find(anchor => anchor.$dynamicAnchor === fragmentTarget.$dynamicAnchor);
-    return anchorTarget ?? fragmentTarget;
-}