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

package/build/schema/engine/multipleOf.mjs

@@ -16,10 +16,6 @@ export function CheckMultipleOf(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorMultipleOf(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckMultipleOf(stack, context, schema, value) || context.AddError({
-        keyword: 'multipleOf',
-        schemaPath,
-        instancePath,
-        params: { multipleOf: schema.multipleOf }
-    });
+    return CheckMultipleOf(stack, context, schema, value) ||
+        context.AddError('multipleOf', schemaPath, instancePath, { multipleOf: schema.multipleOf });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildNot(stack: Stack, context: BuildContext, schema: Schema.XNot, value: string): string;
-export declare function CheckNot(stack: Stack, context: CheckContext, schema: Schema.XNot, value: unknown): boolean;
-export declare function ErrorNot(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XNot, value: unknown): boolean;
+export declare function BuildNot(stack: Stack.XStack, context: BuildContext, schema: Schema.XNot, value: string): string;
+export declare function CheckNot(stack: Stack.XStack, context: CheckContext, schema: Schema.XNot, value: unknown): boolean;
+export declare function ErrorNot(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XNot, value: unknown): boolean;

package/build/schema/engine/not.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { CheckContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
+import { CheckContext } from './_context.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -30,10 +30,6 @@ export function CheckNot(stack, context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorNot(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckNot(stack, context, schema, value) || context.AddError({
-        keyword: 'not',
-        schemaPath,
-        instancePath,
-        params: {},
-    });
+    return CheckNot(stack, context, schema, value) ||
+        context.AddError('not', schemaPath, instancePath, {});
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildOneOf(stack: Stack, context: BuildContext, schema: Schema.XOneOf, value: string): string;
-export declare function CheckOneOf(stack: Stack, context: CheckContext, schema: Schema.XOneOf, value: unknown): boolean;
-export declare function ErrorOneOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XOneOf, value: unknown): boolean;
+export declare function BuildOneOf(stack: Stack.XStack, context: BuildContext, schema: Schema.XOneOf, value: string): string;
+export declare function CheckOneOf(stack: Stack.XStack, context: CheckContext, schema: Schema.XOneOf, value: unknown): boolean;
+export declare function ErrorOneOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XOneOf, value: unknown): boolean;

package/build/schema/engine/oneOf.mjs

@@ -1,9 +1,9 @@
 // deno-fmt-ignore-file
-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';
 import { Unique } from './_unique.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -49,11 +49,6 @@ export function ErrorOneOf(stack, context, schemaPath, instancePath, schema, val
     }, []);
     const isOneOf = G.IsEqual(passedContexts.length, 1) && context.Merge(passedContexts);
     if (!isOneOf && G.IsEqual(passingSchemas.length, 0))
-        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
-    return isOneOf || context.AddError({
-        keyword: 'oneOf',
-        schemaPath,
-        instancePath,
-        params: { passingSchemas },
-    });
+        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
+    return isOneOf || context.AddError('oneOf', schemaPath, instancePath, { passingSchemas });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPattern(_stack: Stack, _context: BuildContext, schema: Schema.XPattern, value: string): string;
-export declare function CheckPattern(_stack: Stack, _context: CheckContext, schema: Schema.XPattern, value: string): boolean;
-export declare function ErrorPattern(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPattern, value: string): boolean;
+export declare function BuildPattern(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XPattern, value: string): string;
+export declare function CheckPattern(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XPattern, value: string): boolean;
+export declare function ErrorPattern(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPattern, value: string): boolean;

