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

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typebox
 
 | Field | Value |
 |-------|-------|
-| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.3.22 |
-| Processed | 2026-08-30 |
+| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.3.27 |
+| Processed | 2026-09-06 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/build/compile/validator.d.mts

@@ -18,7 +18,7 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Check(value: unknown): value is Encode;
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value: unknown): Encode;
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
     Clean(value: unknown): unknown;

package/build/compile/validator.mjs

@@ -53,7 +53,7 @@ export class Validator {
             return Parser(this.Context(), this.Type(), value);
         throw new ParseError(value, this.Errors(value));
     }
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value) {
         if (this.IsAccelerated() && this.Check(value))
             return [];

package/build/format/iri.mjs

@@ -2,6 +2,7 @@
 const IpvFutureMatchMaxLength = 2048;
 const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
 const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
 // NarrowIpvFuture
 //
@@ -26,6 +27,9 @@ export function IsIri(value) {
     // 1. Reject strings containing unencoded whitespace or illegal control characters.
     if (InvalidIriChars.test(value))
         return false;
-    // 2. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
+    // 2. Reject malformed percent-encoding triplets.
+    if (InvalidPercentEncoding.test(value))
+        return false;
+    // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
     return URL.canParse(NarrowIpvFuture(value));
 }

package/build/schema/compile.d.mts

@@ -2,8 +2,9 @@ import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type Static } from '../type/types/static.mjs';
 import * as Schema from './types/index.mjs';
 export declare class Validator<const Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static<Schema>> {
-    private readonly buildResult;
     private readonly evaluateResult;
+    private readonly context;
+    private readonly schema;
     constructor(context: Record<string, Schema.XSchema>, schema: Schema);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;
@@ -13,7 +14,7 @@ export declare class Validator<const Schema extends Schema.XSchema = Schema.XSch
     Check(value: unknown): value is Value;
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value: unknown): Value;
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
 }
 /** Compiles this schema into a high performance Validator */

package/build/schema/compile.mjs

@@ -3,14 +3,15 @@
 import { Arguments } from '../system/arguments/index.mjs';
 import * as Build from './build.mjs';
 import { Errors } from './errors.mjs';
-import { ParseError } from './parse.mjs';
+import { ThrowParseError } from './parse.mjs';
 // ------------------------------------------------------------------
 // Validator
 // ------------------------------------------------------------------
 export class Validator {
     constructor(context, schema) {
-        this.buildResult = Build.Build(context, schema);
-        this.evaluateResult = this.buildResult.Evaluate();
+        this.evaluateResult = Build.Build(context, schema).Evaluate();
+        this.context = context;
+        this.schema = schema;
     }
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
@@ -18,7 +19,7 @@ export class Validator {
     }
     /** Returns the underlying Schema used to construct this Validator. */
     Schema() {
-        return this.buildResult.Schema();
+        return this.schema;
     }
     /** Performs a type-guard check on the provided value. */
     Check(value) {
@@ -28,12 +29,11 @@ export class Validator {
     Parse(value) {
         if (this.evaluateResult.Check(value))
             return value;
-        const [_result, errors] = Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
-        throw new ParseError(this.buildResult.Schema(), value, errors);
+        ThrowParseError(this.context, this.schema, value);
     }
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value) {
-        return Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
+        return Errors(this.context, this.schema, value);
     }
 }
 /** Compiles this schema into a high performance Validator */

package/build/schema/engine/_context.d.mts

@@ -21,15 +21,10 @@ export declare class CheckContext {
     GetKeys(): Set<string>;
     Merge(results: CheckContext[]): true;
 }
-export type ErrorContextCallback = (error: TValidationError) => unknown;
 export declare class ErrorContext extends CheckContext {
-    private readonly callback;
-    constructor(callback: ErrorContextCallback);
-    AddError(error: TValidationError): false;
-}
-export declare class AccumulatedErrorContext extends ErrorContext {
     private readonly errors;
     constructor();
+    AtCapacity(): boolean;
     AddError(error: TValidationError): false;
     GetErrors(): TValidationError[];
 }

package/build/schema/engine/_context.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Settings } from '../../system/settings/index.mjs';
 import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
@@ -101,26 +102,20 @@ export class CheckContext {
         return true;
     }
 }
-export class ErrorContext extends CheckContext {
-    constructor(callback) {
-        super();
-        this.callback = callback;
-    }
-    AddError(error) {
-        this.callback(error);
-        return false;
-    }
-}
 // ------------------------------------------------------------------
-// AccumulatedErrorContext
+// ErrorContext
 // ------------------------------------------------------------------
