@openclaw/whatsapp 2026.9.3 → 2026.9.5

package/node_modules/typebox/build/schema/engine/contains.mjs

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

package/node_modules/typebox/build/schema/engine/dependencies.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 BuildDependencies(stack: Stack, context: BuildContext, schema: Schema.XDependencies, value: string): string;
-export declare function CheckDependencies(stack: Stack, context: CheckContext, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependencies(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildDependencies(stack: Stack.XStack, context: BuildContext, schema: Schema.XDependencies, value: string): string;
+export declare function CheckDependencies(stack: Stack.XStack, context: CheckContext, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependencies(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/typebox/build/schema/engine/dependencies.mjs

@@ -34,12 +34,9 @@ export function ErrorDependencies(stack, context, schemaPath, instancePath, sche
     const isEvery = G.EveryAll(G.Entries(schema.dependencies), 0, ([key, schema]) => {
         const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
         return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
-            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
-                keyword: 'dependencies',
-                schemaPath,
-                instancePath,
-                params: { property: key, dependencies: schema },
-            })) : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
+            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) ||
+                context.AddError('dependencies', schemaPath, instancePath, { property: key, dependencies: schema }))
+            : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
     });
     return isLength || isEvery;
 }

package/node_modules/typebox/build/schema/engine/dependentRequired.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 BuildDependentRequired(_stack: Stack, _context: BuildContext, schema: Schema.XDependentRequired, value: string): string;
-export declare function CheckDependentRequired(_stack: Stack, _context: CheckContext, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentRequired(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildDependentRequired(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XDependentRequired, value: string): string;
+export declare function CheckDependentRequired(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependentRequired(_stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/typebox/build/schema/engine/dependentRequired.mjs

@@ -29,12 +29,8 @@ export function CheckDependentRequired(_stack, _context, schema, value) {
 export function ErrorDependentRequired(_stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
-        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
-            keyword: 'dependentRequired',
-            schemaPath,
-            instancePath,
-            params: { property: key, dependencies: keys },
-        }));
+        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) ||
+            context.AddError('dependentRequired', schemaPath, instancePath, { property: key, dependencies: keys }));
     });
     return isLength || isEveryEntry;
 }