package/build/schema/engine/pattern.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import * as Externals from './_externals.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -20,10 +20,6 @@ export function CheckPattern(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorPattern(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckPattern(stack, context, schema, value) || context.AddError({
-        keyword: 'pattern',
-        schemaPath,
-        instancePath,
-        params: { pattern: schema.pattern }
-    });
+    return CheckPattern(stack, context, schema, value) ||
+        context.AddError('pattern', schemaPath, instancePath, { pattern: schema.pattern });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPatternProperties(stack: Stack, context: BuildContext, schema: Schema.XPatternProperties, value: string): string;
-export declare function CheckPatternProperties(stack: Stack, context: CheckContext, schema: Schema.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorPatternProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildPatternProperties(stack: Stack.XStack, context: BuildContext, schema: Schema.XPatternProperties, value: string): string;
+export declare function CheckPatternProperties(stack: Stack.XStack, context: CheckContext, schema: Schema.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorPatternProperties(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/patternProperties.mjs

@@ -1,9 +1,10 @@
 // deno-fmt-ignore-file
 import * as Externals from './_externals.mjs';
+import * as Pathing from './_pathing.mjs';
 import { Unique } from './_unique.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -34,10 +35,10 @@ export function CheckPatternProperties(stack, context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorPatternProperties(stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
-        const nextSchemaPath = `${schemaPath}/patternProperties/${pattern}`;
+        const nextSchemaPath = `${schemaPath}/patternProperties/${Pathing.EncodeFragment(pattern)}`;
         const regexp = UnicodeRegExp(pattern);
         return G.EveryAll(G.Entries(value), 0, ([key, value]) => {
-            const nextInstancePath = `${instancePath}/${key}`;
+            const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
             const notKey = !regexp.test(key);
             return notKey || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);
         });

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPrefixItems(stack: Stack, context: BuildContext, schema: Schema.XPrefixItems, value: string): string;
-export declare function CheckPrefixItems(stack: Stack, context: CheckContext, schema: Schema.XPrefixItems, value: unknown[]): boolean;
-export declare function ErrorPrefixItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPrefixItems, value: unknown[]): boolean;
+export declare function BuildPrefixItems(stack: Stack.XStack, context: BuildContext, schema: Schema.XPrefixItems, value: string): string;
+export declare function CheckPrefixItems(stack: Stack.XStack, context: CheckContext, schema: Schema.XPrefixItems, value: unknown[]): boolean;
+export declare function ErrorPrefixItems(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPrefixItems, value: unknown[]): boolean;

package/build/schema/engine/prefixItems.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildProperties(stack: Stack, context: BuildContext, schema: Schema.XProperties, value: string): string;
-export declare function CheckProperties(stack: Stack, context: CheckContext, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildProperties(stack: Stack.XStack, context: BuildContext, schema: Schema.XProperties, value: string): string;
+export declare function CheckProperties(stack: Stack.XStack, context: CheckContext, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorProperties(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/properties.mjs

@@ -1,8 +1,9 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import * as Pathing from './_pathing.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 import { InexactOptionalCheck, InexactOptionalBuild, IsExactOptional } from './_exact_optional.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -63,8 +64,8 @@ export function CheckProperties(stack, context, schema, value) {
 export function ErrorProperties(stack, context, schemaPath, instancePath, schema, value) {
     const required = Schema.IsRequired(schema) ? schema.required : [];
     const isProperties = G.EveryAll(G.Entries(schema.properties), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/properties/${key}`;
-        const nextInstancePath = `${instancePath}/${key}`;
+        const nextSchemaPath = `${schemaPath}/properties/${Pathing.EncodeFragment(key)}`;
+        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
         // Defer error generation for IsExactOptional
         const isProperty = () => (!G.HasPropertyKey(value, key) || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key)));
         return IsExactOptional(required, key)

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPropertyNames(stack: Stack, context: BuildContext, schema: Schema.XPropertyNames, value: string): string;
-export declare function CheckPropertyNames(stack: Stack, context: CheckContext, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorPropertyNames(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildPropertyNames(stack: Stack.XStack, context: BuildContext, schema: Schema.XPropertyNames, value: string): string;
+export declare function CheckPropertyNames(stack: Stack.XStack, context: CheckContext, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorPropertyNames(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/propertyNames.mjs

@@ -1,7 +1,8 @@
 // deno-fmt-ignore-file
+import * as Pathing from './_pathing.mjs';
 import { Unique } from './_unique.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -21,17 +22,13 @@ export function CheckPropertyNames(stack, context, schema, value) {
 export function ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, value) {
     const propertyNames = [];
     const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key, _index) => {
-        const nextInstancePath = `${instancePath}/${key}`;
+        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
         const nextSchemaPath = `${schemaPath}/propertyNames`;
         const isPropertyName = ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
         if (!isPropertyName)
             propertyNames.push(key);
         return isPropertyName;
     });
-    return isPropertyNames || context.AddError({
-        keyword: 'propertyNames',
-        schemaPath,
-        instancePath,
-        params: { propertyNames }
-    });
+    return isPropertyNames ||
+        context.AddError('propertyNames', schemaPath, instancePath, { propertyNames });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRecursiveRef(stack: Stack, context: BuildContext, schema: Schema.XRecursiveRef, value: string): string;
-export declare function CheckRecursiveRef(stack: Stack, context: CheckContext, schema: Schema.XRecursiveRef, value: unknown): boolean;
-export declare function ErrorRecursiveRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;
+export declare function BuildRecursiveRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XRecursiveRef, value: string): string;
+export declare function CheckRecursiveRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XRecursiveRef, value: unknown): boolean;
+export declare function ErrorRecursiveRef(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;

package/build/schema/engine/recursiveRef.mjs

@@ -1,25 +1,29 @@
 // deno-fmt-ignore-file
-import * as Functions from './_functions.mjs';
 import * as Schema from '../types/index.mjs';
+import * as Functions from './_functions.mjs';
+import { Resolve } from '../resolve/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildRecursiveRef(stack, context, schema, value) {
-    const target = stack.RecursiveRef(schema) ?? false;
-    return Functions.CreateFunction(stack, context, target, value);
+    const target = Resolve.RecursiveRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return Functions.CreateFunction(nextStack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRecursiveRef(stack, context, schema, value) {
-    const target = stack.RecursiveRef(schema) ?? false;
-    return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
+    const target = Resolve.RecursiveRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return (Schema.IsSchema(target) && CheckSchema(nextStack, context, target, value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRecursiveRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.RecursiveRef(schema) ?? false;
-    return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', instancePath, target, value));
+export function ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value) {
+    const target = Resolve.RecursiveRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value));
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRef(stack: Stack, context: BuildContext, schema: Schema.XRef, value: string): string;
-export declare function CheckRef(stack: Stack, context: CheckContext, schema: Schema.XRef, value: unknown): boolean;
-export declare function ErrorRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;
+export declare function BuildRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XRef, value: string): string;
+export declare function CheckRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XRef, value: unknown): boolean;
+export declare function ErrorRef(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;

package/build/schema/engine/ref.mjs

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import * as Functions from './_functions.mjs';
 import * as Schema from '../types/index.mjs';
+import { Resolve } from '../resolve/index.mjs';
 import { CheckContext, ErrorContext } from './_context.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
@@ -21,32 +22,35 @@ function BuildRefFast(stack, context, target, value) {
     return Functions.CreateFunction(stack, context, target, value);
 }
 export function BuildRef(stack, context, schema, value) {
-    const target = stack.Ref(schema) ?? false;
+    const result = Resolve.Ref(stack, schema);
+    const target = result.schema ?? false;
     return context.UseUnevaluated()
-        ? BuildRefStandard(stack, context, target, value)
-        : BuildRefFast(stack, context, target, value);
+        ? BuildRefStandard(result.stack, context, target, value)
+        : BuildRefFast(result.stack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRef(stack, context, schema, value) {
-    const target = stack.Ref(schema) ?? false;
+    const result = Resolve.Ref(stack, schema);
+    const target = result.schema ?? false;
     const nextContext = new CheckContext();
-    const result = (Schema.IsSchema(target) && CheckSchema(stack, nextContext, target, value));
-    if (result)
+    const valid = (Schema.IsSchema(target) && CheckSchema(result.stack, nextContext, target, value));
+    if (valid)
         context.Merge([nextContext]);
-    return result;
+    return valid;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.Ref(schema) ?? false;
+export function ErrorRef(stack, context, schemaPath, instancePath, schema, value) {
+    const result = Resolve.Ref(stack, schema);
+    const target = result.schema ?? false;
     const nextContext = new ErrorContext();
-    const result = (Schema.IsSchema(target) && ErrorSchema(stack, nextContext, '#', instancePath, target, value));
-    if (result)
+    const valid = (Schema.IsSchema(target) && ErrorSchema(result.stack, nextContext, schemaPath, instancePath, target, value));
+    if (valid)
         context.Merge([nextContext]);
-    if (!result)
-        nextContext.GetErrors().forEach(error => context.AddError(error));
-    return result;
+    if (!valid)
+        context.AddErrors(nextContext.GetErrors());
+    return valid;
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRequired(_stack: Stack, _context: BuildContext, schema: Schema.XRequired, value: string): string;
-export declare function CheckRequired(_stack: Stack, _context: CheckContext, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorRequired(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildRequired(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XRequired, value: string): string;
+export declare function CheckRequired(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorRequired(_stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/required.mjs

@@ -23,10 +23,6 @@ export function ErrorRequired(_stack, context, schemaPath, instancePath, schema,
             requiredProperties.push(key);
         return hasKey;
     });
-    return isRequired || context.AddError({
-        keyword: 'required',
-        schemaPath,
-        instancePath,
-        params: { requiredProperties }
-    });
+    return isRequired ||
+        context.AddError('required', schemaPath, instancePath, { requiredProperties });
 }

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

@@ -1,9 +1,9 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildSchemaPushStack(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
-export declare function BuildSchema(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
-export declare function CheckSchemaPushStack(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
-export declare function CheckSchema(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
-export declare function ErrorSchemaPushStack(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;
-export declare function ErrorSchema(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;
+import * as Stack from './_stack.mjs';
+export declare function BuildSchemaPushStack(stack: Stack.XStack, context: BuildContext, schema: Schema.XSchema, value: string): string;
+export declare function BuildSchema(stack: Stack.XStack, context: BuildContext, schema: Schema.XSchema, value: string): string;
+export declare function CheckSchemaPushStack(stack: Stack.XStack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
+export declare function CheckSchema(stack: Stack.XStack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
+export declare function ErrorSchemaPushStack(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;
+export declare function ErrorSchema(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;