-export class AccumulatedErrorContext extends ErrorContext {
+export class ErrorContext extends CheckContext {
     constructor() {
-        super(error => this.errors.push(error));
+        super();
         this.errors = [];
     }
+    AtCapacity() {
+        return this.errors.length >= Settings.Get().maxErrors;
+    }
     AddError(error) {
-        this.errors.push(error);
+        if (!this.AtCapacity())
+            this.errors.push(error);
         return false;
     }
     GetErrors() {

package/build/schema/engine/_functions.mjs

@@ -55,7 +55,7 @@ export function GetFunctions() {
 // CreateFunction
 // ------------------------------------------------------------------
 export function CreateFunction(stack, context, schema, value) {
-    const name = CreateName(schema, stack.BaseURL().href);
+    const name = CreateName(schema, stack.LexicalBaseURL());
     const call = CreateCallExpression(context, schema, name, value);
     if (funcs.has(name))
         return call;

package/build/schema/engine/_stack.d.mts

@@ -4,12 +4,16 @@ export declare class Stack {
     private readonly context;
     private readonly schema;
     private readonly ids;
+    private readonly resourceIds;
     private readonly anchors;
     private readonly recursiveAnchors;
     private readonly dynamicAnchors;
+    private readonly retrievedResources;
+    private readonly retrievedFrames;
+    private readonly resolvedResources;
+    private pendingResource;
     constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema);
-    BaseURL(): URL;
-    Base(): Schema.XSchemaObject;
+    LexicalBaseURL(): string;
     Push(schema: Schema.XSchema): void;
     Pop(schema: Schema.XSchema): void;
     Ref(ref: Schema.XRef): Schema.XSchema | undefined;

package/build/schema/engine/_stack.mjs

@@ -4,86 +4,163 @@ 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;
+var _Stack_instances, _Stack_StackFrame, _Stack_ApplyRefResult, _Stack_BuildBase, _Stack_ResourceBaseURL, _Stack_ReferenceBaseURL, _Stack_LexicalSchema, _Stack_RegisterResourceAnchorArray, _Stack_UnregisterResourceAnchorArray, _Stack_RegisterResourceAnchors, _Stack_UnregisterResourceAnchors, _Stack_RegisterResource, _Stack_UnregisterResource, _Stack_EnterResolvedResource, _Stack_ExitResolvedResource;
 import * as Schema from '../types/index.mjs';
-import { Guard as G } from '../../guard/index.mjs';
+import { Guard } from '../../guard/index.mjs';
 import { Resolve } from '../resolve/index.mjs';
+// --------------------------------------------------------------------------
+// Stack
+//
+// Tracks traversal state ($ids, $anchors, stack frames) and applies scope
+// updates. Reference resolution rules ($ref, $dynamicRef) are delegated to
+// the Resolve functions using state snapshots (Resolve.Scope).
+// --------------------------------------------------------------------------
 export class Stack {
     constructor(context, schema) {
         _Stack_instances.add(this);
         this.context = context;
         this.schema = schema;
         this.ids = [];
+        this.resourceIds = [];
         this.anchors = [];
         this.recursiveAnchors = [];
         this.dynamicAnchors = [];
+        this.retrievedResources = new Map();
+        this.retrievedFrames = [];
+        this.resolvedResources = new Map();
+        this.pendingResource = true;
     }
     // ----------------------------------------------------------------
-    // Base
+    // LexicalBaseURL
     // ----------------------------------------------------------------
-    BaseURL() {
-        return this.ids.reduce((result, schema) => new URL(schema.$id, result), Resolve.DefaultBase);
-    }
-    Base() {
-        return this.ids[this.ids.length - 1] ?? this.schema;
+    LexicalBaseURL() {
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.ids);
     }
     // ----------------------------------------------------------------
-    // Stack
+    // Push
     // ----------------------------------------------------------------
     Push(schema) {
         if (!Schema.IsSchemaObject(schema))
             return;
-        if (Schema.IsId(schema)) {
-            this.ids.push(schema);
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, schema);
-        }
+        if (Schema.IsId(schema))
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).call(this, schema);
         if (Schema.IsAnchor(schema))
             this.anchors.push(schema);
         if (Schema.IsRecursiveAnchorTrue(schema))
             this.recursiveAnchors.push(schema);
         if (Schema.IsDynamicAnchor(schema))
             this.dynamicAnchors.push(schema);
+        const retrievedResource = this.retrievedResources.get(schema);
+        if (retrievedResource) {
+            this.retrievedFrames.push({
+                schema: retrievedResource.root,
+                base: retrievedResource.base,
+                idDepth: this.ids.length,
+                resourceDepth: this.resourceIds.length
+            });
+        }
     }
+    // ----------------------------------------------------------------
+    // Pop
+    // ----------------------------------------------------------------
     Pop(schema) {
         if (!Schema.IsSchemaObject(schema))
             return;
-        if (Schema.IsId(schema)) {
-            this.ids.pop();
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, schema);
-        }
+        if (Schema.IsId(schema))
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).call(this, schema);
         if (Schema.IsAnchor(schema))
             this.anchors.pop();
         if (Schema.IsRecursiveAnchorTrue(schema))
             this.recursiveAnchors.pop();
         if (Schema.IsDynamicAnchor(schema))
             this.dynamicAnchors.pop();
+        if (this.retrievedResources.has(schema))
+            this.retrievedFrames.pop();
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ExitResolvedResource).call(this, schema);
     }
     // ----------------------------------------------------------------
     // Ref
     // ----------------------------------------------------------------
     Ref(ref) {
-        const root = this.schema;
-        return !ref.$ref.startsWith('#')
-            ? Resolve.Ref(this.context, root, ref.$ref)
-            : Resolve.Ref(this.context, this.Base(), ref.$ref);
+        const result = Resolve.ResolveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), ref);
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ApplyRefResult).call(this, result);
+        return result.schema;
     }
     // ----------------------------------------------------------------
     // RecursiveRef
     // ----------------------------------------------------------------
     RecursiveRef(recursiveRef) {
-        return Schema.IsRecursiveAnchorTrue(this.Base())
-            ? Resolve.Ref(this.context, this.recursiveAnchors[0], recursiveRef.$recursiveRef)
-            : Resolve.Ref(this.context, this.Base(), recursiveRef.$recursiveRef);
+        const result = Resolve.ResolveRecursiveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), recursiveRef);
+        if (result)
+            this.pendingResource = true;
+        return result;
     }
     // ----------------------------------------------------------------
     // DynamicRef
     // ----------------------------------------------------------------
     DynamicRef(dynamicRef) {
-        const root = this.schema;
-        return Resolve.DynamicRef(this.context, root, this.Base(), dynamicRef, this.dynamicAnchors);
+        const result = Resolve.ResolveDynamicRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), dynamicRef);
+        if (result)
+            this.pendingResource = true;
+        return result;
     }
 }
