pi-proactive 0.2.0-beta.2 → 0.2.0-beta.3

package/node_modules/typebox/build/schema/engine/items.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -1,8 +1,7 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import * as Unique from './_unique.mjs';
-import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
 // ItemsSized
 // ------------------------------------------------------------------
@@ -45,16 +44,14 @@ function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value
 // ------------------------------------------------------------------
 function BuildItemsUnsizedStandard(stack, context, schema, value) {
     const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
-    const [item] = [Unique.CreateUnique()];
-    const isSchema = BuildSchemaPushStack(stack, context, schema.items, item);
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
     const addIndex = context.AddIndex('index');
-    return E.Every(value, E.Constant(offset), [item, 'index'], E.And(isSchema, addIndex));
+    return E.Every(value, E.Constant(offset), ['element', 'index'], E.And(isSchema, addIndex));
 }
 function BuildItemsUnsizedFast(stack, context, schema, value) {
     const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
-    const [item] = [Unique.CreateUnique()];
-    const isSchema = BuildSchemaPushStack(stack, context, schema.items, item);
-    return E.Every(value, E.Constant(offset), [item, 'index'], isSchema);
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
+    return E.Every(value, E.Constant(offset), ['element', 'index'], isSchema);
 }
 function BuildItemsUnsized(stack, context, schema, value) {
     return context.UseUnevaluated()

package/node_modules/typebox/build/schema/engine/maxContains.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import * as Unique from './_unique.mjs';
+import { Unique } from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -15,7 +15,7 @@ function IsValid(schema) {
 export function BuildMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const [item] = [Unique.CreateUnique()];
+    const [item] = [Unique()];
     const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.IsLessEqualThan(count, E.Constant(schema.maxContains));
 }
@@ -33,6 +33,10 @@ 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('contains', schemaPath, instancePath, { minContains, maxContains: schema.maxContains });
+    return CheckMaxContains(stack, context, schema, value) || context.AddError({
+        keyword: 'contains',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -16,6 +16,10 @@ 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('maxItems', schemaPath, instancePath, { limit: schema.maxItems });
+    return CheckMaxItems(stack, context, schema, value) || context.AddError({
+        keyword: 'maxItems',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -16,6 +16,10 @@ 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('maxLength', schemaPath, instancePath, { limit: schema.maxLength });
+    return CheckMaxLength(stack, context, schema, value) || context.AddError({
+        keyword: 'maxLength',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -16,6 +16,10 @@ 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('maxProperties', schemaPath, instancePath, { limit: schema.maxProperties });
+    return CheckMaxProperties(stack, context, schema, value) || context.AddError({
+        keyword: 'maxProperties',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -16,6 +16,10 @@ 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('maximum', schemaPath, instancePath, { comparison: '<=', limit: schema.maximum });
+    return CheckMaximum(stack, context, schema, value) || context.AddError({
+        keyword: 'maximum',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import * as Unique from './_unique.mjs';
+import { Unique } from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -13,12 +13,12 @@ function IsValid(schema) {
 // Build
 // ------------------------------------------------------------------
 function BuildMinContainsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
+    const [item, index] = [Unique(), Unique()];
     const count = E.Counted(value, [item, index], E.And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index)));
     return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
 }
 function BuildMinContainsFast(stack, context, schema, value) {
-    const [item] = [Unique.CreateUnique()];
+    const [item] = [Unique()];
     const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
 }
@@ -42,6 +42,10 @@ 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('contains', schemaPath, instancePath, { minContains: schema.minContains });
+    return CheckMinContains(stack, context, schema, value) || context.AddError({
+        keyword: 'contains',
+        schemaPath,
+        instancePath,
+        params: { minContains: schema.minContains }
+    });
 }

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

@@ -1,6 +1,6 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { 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;
+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;

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

@@ -16,6 +16,10 @@ 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('minItems', schemaPath, instancePath, { limit: schema.minItems });
+    return CheckMinItems(stack, context, schema, value) || context.AddError({
+        keyword: 'minItems',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -16,6 +16,10 @@ 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('minLength', schemaPath, instancePath, { limit: schema.minLength });
+    return CheckMinLength(stack, context, schema, value) || context.AddError({
+        keyword: 'minLength',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -16,6 +16,10 @@ 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('minProperties', schemaPath, instancePath, { limit: schema.minProperties });
+    return CheckMinProperties(stack, context, schema, value) || context.AddError({
+        keyword: 'minProperties',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -16,6 +16,10 @@ 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('minimum', schemaPath, instancePath, { comparison: '>=', limit: schema.minimum });
+    return CheckMinimum(stack, context, schema, value) || context.AddError({
+        keyword: 'minimum',
+        schemaPath,
+        instancePath,
+        params: { comparison: '>=', limit: schema.minimum }
+    });
 }

package/node_modules/typebox/build/schema/engine/multipleOf.d.mts

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -16,6 +16,10 @@ 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('multipleOf', schemaPath, instancePath, { multipleOf: schema.multipleOf });
+    return CheckMultipleOf(stack, context, schema, value) || context.AddError({
+        keyword: 'multipleOf',
+        schemaPath,
+        instancePath,
+        params: { multipleOf: schema.multipleOf }
+    });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

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

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -1,9 +1,9 @@
 // deno-fmt-ignore-file
-import { Reducer } from './_reducer.mjs';
-import * as Unique from './_unique.mjs';
 import { CheckContext, ErrorContext } from './_context.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.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';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -11,7 +11,7 @@ function BuildOneOfStandard(stack, context, schema, value) {
     return Reducer(stack, context, schema.oneOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(1)));
 }
 function BuildOneOfFast(stack, context, schema, value) {
-    const [result] = [Unique.CreateUnique()];
+    const [result] = [Unique()];
     const results = E.ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(stack, context, schema, value)));
     const count = E.Counted(results, [result, '_'], E.IsEqual(result, E.Constant(true)));
     return E.IsEqual(count, E.Constant(1));
@@ -49,6 +49,11 @@ 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 => context.AddErrors(failed.GetErrors()));
-    return isOneOf || context.AddError('oneOf', schemaPath, instancePath, { passingSchemas });
+        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
+    return isOneOf || context.AddError({
+        keyword: 'oneOf',
+        schemaPath,
+        instancePath,
+        params: { passingSchemas },
+    });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

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

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

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

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

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

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;