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

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

@@ -1,8 +1,7 @@
 // deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import * as Unique from './_unique.mjs';
-import * as Externals from './_externals.mjs';
-import * as Pathing from './_pathing.mjs';
+import * as S from '../types/index.mjs';
+import * as V from './_externals.mjs';
+import { Unique } from './_unique.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
@@ -35,41 +34,43 @@ function GetPropertyKeyAsPattern(key) {
 }
 function GetPropertiesPattern(schema) {
     const patterns = [];
-    if (Schema.IsPatternProperties(schema))
+    if (S.IsPatternProperties(schema))
         patterns.push(...G.Keys(schema.patternProperties));
-    if (Schema.IsProperties(schema))
+    if (S.IsProperties(schema))
         patterns.push(...G.Keys(schema.properties).map(GetPropertyKeyAsPattern));
     return G.IsEqual(patterns.length, 0) ? '(?!)' : `(${patterns.join('|')})`;
 }
 // ------------------------------------------------------------------
-// BuildAdditionalPropertiesFast (AdditionalProperties False)
+// BuildAdditionalPropertiesFast
 //
-// - AdditionalProperties is explicitly set to false,
-// - The schema uses only Properties (no PatternProperties),
-// - Required contains exactly the keys in Properties.
+// Optimized logic for schemas with `additionalProperties: false`.
+//
+// This fast-path applies only when:
+// - `additionalProperties` is explicitly set to false,
+// - the schema uses only `properties` (no `patternProperties`),
+// - and all defined properties are required (i.e., no optional keys).
+//
+// This constraint is common when enforcing strict object shapes
+// with only known, fixed keys. When all these conditions are met,
+// we can generate a simplified and efficient runtime check.
 //
 // ------------------------------------------------------------------
-function HasExactRequiredProperties(schema) {
-    const keys = G.Keys(schema.properties);
-    return G.IsEqual(keys.length, schema.required.length)
-        && G.Every(keys, 0, (key) => schema.required.includes(key));
-}
-function CanAdditionalPropertiesFast(_context, schema, _value) {
-    return Schema.IsRequired(schema)
-        && Schema.IsProperties(schema)
-        && !Schema.IsPatternProperties(schema)
+export function CanAdditionalPropertiesFast(_context, schema, _value) {
+    return S.IsRequired(schema)
+        && S.IsProperties(schema)
+        && !S.IsPatternProperties(schema)
         && G.IsEqual(schema.additionalProperties, false)
-        && HasExactRequiredProperties(schema);
+        && G.IsEqual(G.Keys(schema.properties).length, schema.required.length);
 }
-function BuildAdditionalPropertiesFast(_context, schema, value) {
+export function BuildAdditionalPropertiesFast(_context, schema, value) {
     return E.IsEqual(E.Member(E.Call(E.Member('Object', 'getOwnPropertyNames'), [value]), 'length'), E.Constant(schema.required.length));
 }
 // ------------------------------------------------------------------
 // BuildAdditionalPropertiesStandard
 // ------------------------------------------------------------------
-function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
-    const [key, _index] = [Unique.CreateUnique(), Unique.CreateUnique()];
-    const regexp = Externals.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
+export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
+    const [key, _index] = [Unique(), Unique()];
+    const regexp = V.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
     const isKey = E.Call(E.Member(regexp, 'test'), [key]);
     const addKey = context.AddKey(key);
@@ -106,13 +107,17 @@ export function ErrorAdditionalProperties(stack, context, schemaPath, instancePa
     const additionalProperties = [];
     const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;
-        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
+        const nextInstancePath = `${instancePath}/${key}`;
         const isAdditionalProperty = regexp.test(key) ||
             (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
         if (!isAdditionalProperty)
             additionalProperties.push(key);
         return isAdditionalProperty;
     });
-    return isAdditionalProperties ||
-        context.AddError('additionalProperties', schemaPath, instancePath, { additionalProperties });
+    return isAdditionalProperties || context.AddError({
+        keyword: 'additionalProperties',
+        schemaPath,
+        instancePath,
+        params: { additionalProperties },
+    });
 }

package/node_modules/typebox/build/schema/engine/allOf.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 BuildAllOf(stack: Stack.XStack, context: BuildContext, schema: Schema.XAllOf, value: string): string;
-export declare function CheckAllOf(stack: Stack.XStack, context: CheckContext, schema: Schema.XAllOf, value: unknown): boolean;
-export declare function ErrorAllOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAllOf, value: unknown): boolean;
+export declare function BuildAllOf(stack: Stack, context: BuildContext, schema: Schema.XAllOf, value: string): string;
+export declare function CheckAllOf(stack: Stack, context: CheckContext, schema: Schema.XAllOf, value: unknown): boolean;
+export declare function ErrorAllOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAllOf, value: unknown): boolean;

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