-_Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
+_Stack_instances = new WeakSet(), _Stack_StackFrame = function _Stack_StackFrame() {
+    return {
+        context: this.context,
+        root: this.schema,
+        ids: this.ids,
+        lexicalSchema: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_LexicalSchema).call(this),
+        lexicalBase: this.LexicalBaseURL(),
+        referenceBase: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ReferenceBaseURL).call(this),
+        resourceBase: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this),
+        recursiveAnchors: this.recursiveAnchors,
+        dynamicAnchors: this.dynamicAnchors,
+        inRetrievedFrame: this.retrievedFrames.length > 0
+    };
+}, _Stack_ApplyRefResult = function _Stack_ApplyRefResult(result) {
+    if (!Guard.IsUndefined(result.schema))
+        this.pendingResource = true;
+    if (!Guard.IsUndefined(result.resolvedResource)) {
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_EnterResolvedResource).call(this, result.resolvedResource.target, result.resolvedResource.resource);
+    }
+    if (!Guard.IsUndefined(result.retrievedResource)) {
+        this.retrievedResources.set(result.retrievedResource.target, {
+            base: result.retrievedResource.base,
+            root: result.retrievedResource.root
+        });
+    }
+}, _Stack_BuildBase = function _Stack_BuildBase(stack) {
+    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
+    const base = frame ? new URL(frame.base) : new URL(Resolve.DefaultBase);
+    const scoped = frame ? stack.slice(frame.idDepth) : stack;
+    return scoped.reduce((result, schema) => new URL(schema.$id, result), base).href;
+}, _Stack_ResourceBaseURL = function _Stack_ResourceBaseURL() {
+    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
+    if (!frame)
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.resourceIds);
+    return this.resourceIds.slice(frame.resourceDepth).reduce((result, schema) => new URL(schema.$id, result), new URL(frame.base)).href;
+}, _Stack_ReferenceBaseURL = function _Stack_ReferenceBaseURL() {
+    if (this.retrievedFrames.length > 0)
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this);
+    const lexical = this.ids[this.ids.length - 1];
+    if (lexical && !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(lexical.$id))
+        return this.LexicalBaseURL();
+    return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this);
+}, _Stack_LexicalSchema = function _Stack_LexicalSchema() {
+    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
+    if (frame)
+        return this.ids.length > frame.idDepth ? this.ids[this.ids.length - 1] : frame.schema;
+    return this.ids.length > 0 ? this.ids[this.ids.length - 1] : this.schema;
+}, _Stack_RegisterResourceAnchorArray = function _Stack_RegisterResourceAnchorArray(schema) {
+    schema.forEach((schema) => __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, schema, false));
+}, _Stack_UnregisterResourceAnchorArray = function _Stack_UnregisterResourceAnchorArray(schema) {
+    schema.forEach((schema) => __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, schema, false));
+}, _Stack_RegisterResourceAnchors = function _Stack_RegisterResourceAnchors(schema, isRoot = true) {
+    if (Schema.IsSchemaBoolean(schema))
+        return;
+    if (Guard.IsArray(schema))
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchorArray).call(this, schema);
     if (!Schema.IsSchemaObject(schema))
         return;
     const current = schema;
