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

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,12 +2,23 @@
 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';
 // ------------------------------------------------------------------
-// Common: GetPropertiesPattern
+// Optimization: IsAdditionalPropertiesIgnored
+//
+// We can ignore additionalProperties if the schema is true-like and
+// we are not in an unevaluated context, noting that additional
+// properties are considered tracked, evaluated keys.
+// ------------------------------------------------------------------
+function IsAdditionalPropertiesIgnored(context, additionalProperties) {
+    return !context.UseUnevaluated() &&
+        (G.IsEqual(additionalProperties, true) ||
+            (G.IsObject(additionalProperties) && G.IsEqual(G.Keys(additionalProperties).length, 0)));
+}
+// ------------------------------------------------------------------
+// Optimization: GetPropertiesPattern
 //
 // Constructs a regular expression that matches all property keys
 // and pattern properties defined in a schema. This approach unifies
@@ -71,6 +82,8 @@ export function BuildAdditionalPropertiesStandard(stack, context, schema, value)
 // Build
 // ------------------------------------------------------------------
 export function BuildAdditionalProperties(stack, context, schema, value) {
+    if (IsAdditionalPropertiesIgnored(context, schema.additionalProperties))
+        return E.Constant(true);
     return CanAdditionalPropertiesFast(context, schema, value)
         ? BuildAdditionalPropertiesFast(context, schema, value)
         : BuildAdditionalPropertiesStandard(stack, context, schema, value);
@@ -95,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[]];

package/build/schema/errors.mjs

@@ -1,24 +1,18 @@
 // deno-fmt-ignore-file
 import { Arguments } from '../system/arguments/index.mjs';
-import { Settings } from '../system/settings/index.mjs';
-import { Get as LocaleGet } from '../system/locale/_config.mjs';
-import { Guard } from '../guard/index.mjs';
+import { Get as GetLocalizationFunction } from '../system/locale/_config.mjs';
 import * as Engine from './engine/index.mjs';
-/** Checks a value and returns validation errors */
+/** Returns an array of validation errors for the given value. */
 export function Errors(...args) {
     const [context, schema, value] = Arguments.Match(args, {
         3: (context, schema, value) => [context, schema, value],
         2: (schema, value) => [{}, schema, value]
     });
-    const settings = Settings.Get();
-    const locale = LocaleGet();
-    const errors = [];
     const stack = new Engine.Stack(context, schema);
-    const errorContext = new Engine.ErrorContext(error => {
-        if (Guard.IsGreaterEqualThan(errors.length, settings.maxErrors))
-            return;
-        return errors.push({ ...error, message: locale(error) });
-    });
+    const errorContext = new Engine.ErrorContext();
     const result = Engine.ErrorSchema(stack, errorContext, '#', '', schema, value);
-    return [result, errors];
+    const errors = errorContext.GetErrors();
+    const locale = GetLocalizationFunction();
+    const localized = errors.map(error => ({ ...error, message: locale(error) }));
+    return [result, localized];
 }

package/build/schema/intern/index.d.mts

@@ -0,0 +1 @@
+export * from './intern.mjs';

package/build/schema/intern/index.mjs

@@ -0,0 +1 @@
+export * from './intern.mjs';

package/build/schema/intern/intern.d.mts

@@ -0,0 +1,14 @@
+import { type XStatic } from '../static/index.mjs';
+import * as S from '../types/index.mjs';
+export interface XIntern<Type extends unknown = unknown> {
+    '~unsafe': Type;
+    $ref: string;
+    $defs: Record<string, S.XSchemaObject>;
+}
+/**
+ * [Experimental] Performs a Common Subexpression Elimination (CSE) transform on the given
+ * schema. This function restructures the schema such that each distinct sub-schema is stored
+ * exactly once in a $defs object and keyed by content hash. This function can be used to
+ * both compress and optimize schemas prior to compilation.
+ */
+export declare function Intern<const Schema extends S.XSchema>(schema: Schema): XIntern<XStatic<Schema>>;