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

package/build/schema/engine/maxItems.mjs

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

package/build/schema/engine/maxLength.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 BuildMaxLength(_stack: Stack, _context: BuildContext, schema: Schema.XMaxLength, value: string): string;
-export declare function CheckMaxLength(_stack: Stack, _context: CheckContext, schema: Schema.XMaxLength, value: string): boolean;
-export declare function ErrorMaxLength(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxLength, value: string): boolean;
+export declare function BuildMaxLength(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMaxLength, value: string): string;
+export declare function CheckMaxLength(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMaxLength, value: string): boolean;
+export declare function ErrorMaxLength(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxLength, value: string): boolean;

package/build/schema/engine/maxLength.mjs

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

package/build/schema/engine/maxProperties.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 BuildMaxProperties(_stack: Stack, _context: BuildContext, schema: Schema.XMaxProperties, value: string): string;
-export declare function CheckMaxProperties(_stack: Stack, _context: CheckContext, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorMaxProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildMaxProperties(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMaxProperties, value: string): string;
+export declare function CheckMaxProperties(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorMaxProperties(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/maxProperties.mjs

@@ -16,10 +16,6 @@ export function CheckMaxProperties(_stack, _context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckMaxProperties(stack, context, schema, value) || context.AddError({
-        keyword: 'maxProperties',
-        schemaPath,
-        instancePath,
-        params: { limit: schema.maxProperties },
-    });
+    return CheckMaxProperties(stack, context, schema, value) ||
+        context.AddError('maxProperties', schemaPath, instancePath, { limit: schema.maxProperties });
 }

package/build/schema/engine/maximum.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 BuildMaximum(_stack: Stack, _context: BuildContext, schema: Schema.XMaximum, value: string): string;
-export declare function CheckMaximum(_stack: Stack, _context: CheckContext, schema: Schema.XMaximum, value: number | bigint): boolean;
-export declare function ErrorMaximum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaximum, value: number | bigint): boolean;
+export declare function BuildMaximum(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMaximum, value: string): string;
+export declare function CheckMaximum(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMaximum, value: number | bigint): boolean;
+export declare function ErrorMaximum(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaximum, value: number | bigint): boolean;

package/build/schema/engine/maximum.mjs

@@ -16,10 +16,6 @@ export function CheckMaximum(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorMaximum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckMaximum(stack, context, schema, value) || context.AddError({
-        keyword: 'maximum',
-        schemaPath,
-        instancePath,
-        params: { comparison: '<=', limit: schema.maximum }
-    });
+    return CheckMaximum(stack, context, schema, value) ||
+        context.AddError('maximum', schemaPath, instancePath, { comparison: '<=', limit: schema.maximum });
 }

package/build/schema/engine/minContains.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 BuildMinContains(stack: Stack, context: BuildContext, schema: Schema.XMinContains, value: string): string;
-export declare function CheckMinContains(stack: Stack, context: CheckContext, schema: Schema.XMinContains, value: unknown[]): boolean;
-export declare function ErrorMinContains(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinContains, value: unknown[]): boolean;
+export declare function BuildMinContains(stack: Stack.XStack, context: BuildContext, schema: Schema.XMinContains, value: string): string;
+export declare function CheckMinContains(stack: Stack.XStack, context: CheckContext, schema: Schema.XMinContains, value: unknown[]): boolean;
+export declare function ErrorMinContains(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinContains, value: unknown[]): boolean;

package/build/schema/engine/minContains.mjs

@@ -42,10 +42,6 @@ export function CheckMinContains(stack, context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorMinContains(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckMinContains(stack, context, schema, value) || context.AddError({
-        keyword: 'contains',
-        schemaPath,
-        instancePath,
-        params: { minContains: schema.minContains }
-    });
+    return CheckMinContains(stack, context, schema, value) ||
+        context.AddError('contains', schemaPath, instancePath, { minContains: schema.minContains });
 }

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

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

package/build/schema/engine/minItems.mjs

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

package/build/schema/engine/minLength.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 BuildMinLength(_stack: Stack, _context: BuildContext, schema: Schema.XMinLength, value: string): string;
-export declare function CheckMinLength(_stack: Stack, _context: CheckContext, schema: Schema.XMinLength, value: string): boolean;
-export declare function ErrorMinLength(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinLength, value: string): boolean;
+export declare function BuildMinLength(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMinLength, value: string): string;
+export declare function CheckMinLength(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMinLength, value: string): boolean;
+export declare function ErrorMinLength(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinLength, value: string): boolean;

package/build/schema/engine/minLength.mjs

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

package/build/schema/engine/minProperties.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 BuildMinProperties(_stack: Stack, _context: BuildContext, schema: Schema.XMinProperties, value: string): string;
-export declare function CheckMinProperties(_stack: Stack, _context: CheckContext, schema: Schema.XMinProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorMinProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildMinProperties(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMinProperties, value: string): string;
+export declare function CheckMinProperties(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMinProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorMinProperties(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/minProperties.mjs

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

package/build/schema/engine/minimum.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 BuildMinimum(_stack: Stack, _context: BuildContext, schema: Schema.XMinimum, value: string): string;
-export declare function CheckMinimum(_stack: Stack, _context: CheckContext, schema: Schema.XMinimum, value: number | bigint): boolean;
-export declare function ErrorMinimum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinimum, value: number | bigint): boolean;
+export declare function BuildMinimum(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMinimum, value: string): string;
+export declare function CheckMinimum(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMinimum, value: number | bigint): boolean;
+export declare function ErrorMinimum(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinimum, value: number | bigint): boolean;

package/build/schema/engine/minimum.mjs

@@ -16,10 +16,6 @@ export function CheckMinimum(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorMinimum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckMinimum(stack, context, schema, value) || context.AddError({
-        keyword: 'minimum',
-        schemaPath,
-        instancePath,
-        params: { comparison: '>=', limit: schema.minimum }
-    });
+    return CheckMinimum(stack, context, schema, value) ||
+        context.AddError('minimum', schemaPath, instancePath, { comparison: '>=', limit: schema.minimum });
 }

package/build/schema/engine/multipleOf.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 BuildMultipleOf(_stack: Stack, _context: BuildContext, schema: Schema.XMultipleOf, value: string): string;
-export declare function CheckMultipleOf(_stack: Stack, _context: CheckContext, schema: Schema.XMultipleOf, value: number | bigint): boolean;
-export declare function ErrorMultipleOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMultipleOf, value: number | bigint): boolean;
+export declare function BuildMultipleOf(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMultipleOf, value: string): string;
+export declare function CheckMultipleOf(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMultipleOf, value: number | bigint): boolean;
+export declare function ErrorMultipleOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMultipleOf, value: number | bigint): boolean;

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, AccumulatedErrorContext } 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
 // ------------------------------------------------------------------
@@ -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)
@@ -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

@@ -2,8 +2,8 @@
 import * as Externals from './_externals.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
 // ------------------------------------------------------------------

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,8 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.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
 // ------------------------------------------------------------------

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,8 +1,7 @@
 // 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';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -24,16 +23,11 @@ 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;
     });
-    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));
+    const target = Resolve.RecursiveRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, '#', 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;