@@ -91,9 +168,13 @@ _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_P
         return;
     if (!isRoot && Schema.IsDynamicAnchor(current))
         this.dynamicAnchors.push(current);
-    for (const key of G.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, current[key], false);
-}, _Stack_PopResourceAnchors = function _Stack_PopResourceAnchors(schema, isRoot = true) {
+    for (const key of Guard.Keys(current))
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, current[key], false);
+}, _Stack_UnregisterResourceAnchors = function _Stack_UnregisterResourceAnchors(schema, isRoot = true) {
+    if (Schema.IsSchemaBoolean(schema))
+        return;
+    if (Guard.IsArray(schema))
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchorArray).call(this, schema);
     if (!Schema.IsSchemaObject(schema))
         return;
     const current = schema;
@@ -101,6 +182,28 @@ _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_P
         return;
     if (!isRoot && Schema.IsDynamicAnchor(current))
         this.dynamicAnchors.pop();
-    for (const key of G.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
+    for (const key of Guard.Keys(current))
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, current[key], false);
+}, _Stack_RegisterResource = function _Stack_RegisterResource(schema) {
+    this.ids.push(schema);
+    const isResource = this.pendingResource;
+    this.pendingResource = false;
+    if (isResource)
+        this.resourceIds.push(schema);
+    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, schema, true);
+}, _Stack_UnregisterResource = function _Stack_UnregisterResource(schema) {
+    this.ids.pop();
+    const isResource = this.resourceIds.length > 0 && Guard.IsEqual(this.resourceIds[this.resourceIds.length - 1], schema);
+    if (isResource)
+        this.resourceIds.pop();
+    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, schema, true);
+}, _Stack_EnterResolvedResource = function _Stack_EnterResolvedResource(target, resource) {
+    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).call(this, resource);
+    this.resolvedResources.set(target, resource);
+}, _Stack_ExitResolvedResource = function _Stack_ExitResolvedResource(target) {
+    if (!this.resolvedResources.has(target))
+        return;
+    const resource = this.resolvedResources.get(target);
+    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).call(this, resource);
+    this.resolvedResources.delete(target);
 };

package/build/schema/engine/additionalProperties.mjs

@@ -2,7 +2,6 @@
 import * as S from '../types/index.mjs';
 import * as V from './_externals.mjs';
 import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