package/node_modules/typebox/build/schema/engine/dependentSchemas.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 BuildDependentSchemas(stack: Stack, context: BuildContext, schema: Schema.XDependentSchemas, value: string): string;
-export declare function CheckDependentSchemas(stack: Stack, context: CheckContext, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentSchemas(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildDependentSchemas(stack: Stack.XStack, context: BuildContext, schema: Schema.XDependentSchemas, value: string): string;
+export declare function CheckDependentSchemas(stack: Stack.XStack, context: CheckContext, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependentSchemas(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/typebox/build/schema/engine/dynamicRef.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 BuildDynamicRef(stack: Stack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
-export declare function CheckDynamicRef(stack: Stack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
-export declare function ErrorDynamicRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;
+export declare function BuildDynamicRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
+export declare function CheckDynamicRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
+export declare function ErrorDynamicRef(stack: Stack.XStack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;

package/node_modules/typebox/build/schema/engine/dynamicRef.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 BuildDynamicRef(stack, context, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return Functions.CreateFunction(stack, context, target, value);
+    const target = Resolve.DynamicRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return Functions.CreateFunction(nextStack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckDynamicRef(stack, context, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
+    const target = Resolve.DynamicRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return (Schema.IsSchema(target) && CheckSchema(nextStack, context, target, value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorDynamicRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', instancePath, target, value));
+    const target = Resolve.DynamicRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, '#', instancePath, target, value));
 }

package/node_modules/typebox/build/schema/engine/enum.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 BuildEnum(_stack: Stack, _context: BuildContext, schema: Schema.XEnum, value: string): string;
-export declare function CheckEnum(_stack: Stack, _context: CheckContext, schema: Schema.XEnum, value: unknown): boolean;
-export declare function ErrorEnum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XEnum, value: unknown): boolean;
+export declare function BuildEnum(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XEnum, value: string): string;
+export declare function CheckEnum(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XEnum, value: unknown): boolean;
+export declare function ErrorEnum(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XEnum, value: unknown): boolean;

package/node_modules/typebox/build/schema/engine/enum.mjs

@@ -24,10 +24,6 @@ export function CheckEnum(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorEnum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckEnum(stack, context, schema, value) || context.AddError({
-        keyword: 'enum',
-        schemaPath,
-        instancePath,
-        params: { allowedValues: schema.enum }
-    });
+    return CheckEnum(stack, context, schema, value) ||
+        context.AddError('enum', schemaPath, instancePath, { allowedValues: schema.enum });
 }

package/node_modules/typebox/build/schema/engine/exclusiveMaximum.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 BuildExclusiveMaximum(_stack: Stack, _context: BuildContext, schema: Schema.XExclusiveMaximum, value: string): string;
-export declare function CheckExclusiveMaximum(_stack: Stack, _context: CheckContext, schema: Schema.XExclusiveMaximum, value: number | bigint): boolean;
-export declare function ErrorExclusiveMaximum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XExclusiveMaximum, value: number | bigint): boolean;
+export declare function BuildExclusiveMaximum(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XExclusiveMaximum, value: string): string;
+export declare function CheckExclusiveMaximum(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XExclusiveMaximum, value: number | bigint): boolean;
+export declare function ErrorExclusiveMaximum(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XExclusiveMaximum, value: number | bigint): boolean;

package/node_modules/typebox/build/schema/engine/exclusiveMaximum.mjs

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

package/node_modules/typebox/build/schema/engine/exclusiveMinimum.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 BuildExclusiveMinimum(_stack: Stack, _context: BuildContext, schema: Schema.XExclusiveMinimum, value: string): string;
-export declare function CheckExclusiveMinimum(_stack: Stack, _context: CheckContext, schema: Schema.XExclusiveMinimum, value: number | bigint): boolean;
-export declare function ErrorExclusiveMinimum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XExclusiveMinimum, value: number | bigint): boolean;
+export declare function BuildExclusiveMinimum(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XExclusiveMinimum, value: string): string;
+export declare function CheckExclusiveMinimum(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XExclusiveMinimum, value: number | bigint): boolean;
+export declare function ErrorExclusiveMinimum(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XExclusiveMinimum, value: number | bigint): boolean;

package/node_modules/typebox/build/schema/engine/exclusiveMinimum.mjs

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

package/node_modules/typebox/build/schema/engine/format.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 BuildFormat(_stack: Stack, _context: BuildContext, schema: Schema.XFormat, value: string): string;
-export declare function CheckFormat(_stack: Stack, _context: CheckContext, schema: Schema.XFormat, value: string): boolean;
-export declare function ErrorFormat(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XFormat, value: string): boolean;
+export declare function BuildFormat(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XFormat, value: string): string;
+export declare function CheckFormat(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XFormat, value: string): boolean;
+export declare function ErrorFormat(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XFormat, value: string): boolean;

package/node_modules/typebox/build/schema/engine/format.mjs

@@ -17,10 +17,6 @@ export function CheckFormat(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorFormat(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckFormat(stack, context, schema, value) || context.AddError({
-        keyword: 'format',
-        schemaPath,
-        instancePath,
-        params: { format: schema.format },
-    });
+    return CheckFormat(stack, context, schema, value) ||
+        context.AddError('format', schemaPath, instancePath, { format: schema.format });
 }

package/node_modules/typebox/build/schema/engine/if.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 BuildIf(stack: Stack, context: BuildContext, schema: Schema.XIf, value: string): string;
-export declare function CheckIf(stack: Stack, context: CheckContext, schema: Schema.XIf, value: unknown): boolean;
-export declare function ErrorIf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XIf, value: unknown): boolean;
+export declare function BuildIf(stack: Stack.XStack, context: BuildContext, schema: Schema.XIf, value: string): string;
+export declare function CheckIf(stack: Stack.XStack, context: CheckContext, schema: Schema.XIf, value: unknown): boolean;
+export declare function ErrorIf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XIf, value: unknown): boolean;

package/node_modules/typebox/build/schema/engine/if.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
+import { ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -27,20 +27,12 @@ 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',
-            schemaPath,
-            instancePath,
-            params: { failingKeyword: 'then' },
-        })
-        : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
-            keyword: 'if',
-            schemaPath,
-            instancePath,
-            params: { failingKeyword: 'else' },
-        });
+        ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) ||
+            context.AddError('if', schemaPath, instancePath, { failingKeyword: 'then' })
+        : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) ||
+            context.AddError('if', schemaPath, instancePath, { failingKeyword: 'else' });
     if (isIf)
         context.Merge([trueContext]);
     return isIf;

