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

package/build/schema/resolve/resolve.mjs

@@ -2,25 +2,69 @@
 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';
 // ------------------------------------------------------------------
-// DefaultBase
+// Find: FindDynamicAnchor
 // ------------------------------------------------------------------
-export const DefaultBase = new URL('https://json-schema.org');
+function FindDynamicAnchor(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);
+            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;
+}
 // ------------------------------------------------------------------
-// Match: Id
+// Find: FindBase
+// ------------------------------------------------------------------
+function FindBase(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;
+    if (Guard.IsArray(schema)) {
+        for (const item of schema) {
+            const result = FindBase(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);
+            if (!Guard.IsUndefined(result))
+                return result;
+        }
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Match: MatchId
 // ------------------------------------------------------------------
 function MatchId(schema, base, ref) {
-    if (schema.$id === ref.hash)
+    // ref is a bare fragment naming this schema's $id directly
+    if (Guard.IsEqual(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;
-    }
+    // 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 undefined;
 }
 // ------------------------------------------------------------------
-// Match: Anchor
+// Match: MatchAnchor
 // ------------------------------------------------------------------
 function MatchAnchor(schema, base, ref) {
     const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
@@ -28,23 +72,18 @@ function MatchAnchor(schema, base, ref) {
     return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
 }
 // ------------------------------------------------------------------
-// Match: DynamicAnchor
+// Match: MatchDynamicAnchor
 // ------------------------------------------------------------------
 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;
+    const isMatch = Guard.IsEqual(absoluteAnchor.href, absoluteRef.href);
+    return isMatch ? 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.
-//
+// Match: MatchHash
 // ------------------------------------------------------------------
-function MatchHash(schema, _base, ref) {
+function MatchHash(schema, ref) {
     if (ref.href.endsWith('#'))
         return schema;
     if (!ref.hash.startsWith('#'))
@@ -52,10 +91,11 @@ function MatchHash(schema, _base, ref) {
     const fragment = decodeURIComponent(ref.hash.slice(1));
     if (!fragment.startsWith('/'))
         return undefined;
-    return Pointer.Get(schema, fragment);
+    const result = Pointer.Get(schema, fragment);
+    return result;
 }
 // ------------------------------------------------------------------
-// Match
+// Match: Match
 // ------------------------------------------------------------------
 function Match(schema, base, ref) {
     if (Schema.IsId(schema)) {
@@ -73,7 +113,7 @@ function Match(schema, base, ref) {
         if (!Guard.IsUndefined(result))
             return result;
     }
-    return MatchHash(schema, base, ref);
+    return MatchHash(schema, ref);
 }
 // ------------------------------------------------------------------
 // FromArray
@@ -88,8 +128,6 @@ function FromArray(schema, base, ref) {
 // 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) {
@@ -104,9 +142,7 @@ function FromObject(schema, base, ref) {
 // FromValue
 // ------------------------------------------------------------------
 function FromValue(schema, base, ref) {
-    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema)
-        ? new URL(schema.$id, base.href)
-        : base;
+    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))
@@ -119,84 +155,173 @@ function FromValue(schema, base, ref) {
     return undefined;
 }
 // ------------------------------------------------------------------
+// Base
+// ------------------------------------------------------------------
+export function Base(schema, base, target) {
+    return FindBase(schema, new URL(base || '.', DefaultBase), target);
+}
+// ------------------------------------------------------------------
+// Resource
+// ------------------------------------------------------------------
+export function Resource(context, schema, base, ref) {
+    const result = Ref(context, schema, base, ref, false);
+    return Schema.IsSchemaObject(result) && Schema.IsId(result) ? result : 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.
+// Ref: RefRemote (Phase 1)
 // ------------------------------------------------------------------
 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.
+// Ref: RefRemote (Phase 2)
 // ------------------------------------------------------------------
 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.
+// Ref: RefRemote (Phase 3)
 // ------------------------------------------------------------------
 function RefRemote(context, base, ref) {
-    const targetDocumentHref = CanonicalHref(ref);
-    if (Guard.IsEqual(targetDocumentHref, CanonicalHref(base)))
+    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
+//
+// 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.
+// ------------------------------------------------------------------
+function LegacyRetrievedResource(root, lexicalSchema, referenceBase, ref, schema) {
+    if (!ref.$ref.startsWith('#'))
+        return undefined;
+    if (Guard.HasPropertyKey(root, '$schema'))
+        return undefined;
+    const targetBase = Base(lexicalSchema, referenceBase, schema);
+    if (Guard.IsUndefined(targetBase) || Guard.IsEqual(targetBase, referenceBase))
         return undefined;
-    if (!Guard.HasPropertyKey(context, targetDocumentHref))
+    return { target: schema, base: targetBase, root: 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];
+    if (!Schema.IsSchemaObject(remoteRoot))
         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);
+    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);
+}
+// ------------------------------------------------------------------
+// ResolvedResource: 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.
+// ------------------------------------------------------------------
+function FindResolvedResource(context, root, referenceBase, canonical, schema, ids) {
+    if (Schema.IsId(schema))
+        return undefined;
+    const resource = Resource(context, root, referenceBase, canonical);
+    if (!resource || ids.includes(resource))
+        return undefined;
+    return { target: schema, resource };
 }
 // ------------------------------------------------------------------
 // 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);
+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);
 }
 // ------------------------------------------------------------------
 // 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))
+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;
+        }
         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;
+    const fragment = new URL(dynamicRef.$dynamicRef, initialBase).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);
+    const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, fragmentTarget.$dynamicAnchor));
     return anchorTarget ?? fragmentTarget;
 }