@@ -42,6 +42,6 @@ export function ErrorAllOf(stack, context, schemaPath, instancePath, schema, val
     }, []);
     const isAllOf = G.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
     if (!isAllOf)
-        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
+        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
     return isAllOf;
 }

package/node_modules/typebox/build/schema/engine/anyOf.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 BuildAnyOf(stack: Stack.XStack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
-export declare function CheckAnyOf(stack: Stack.XStack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
-export declare function ErrorAnyOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;
+export declare function BuildAnyOf(stack: Stack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
+export declare function CheckAnyOf(stack: Stack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
+export declare function ErrorAnyOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;

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

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { Reducer } from './_reducer.mjs';
 import { CheckContext, ErrorContext } from './_context.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { Reducer } from './_reducer.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -42,6 +42,11 @@ export function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, val
     }, []);
     const isAnyOf = G.IsGreaterThan(results.length, 0) && context.Merge(results);
     if (!isAnyOf)
-        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
-    return isAnyOf || context.AddError('anyOf', schemaPath, instancePath, {});
+        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
+    return isAnyOf || context.AddError({
+        keyword: 'anyOf',
+        schemaPath,
+        instancePath,
+        params: {}
+    });
 }

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

@@ -1,5 +1,5 @@
-import * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildSchemaBoolean(_stack: Stack.XStack, _context: BuildContext, schema: boolean, _value: string): string;
-export declare function CheckSchemaBoolean(_stack: Stack.XStack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
-export declare function ErrorSchemaBoolean(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;
+export declare function BuildSchemaBoolean(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
+export declare function CheckSchemaBoolean(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
+export declare function ErrorSchemaBoolean(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;

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

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

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

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

@@ -21,6 +21,10 @@ export function CheckConst(_stack, _context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function ErrorConst(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckConst(stack, context, schema, value) ||
-        context.AddError('const', schemaPath, instancePath, { allowedValue: schema.const });
+    return CheckConst(stack, context, schema, value) || context.AddError({
+        keyword: 'const',
+        schemaPath,
+        instancePath,
+        params: { allowedValue: schema.const },
+    });
 }

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

package/node_modules/typebox/build/schema/engine/contains.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 { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -13,13 +13,13 @@ function IsValid(schema) {
 // Build
 // ------------------------------------------------------------------
 function BuildContainsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
+    const [item, index] = [Unique(), Unique()];
     const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
     const isSome = E.SomeAll(value, [item, index], E.And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index)));
     return E.And(isLength, isSome);
 }
 function BuildContainsFast(stack, context, schema, value) {
-    const [item] = [Unique.CreateUnique()];
+    const [item] = [Unique()];
     const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
     const isSome = E.Some(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.And(isLength, isSome);
@@ -45,6 +45,10 @@ 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('contains', schemaPath, instancePath, { minContains: 1 });
+    return CheckContains(stack, context, schema, value) || context.AddError({
+        keyword: 'contains',
+        schemaPath,
+        instancePath,
+        params: { minContains: 1 },
+    });
 }

package/node_modules/typebox/build/schema/engine/dependencies.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 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;
+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;

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

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import * as Pathing from './_pathing.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -33,11 +32,14 @@ export function CheckDependencies(stack, context, schema, value) {
 export function ErrorDependencies(stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.EveryAll(G.Entries(schema.dependencies), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/dependencies/${Pathing.EncodeFragment(key)}`;
+        const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
         return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
-            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) ||
-                context.AddError('dependencies', schemaPath, instancePath, { property: key, dependencies: schema }))
-            : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
+            ? 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));
     });
     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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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

@@ -29,8 +29,12 @@ 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('dependentRequired', schemaPath, instancePath, { property: key, dependencies: 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 isLength || isEveryEntry;
 }

package/node_modules/typebox/build/schema/engine/dependentSchemas.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 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;
+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;

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

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import * as Pathing from './_pathing.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -31,7 +30,7 @@ export function CheckDependentSchemas(stack, context, schema, value) {
 export function ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.EveryAll(G.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/dependentSchemas/${Pathing.EncodeFragment(key)}`;
+        const nextSchemaPath = `${schemaPath}/dependentSchemas/${key}`;
         return !G.HasPropertyKey(value, key) ||
             ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value);
     });

package/node_modules/typebox/build/schema/engine/dynamicRef.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 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;
+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;

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

@@ -1,29 +1,25 @@
 // deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
 import * as Functions from './_functions.mjs';
-import { Resolve } from '../resolve/index.mjs';
+import * as Schema from '../types/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildDynamicRef(stack, context, schema, value) {
-    const target = Resolve.DynamicRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return Functions.CreateFunction(nextStack, context, target, value);
+    const target = stack.DynamicRef(schema) ?? false;
+    return Functions.CreateFunction(stack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckDynamicRef(stack, context, schema, value) {
-    const target = Resolve.DynamicRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return (Schema.IsSchema(target) && CheckSchema(nextStack, context, target, value));
+    const target = stack.DynamicRef(schema) ?? false;
+    return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorDynamicRef(stack, context, schemaPath, instancePath, schema, value) {
-    const target = Resolve.DynamicRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value));
+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));
 }

package/node_modules/typebox/build/schema/engine/enum.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 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;
+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;

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

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

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

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

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

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

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

@@ -1,18 +1,11 @@
 // deno-fmt-ignore-file
-import * as Externals from './_externals.mjs';
 import { Format } from '../../format/index.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Build (Remote)
-// ------------------------------------------------------------------
-// export function BuildFormat(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XFormat, value: string): string {
-//   return E.Call(E.Member('Format', 'Test'), [E.Constant(schema.format), value])
-// }
-// ------------------------------------------------------------------
-// Build (Inline)
+// Build
 // ------------------------------------------------------------------
 export function BuildFormat(_stack, _context, schema, value) {
-    return Format.Has(schema.format) ? E.Call(Externals.CreateVariable(Format.Get(schema.format)), [value]) : E.Constant(true);
+    return E.Call(E.Member('Format', 'Test'), [E.Constant(schema.format), value]);
 }
 // ------------------------------------------------------------------
 // Check
@@ -24,6 +17,10 @@ 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('format', schemaPath, instancePath, { format: schema.format });
+    return CheckFormat(stack, context, schema, value) || context.AddError({
+        keyword: 'format',
+        schemaPath,
+        instancePath,
+        params: { 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 * as Stack from './_stack.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-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;
+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;

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 { ErrorContext } from './_context.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -29,10 +29,18 @@ export function ErrorIf(stack, context, schemaPath, instancePath, schema, value)
     const elseSchema = Schema.IsElse(schema) ? schema.else : true;
     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('if', schemaPath, instancePath, { failingKeyword: 'then' })
-        : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) ||
-            context.AddError('if', schemaPath, instancePath, { failingKeyword: 'else' });
+        ? 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' },
+        });
     if (isIf)
         context.Merge([trueContext]);
     return isIf;

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

@@ -4,7 +4,6 @@ export * from './_functions.mjs';
 export * from './_reducer.mjs';
 export * from './_refine.mjs';
 export * from './_stack.mjs';
-export * from './_unique.mjs';
 export * from './additionalItems.mjs';
 export * from './additionalProperties.mjs';
 export * from './allOf.mjs';

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

@@ -7,7 +7,6 @@ export * from './_functions.mjs';
 export * from './_reducer.mjs';
 export * from './_refine.mjs';
 export * from './_stack.mjs';
-export * from './_unique.mjs';
 // ------------------------------------------------------------------
 // Schematics
 // ------------------------------------------------------------------