package/node_modules/typebox/build/schema/engine/items.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 BuildItems(stack: Stack, context: BuildContext, schema: Schema.XItems, value: string): string;
-export declare function CheckItems(stack: Stack, context: CheckContext, schema: Schema.XItems, value: unknown[]): boolean;
-export declare function ErrorItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XItems, value: unknown[]): boolean;
+export declare function BuildItems(stack: Stack.XStack, context: BuildContext, schema: Schema.XItems, value: string): string;
+export declare function CheckItems(stack: Stack.XStack, context: CheckContext, schema: Schema.XItems, value: unknown[]): boolean;
+export declare function ErrorItems(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XItems, value: unknown[]): boolean;

package/node_modules/typebox/build/schema/engine/items.mjs

@@ -1,7 +1,7 @@
 // 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 { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // ItemsSized
 // ------------------------------------------------------------------

package/node_modules/typebox/build/schema/engine/maxContains.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 BuildMaxContains(stack: Stack, context: BuildContext, schema: Schema.XMaxContains, value: string): string;
-export declare function CheckMaxContains(stack: Stack, context: CheckContext, schema: Schema.XMaxContains, value: unknown[]): boolean;
-export declare function ErrorMaxContains(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxContains, value: unknown[]): boolean;
+export declare function BuildMaxContains(stack: Stack.XStack, context: BuildContext, schema: Schema.XMaxContains, value: string): string;
+export declare function CheckMaxContains(stack: Stack.XStack, context: CheckContext, schema: Schema.XMaxContains, value: unknown[]): boolean;
+export declare function ErrorMaxContains(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxContains, value: unknown[]): boolean;

package/node_modules/typebox/build/schema/engine/maxContains.mjs

@@ -33,10 +33,6 @@ export function CheckMaxContains(stack, context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorMaxContains(stack, context, schemaPath, instancePath, schema, value) {
     const minContains = Schema.IsMinContains(schema) ? schema.minContains : 1;
-    return CheckMaxContains(stack, context, schema, value) || context.AddError({
-        keyword: 'contains',
-        schemaPath,
-        instancePath,
-        params: { minContains, maxContains: schema.maxContains },
-    });
+    return CheckMaxContains(stack, context, schema, value) ||
+        context.AddError('contains', schemaPath, instancePath, { minContains, maxContains: schema.maxContains });
 }

package/node_modules/typebox/build/schema/engine/maxItems.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 BuildMaxItems(_stack: Stack, _context: BuildContext, schema: Schema.XMaxItems, value: string): string;
-export declare function CheckMaxItems(_stack: Stack, _context: CheckContext, schema: Schema.XMaxItems, value: unknown[]): boolean;
-export declare function ErrorMaxItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxItems, value: unknown[]): boolean;
+export declare function BuildMaxItems(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMaxItems, value: string): string;
+export declare function CheckMaxItems(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMaxItems, value: unknown[]): boolean;
+export declare function ErrorMaxItems(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxItems, value: unknown[]): boolean;

package/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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/node_modules/typebox/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 });
 }