+// ------------------------------------------------------------------
+// ResolveRef
+//
+// 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.
+// ------------------------------------------------------------------
+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 };
+}
+// ------------------------------------------------------------------
+// ResolveRecursiveRef
+// ------------------------------------------------------------------
+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);
+}
+// ------------------------------------------------------------------
+// ResolveDynamicRef
+// ------------------------------------------------------------------
+export function ResolveDynamicRef(stackframe, dynamicRef) {
+    return DynamicRef(stackframe.context, stackframe.root, stackframe.lexicalBase, stackframe.lexicalSchema, dynamicRef, stackframe.dynamicAnchors);
+}

package/build/schema/schema.d.mts

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

package/build/schema/schema.mjs

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

package/build/value/errors/errors.d.mts

@@ -1,16 +1,6 @@
 import type { TProperties, TSchema } from '../../type/index.mjs';
 import type { TLocalizedValidationError } from '../../error/index.mjs';
-/**
- * Performs an exhaustive Check on the specified value and reports any errors found.
- * If no errors are found, an empty array is returned. Unlike Check, this function
- * does not terminate at the first occurrence of an error. For best performance, call
- * Check first and call Errors only if Check returns false.
- */
+/** Returns an array of validation errors for the given value. */
 export declare function Errors<Type extends TSchema>(type: Type, value: unknown): TLocalizedValidationError[];
-/**
- * Performs an exhaustive Check on the specified value and reports any errors found.
- * If no errors are found, an empty array is returned. Unlike Check, this function
- * does not terminate at the first occurrence of an error. For best performance, call
- * Check first and call Errors only if Check returns false.
- */
+/** Returns an array of validation errors for the given value. */
 export declare function Errors<Context extends TProperties, Type extends TSchema>(context: Context, type: Type, value: unknown): TLocalizedValidationError[];

package/build/value/errors/errors.mjs

@@ -1,12 +1,7 @@
 // deno-fmt-ignore-file
 import { Arguments } from '../../system/arguments/index.mjs';
-import { Errors as SchemaErrors, } from '../../schema/index.mjs';
-/**
- * Performs an exhaustive Check on the specified value and reports any errors found.
- * If no errors are found, an empty array is returned. Unlike Check, this function
- * does not terminate at the first occurrence of an error. For best performance, call
- * Check first and call Errors only if Check returns false.
- */
+import { Errors as SchemaErrors } from '../../schema/index.mjs';
+/** Returns an array of validation errors for the given value. */
 export function Errors(...args) {
     const [context, type, value] = Arguments.Match(args, {
         3: (context, type, value) => [context, type, value],

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-08-30T00:59:40.420Z",
+  "timestamp": "2026-09-06T01:04:01.845Z",
   "totalUpdated": 0
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@depup/typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript (with updated dependencies)",
-  "version": "1.3.22-depup.0",
+  "version": "1.3.27-depup.0",
   "keywords": [
     "typebox",
     "depup",
@@ -94,8 +94,8 @@
     "changes": {},
     "depsUpdated": 0,
     "originalPackage": "typebox",
-    "originalVersion": "1.3.22",
-    "processedAt": "2026-08-30T00:59:41.143Z",
+    "originalVersion": "1.3.27",
+    "processedAt": "2026-09-06T01:04:02.687Z",
     "smokeTest": "passed"
   }
 }

package/readme.md

@@ -245,13 +245,16 @@ TypeBox supports all major JSON Schema draft versions and tracks compliance agai
 | contains | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | content | - | - | - | - | ✅ | ✅ | ✅ |
 | default | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| definitions | - | 1/2 | ✅ | ✅ | - | - | - |
+| defs | - | - | - | - | ✅ | ✅ | - |
 | dependencies | 17/18 | ✅ | ✅ | ✅ | - | - | - |
 | dependentRequired | - | - | - | - | ✅ | ✅ | ✅ |
 | dependentSchemas | - | - | - | - | ✅ | ✅ | ✅ |
-| dynamicRef | - | - | - | - | - | 40/44 | 21/27 |
-| enum | 14/16 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| dynamicRef | - | - | - | - | - | ✅ | ✅ |
+| enum | 16/18 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMaximum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMinimum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
+| format | ✅ | ✅ | ✅ | ✅ | ✅ | 114/133 | - |
 | if-then-else | - | - | - | ✅ | ✅ | ✅ | ✅ |
 | infinite-loop-detection | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | items | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -274,11 +277,12 @@ 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 | 78/79 |
+| ref | 23/27 | 38/45 | 69/70 | 77/78 | ✅ | ✅ | ✅ |
+| refRemote | 7/8 | 11/17 | ✅ | ✅ | ✅ | ✅ | ✅ |
 | required | 3/4 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | type | 73/80 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
-| unevaluatedItems | - | - | - | - | ✅ | ✅ | 70/71 |
-| unevaluatedProperties | - | - | - | - | ✅ | ✅ | 128/129 |
+| unevaluatedItems | - | - | - | - | ✅ | ✅ | ✅ |
+| unevaluatedProperties | - | - | - | - | ✅ | ✅ | ✅ |
 | uniqueItems | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 
 ### Performance