@openclaw/feishu 2026.9.3 → 2026.9.5

package/node_modules/typebox/build/schema/resolve/resolve.mjs

@@ -1,50 +1,84 @@
-// deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Pointer } from '../pointer/index.mjs';
 import * as Schema from '../types/index.mjs';
+import * as Stack from '../engine/_stack.mjs';
 // ------------------------------------------------------------------
-// DefaultBase
+// 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.
 // ------------------------------------------------------------------
-export const DefaultBase = new URL('https://json-schema.org');
+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('#/');
+}
 // ------------------------------------------------------------------
-// Match: Id
+// 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 MatchId(schema, base, ref) {
-    if (schema.$id === ref.hash)
+function SearchDynamicAnchor(schema, name) {
+    if (Guard.IsObject(schema) && Schema.IsDynamicAnchor(schema) && Guard.IsEqual(schema.$dynamicAnchor, name)) {
         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;
+    }
+    if (Guard.IsObject(schema)) {
+        for (const key of Guard.Keys(schema)) {
+            const result = SearchDynamicAnchor(schema[key], name);
+            if (result)
+                return result;
+        }
     }
     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;
+function SearchBase(schema, base, target) {
+    if (Guard.IsEqual(schema, target))
+        return base.href;
+    const nextBase = RelativeBase(schema, base);
+    if (Guard.IsArray(schema)) {
+        for (const item of schema) {
+            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 = SearchBase(schema[key], nextBase, target);
+            if (!Guard.IsUndefined(result))
+                return result;
+        }
+    }
+    return 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
 //
+// 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 MatchHash(schema, _base, ref) {
+function MatchWithHash(schema, ref) {
     if (ref.href.endsWith('#'))
         return schema;
     if (!ref.hash.startsWith('#'))
@@ -54,149 +88,244 @@ function MatchHash(schema, _base, ref) {
         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);
+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);
+    if (Guard.IsEqual(base.pathname, absoluteRef.pathname))
+        return ref.hash.startsWith('#') ? MatchWithHash(schema, ref) : schema;
+    return undefined;
 }
-// ------------------------------------------------------------------
-// FromArray
-// ------------------------------------------------------------------
-function FromArray(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;
+}
+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;
+}
+function MatchSchemaObject(schema, base, ref) {
+    if (!Schema.IsSchemaObject(schema))
+        return undefined;
+    return MatchWithId(schema, base, ref) ??
+        MatchWithAnchor(schema, base, ref) ??
+        MatchWithDynamicAnchor(schema, base, ref) ??
+        MatchWithHash(schema, 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) {
-    // 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) {
+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);
 }
+function Match(schema, base, ref) {
+    const relativeBase = RelativeBase(schema, base);
+    return MatchSchemaObject(schema, relativeBase, ref) ??
+        MatchFromArray(schema, relativeBase, ref) ??
+        MatchFromObject(schema, relativeBase, ref);
+}
 // ------------------------------------------------------------------
-// FromValue
+// 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.
 // ------------------------------------------------------------------
-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;
+function Resource(context, schema, base, ref) {
+    const result = RefInternal(context, schema, base, ref);
+    return Schema.IsSchemaObject(result) && Schema.IsId(result) ? result : undefined;
 }
 // ------------------------------------------------------------------
-// CanonicalHref
+// FindDeferredResource
 //
-// 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.
+// 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 CanonicalHref(url) {
-    return url.href.split('#')[0];
+function FindDeferredResourceLegacy(stack, ref, schema) {
+    if (!ref.$ref.startsWith('#'))
+        return undefined;
+    if (!Schema.IsSchemaObject(stack.schema) || Guard.HasPropertyKey(stack.schema, '$schema'))
+        return undefined;
+    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: /* safe-object-root */ stack.lexicalSchema };
+}
+function FindDeferredResourceModern(stack, canonical, schema) {
+    const remoteRoot = stack.context[canonical];
+    if (!Schema.IsSchemaObject(remoteRoot))
+        return undefined;
+    return { target: schema, base: canonical, root: remoteRoot };
+}
+function FindDeferredResource(stack, ref, schema, canonical, isRemote) {
+    const remote = isRemote ? FindDeferredResourceModern(stack, canonical, schema) : undefined;
+    return Guard.IsUndefined(remote) ? FindDeferredResourceLegacy(stack, ref, schema) : remote;
 }
 // ------------------------------------------------------------------
-// RefContext: Phase 1
+// FindResolvedResource
 //
-// A ContextRef targets a simple key name in the context and is
-// used for fast resolution of inline referential TypeBox types.
+// 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 RefContext(context, ref) {
+function FindResolvedResource(stack, canonical, schema) {
+    if (Schema.IsId(schema))
+        return undefined;
+    const resource = Resource(stack.context, /* safe-object-root */ stack.schema, stack.referenceBase, canonical);
+    if (!resource || stack.ids.includes(resource))
+        return undefined;
+    return { resource };
+}
+// ------------------------------------------------------------------
+// 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.
+// ------------------------------------------------------------------
+function RefInternalWithContext(context, ref) {
     return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
 }
+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;
+    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);
+}
 // ------------------------------------------------------------------
-// RefLocal: Phase 2
+// RefNextStack
 //
-// 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.
+// 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 RefLocal(schema, base, ref) {
-    return FromValue(schema, base, ref);
+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;
 }
 // ------------------------------------------------------------------
-// RefRemote: Phase 3
+// RefResult
 //
-// 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.
+// 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 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);
+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)) };
 }
 // ------------------------------------------------------------------
 // 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 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(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);
 }
 // ------------------------------------------------------------------
-// DynamicRef
+// 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.
 // ------------------------------------------------------------------
-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.
+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);
+}
+// ------------------------------------------------------------------
+// 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;
-    // 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;
+    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/node_modules/typebox/build/schema/schema.d.mts

@@ -1,4 +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/node_modules/typebox/build/schema/schema.mjs

@@ -1,4 +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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/package.json

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