@@ -109,9 +108,8 @@ export function ErrorAdditionalProperties(stack, context, schemaPath, instancePa
     const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;
         const nextInstancePath = `${instancePath}/${key}`;
-        const nextContext = new AccumulatedErrorContext();
         const isAdditionalProperty = regexp.test(key) ||
-            (ErrorSchemaPushStack(stack, nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
+            (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
         if (!isAdditionalProperty)
             additionalProperties.push(key);
         return isAdditionalProperty;

package/build/schema/engine/allOf.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
@@ -34,7 +34,7 @@ export function ErrorAllOf(stack, context, schemaPath, instancePath, schema, val
     const failedContexts = [];
     const results = schema.allOf.reduce((result, schema, index) => {
         const nextSchemaPath = `${schemaPath}/allOf/${index}`;
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (!isSchema)
             failedContexts.push(nextContext);

package/build/schema/engine/anyOf.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
@@ -33,7 +33,7 @@ export function CheckAnyOf(stack, context, schema, value) {
 export function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, value) {
     const failedContexts = [];
     const results = schema.anyOf.reduce((result, schema, index) => {
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const nextSchemaPath = `${schemaPath}/anyOf/${index}`;
         const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (!isSchema)

package/build/schema/engine/if.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
+import { ErrorContext } from './_context.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -27,7 +27,7 @@ export function CheckIf(stack, context, schema, value) {
 export function ErrorIf(stack, context, schemaPath, instancePath, schema, value) {
     const thenSchema = Schema.IsThen(schema) ? schema.then : true;
     const elseSchema = Schema.IsElse(schema) ? schema.else : true;
-    const trueContext = new AccumulatedErrorContext();
+    const trueContext = new ErrorContext();
     const isIf = ErrorSchema(stack, trueContext, `${schemaPath}/if`, instancePath, schema.if, value)
         ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
             keyword: 'if',

package/build/schema/engine/oneOf.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
@@ -38,7 +38,7 @@ export function ErrorOneOf(stack, context, schemaPath, instancePath, schema, val
     const failedContexts = [];
     const passingSchemas = [];
     const passedContexts = schema.oneOf.reduce((result, schema, index) => {
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const nextSchemaPath = `${schemaPath}/oneOf/${index}`;
         const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (isSchema)

package/build/schema/engine/propertyNames.mjs

@@ -1,6 +1,5 @@
 // deno-fmt-ignore-file
 import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -24,8 +23,7 @@ export function ErrorPropertyNames(stack, context, schemaPath, instancePath, sch
     const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextInstancePath = `${instancePath}/${key}`;
         const nextSchemaPath = `${schemaPath}/propertyNames`;
-        const nextContext = new AccumulatedErrorContext();
-        const isPropertyName = ErrorSchema(stack, nextContext, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
+        const isPropertyName = ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
         if (!isPropertyName)
             propertyNames.push(key);
         return isPropertyName;

package/build/schema/engine/ref.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import * as Functions from './_functions.mjs';
 import * as Schema from '../types/index.mjs';
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -42,7 +42,7 @@ export function CheckRef(stack, context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
     const target = stack.Ref(schema) ?? false;
-    const nextContext = new AccumulatedErrorContext();
+    const nextContext = new ErrorContext();
     const result = (Schema.IsSchema(target) && ErrorSchema(stack, nextContext, '#', instancePath, target, value));
     if (result)
         context.Merge([nextContext]);

package/build/schema/engine/schema.mjs

@@ -308,6 +308,12 @@ export function ErrorSchemaPushStack(stack, context, schemaPath, instancePath, s
     return (context.Push() && ErrorSchema(stack, context, schemaPath, instancePath, schema, value)) && context.Pop();
 }
 export function ErrorSchema(stack, context, schemaPath, instancePath, schema, value) {
+    // Optimization: We can safely terminate here when the context is at capacity because we are unable to
+    // append additional errors. It is worth being mindful that logical keywords such as allOf, anyOf,
+    // oneOf pass a new context per operand, so the capacity check applies per context, not across the
+    // full set of errors accumulated by the schema as a whole. (review)
+    if (context.AtCapacity())
+        return false;
     stack.Push(schema);
     const result = (Schema.IsSchemaBoolean(schema)) ? ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) : (!!(+(!Schema.IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) &
         +(!(G.IsObject(value) && !G.IsArray(value)) || !!(+(!Schema.IsRequired(schema) || ErrorRequired(stack, context, schemaPath, instancePath, schema, value)) &

package/build/schema/engine/unevaluatedItems.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
+import { ErrorContext } from './_context.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -35,7 +35,7 @@ export function ErrorUnevaluatedItems(stack, context, schemaPath, instancePath,
     const indices = context.GetIndices();
     const unevaluatedItems = [];
     const isUnevaluatedItems = G.EveryAll(value, 0, (item, index) => {
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const isEvaluatedItem = (indices.has(index) || ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedItems, item))
             && context.AddIndex(index);
         if (!isEvaluatedItem)

package/build/schema/engine/unevaluatedProperties.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
+import { ErrorContext } from './_context.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -35,7 +35,7 @@ export function ErrorUnevaluatedProperties(stack, context, schemaPath, instanceP
     const keys = context.GetKeys();
     const unevaluatedProperties = [];
     const isUnevaluatedProperties = G.EveryAll(G.Entries(value), 0, ([key, prop]) => {
-        const nextContext = new AccumulatedErrorContext();
+        const nextContext = new ErrorContext();
         const isEvaluatedProperty = keys.has(key)
             || (ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedProperties, prop) && context.AddKey(key));
         if (!isEvaluatedProperty)

package/build/schema/errors.d.mts

@@ -1,6 +1,6 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
 import * as Schema from './types/index.mjs';
-/** Checks a value and returns validation errors */
+/** Returns an array of validation errors for the given value. */
 export declare function Errors(schema: Schema.XSchema, value: unknown): [boolean, TLocalizedValidationError[]];
-/** Checks a value and returns validation errors */
+/** Returns an array of validation errors for the given value. */
 export declare function Errors(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, value: unknown): [boolean, TLocalizedValidationError[]];