npm - @openclaw/firecrawl-plugin - Versions diffs - 2026.9.4 → 2026.9.6 - Mend

@openclaw/firecrawl-plugin 2026.9.4 → 2026.9.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (676) hide show

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 });
 }