@openclaw/discord 2026.9.6 → 2026.9.7

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

@@ -0,0 +1,11 @@
+// ------------------------------------------------------------------
+// EncodeFragment
+//
+// We use this function to encode instancePath and schemaPath path
+// fragments for errors. We need this encoding such that callers
+// can use Pointer to deref error targets. We should consider adding
+// this to the Pointer module as Pointer.Encode(...) (review)
+// ------------------------------------------------------------------
+export function EncodeFragment(fragment) {
+    return fragment.replace(/~/g, '~0').replace(/\//g, '~1');
+}

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

@@ -4,9 +4,18 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
+function BuildRefineMultiple(_stack, _context, schema, value) {
+    const external = Externals.CreateVariable(schema['~refine']);
+    return E.Every(external, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
+}
+function BuildRefineSingle(_stack, _context, schema, value) {
+    const external = Externals.CreateVariable(schema['~refine'][0]);
+    return E.Call(E.Member(external, 'check'), [value]);
+}
 export function BuildRefine(_stack, _context, schema, value) {
-    const refinements = Externals.CreateVariable(schema['~refine'].map((refinement) => refinement));
-    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
+    return G.IsEqual(schema['~refine'].length, 1)
+        ? BuildRefineSingle(_stack, _context, schema, value)
+        : BuildRefineMultiple(_stack, _context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
@@ -19,8 +28,7 @@ export function CheckRefine(_stack, _context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
-        return refinement.check(value) || context.AddError('~refine', schemaPath, instancePath, {
-            index, message: refinement.error(value)
-        });
+        return refinement.check(value) ||
+            context.AddError('~refine', schemaPath, instancePath, { index, message: refinement.error(value) });
     });
 }

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

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
 import * as Externals from './_externals.mjs';
+import * as Pathing from './_pathing.mjs';
 import { Unique } from './_unique.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
@@ -107,7 +108,7 @@ 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}/${key}`;
+        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
         const isAdditionalProperty = regexp.test(key) ||
             (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
         if (!isAdditionalProperty)

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

@@ -1,4 +1,5 @@
 // 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';
 // ------------------------------------------------------------------
@@ -32,7 +33,7 @@ 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/${key}`;
+        const nextSchemaPath = `${schemaPath}/dependencies/${Pathing.EncodeFragment(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 }))

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

@@ -1,4 +1,5 @@
 // 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';
 // ------------------------------------------------------------------
@@ -30,7 +31,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/${key}`;
+        const nextSchemaPath = `${schemaPath}/dependentSchemas/${Pathing.EncodeFragment(key)}`;
         return !G.HasPropertyKey(value, key) ||
             ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value);
     });

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

@@ -3,4 +3,4 @@ import * as 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 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

@@ -22,8 +22,8 @@ export function CheckDynamicRef(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorDynamicRef(stack, context, _schemaPath, instancePath, schema, value) {
+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, '#', instancePath, target, value));
+    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value));
 }

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

@@ -1,11 +1,18 @@
 // 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
+// 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)
 // ------------------------------------------------------------------
 export function BuildFormat(_stack, _context, schema, value) {
-    return E.Call(E.Member('Format', 'Test'), [E.Constant(schema.format), value]);
+    return Format.Has(schema.format) ? E.Call(Externals.CreateVariable(Format.Get(schema.format)), [value]) : E.Constant(true);
 }
 // ------------------------------------------------------------------
 // Check

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

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
 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';
@@ -34,10 +35,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/${pattern}`;
+        const nextSchemaPath = `${schemaPath}/patternProperties/${Pathing.EncodeFragment(pattern)}`;
         const regexp = UnicodeRegExp(pattern);
         return G.EveryAll(G.Entries(value), 0, ([key, value]) => {
-            const nextInstancePath = `${instancePath}/${key}`;
+            const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(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/properties.mjs

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
+import * as Pathing from './_pathing.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 import { InexactOptionalCheck, InexactOptionalBuild, IsExactOptional } from './_exact_optional.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
@@ -63,8 +64,8 @@ export function CheckProperties(stack, context, schema, value) {
 export function ErrorProperties(stack, context, schemaPath, instancePath, schema, value) {
     const required = Schema.IsRequired(schema) ? schema.required : [];
     const isProperties = G.EveryAll(G.Entries(schema.properties), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/properties/${key}`;
-        const nextInstancePath = `${instancePath}/${key}`;
+        const nextSchemaPath = `${schemaPath}/properties/${Pathing.EncodeFragment(key)}`;
+        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
         // Defer error generation for IsExactOptional
         const isProperty = () => (!G.HasPropertyKey(value, key) || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key)));
         return IsExactOptional(required, key)

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

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import * as Pathing from './_pathing.mjs';
 import { Unique } from './_unique.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
@@ -21,7 +22,7 @@ export function CheckPropertyNames(stack, context, schema, value) {
 export function ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, value) {
     const propertyNames = [];
     const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key, _index) => {
-        const nextInstancePath = `${instancePath}/${key}`;
+        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
         const nextSchemaPath = `${schemaPath}/propertyNames`;
         const isPropertyName = ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
         if (!isPropertyName)

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

@@ -3,4 +3,4 @@ import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
 export declare function BuildRecursiveRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XRecursiveRef, value: string): string;
 export declare function CheckRecursiveRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XRecursiveRef, value: unknown): boolean;
-export declare function ErrorRecursiveRef(stack: Stack.XStack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;
+export declare function ErrorRecursiveRef(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;

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

@@ -22,8 +22,8 @@ export function CheckRecursiveRef(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRecursiveRef(stack, context, _schemaPath, instancePath, schema, value) {
+export function ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value) {
     const target = Resolve.RecursiveRef(stack, schema) ?? false;
     const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, '#', instancePath, target, value));
+    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value));
 }

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

@@ -3,4 +3,4 @@ import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
 export declare function BuildRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XRef, value: string): string;
 export declare function CheckRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XRef, value: unknown): boolean;
-export declare function ErrorRef(stack: Stack.XStack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;
+export declare function ErrorRef(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;

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

@@ -43,11 +43,11 @@ export function CheckRef(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
+export function ErrorRef(stack, context, schemaPath, instancePath, schema, value) {
     const result = Resolve.Ref(stack, schema);
     const target = result.schema ?? false;
     const nextContext = new ErrorContext();
-    const valid = (Schema.IsSchema(target) && ErrorSchema(result.stack, nextContext, '#', instancePath, target, value));
+    const valid = (Schema.IsSchema(target) && ErrorSchema(result.stack, nextContext, schemaPath, instancePath, target, value));
     if (valid)
         context.Merge([nextContext]);
     if (!valid)

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

@@ -173,14 +173,14 @@ export function BuildSchema(stack, context, schema, value) {
             constraints.push(BuildContains(current, context, schema, value));
         if (Schema.IsItems(schema))
             constraints.push(BuildItems(current, context, schema, value));
-        if (Schema.IsMaxContains(schema))
-            constraints.push(BuildMaxContains(current, context, schema, value));
-        if (Schema.IsMaxItems(schema))
-            constraints.push(BuildMaxItems(current, context, schema, value));
         if (Schema.IsMinContains(schema))
             constraints.push(BuildMinContains(current, context, schema, value));
+        if (Schema.IsMaxContains(schema))
+            constraints.push(BuildMaxContains(current, context, schema, value));
         if (Schema.IsMinItems(schema))
             constraints.push(BuildMinItems(current, context, schema, value));
+        if (Schema.IsMaxItems(schema))
+            constraints.push(BuildMaxItems(current, context, schema, value));
         if (Schema.IsPrefixItems(schema))
             constraints.push(BuildPrefixItems(current, context, schema, value));
         if (Schema.IsUniqueItems(schema))
@@ -191,10 +191,10 @@ export function BuildSchema(stack, context, schema, value) {
     }
     if (HasStringKeywords(schema)) {
         const constraints = [];
-        if (Schema.IsMaxLength(schema))
-            constraints.push(BuildMaxLength(current, context, schema, value));
         if (Schema.IsMinLength(schema))
             constraints.push(BuildMinLength(current, context, schema, value));
+        if (Schema.IsMaxLength(schema))
+            constraints.push(BuildMaxLength(current, context, schema, value));
         if (Schema.IsFormat(schema))
             constraints.push(BuildFormat(current, context, schema, value));
         if (Schema.IsPattern(schema))
@@ -205,14 +205,14 @@ export function BuildSchema(stack, context, schema, value) {
     }
     if (HasNumberKeywords(schema)) {
         const constraints = [];
-        if (Schema.IsExclusiveMaximum(schema))
-            constraints.push(BuildExclusiveMaximum(current, context, schema, value));
         if (Schema.IsExclusiveMinimum(schema))
             constraints.push(BuildExclusiveMinimum(current, context, schema, value));
-        if (Schema.IsMaximum(schema))
-            constraints.push(BuildMaximum(current, context, schema, value));
+        if (Schema.IsExclusiveMaximum(schema))
+            constraints.push(BuildExclusiveMaximum(current, context, schema, value));
         if (Schema.IsMinimum(schema))
             constraints.push(BuildMinimum(current, context, schema, value));
+        if (Schema.IsMaximum(schema))
+            constraints.push(BuildMaximum(current, context, schema, value));
         if (Schema.IsMultipleOf(schema))
             constraints.push(BuildMultipleOf(current, context, schema, value));
         const reduced = E.ReduceAnd(constraints);
@@ -270,20 +270,20 @@ export function CheckSchema(stack, context, schema, value) {
         (!G.IsArray(value) || ((!Schema.IsAdditionalItems(schema) || CheckAdditionalItems(current, context, schema, value)) &&
             (!Schema.IsContains(schema) || CheckContains(current, context, schema, value)) &&
             (!Schema.IsItems(schema) || CheckItems(current, context, schema, value)) &&
-            (!Schema.IsMaxContains(schema) || CheckMaxContains(current, context, schema, value)) &&
-            (!Schema.IsMaxItems(schema) || CheckMaxItems(current, context, schema, value)) &&
             (!Schema.IsMinContains(schema) || CheckMinContains(current, context, schema, value)) &&
+            (!Schema.IsMaxContains(schema) || CheckMaxContains(current, context, schema, value)) &&
             (!Schema.IsMinItems(schema) || CheckMinItems(current, context, schema, value)) &&
+            (!Schema.IsMaxItems(schema) || CheckMaxItems(current, context, schema, value)) &&
             (!Schema.IsPrefixItems(schema) || CheckPrefixItems(current, context, schema, value)) &&
             (!Schema.IsUniqueItems(schema) || CheckUniqueItems(current, context, schema, value)))) &&
-        (!G.IsString(value) || ((!Schema.IsMaxLength(schema) || CheckMaxLength(current, context, schema, value)) &&
-            (!Schema.IsMinLength(schema) || CheckMinLength(current, context, schema, value)) &&
+        (!G.IsString(value) || ((!Schema.IsMinLength(schema) || CheckMinLength(current, context, schema, value)) &&
+            (!Schema.IsMaxLength(schema) || CheckMaxLength(current, context, schema, value)) &&
             (!Schema.IsFormat(schema) || CheckFormat(current, context, schema, value)) &&
             (!Schema.IsPattern(schema) || CheckPattern(current, context, schema, value)))) &&
-        (!(G.IsNumber(value) || G.IsBigInt(value)) || ((!Schema.IsExclusiveMaximum(schema) || CheckExclusiveMaximum(current, context, schema, value)) &&
-            (!Schema.IsExclusiveMinimum(schema) || CheckExclusiveMinimum(current, context, schema, value)) &&
-            (!Schema.IsMaximum(schema) || CheckMaximum(current, context, schema, value)) &&
+        (!(G.IsNumber(value) || G.IsBigInt(value)) || ((!Schema.IsExclusiveMinimum(schema) || CheckExclusiveMinimum(current, context, schema, value)) &&
+            (!Schema.IsExclusiveMaximum(schema) || CheckExclusiveMaximum(current, context, schema, value)) &&
             (!Schema.IsMinimum(schema) || CheckMinimum(current, context, schema, value)) &&
+            (!Schema.IsMaximum(schema) || CheckMaximum(current, context, schema, value)) &&
             (!Schema.IsMultipleOf(schema) || CheckMultipleOf(current, context, schema, value)))) &&
         (!Schema.IsRef(schema) || CheckRef(current, context, schema, value)) &&
         (!Schema.IsRecursiveRef(schema) || CheckRecursiveRef(current, context, schema, value)) &&
@@ -328,20 +328,20 @@ export function ErrorSchema(stack, context, schemaPath, instancePath, schema, va
         +(!G.IsArray(value) || !!(+(!Schema.IsAdditionalItems(schema) || ErrorAdditionalItems(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsContains(schema) || ErrorContains(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsItems(schema) || ErrorItems(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsMaxContains(schema) || ErrorMaxContains(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsMaxItems(schema) || ErrorMaxItems(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMinContains(schema) || ErrorMinContains(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxContains(schema) || ErrorMaxContains(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMinItems(schema) || ErrorMinItems(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxItems(schema) || ErrorMaxItems(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsPrefixItems(schema) || ErrorPrefixItems(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsUniqueItems(schema) || ErrorUniqueItems(current, context, schemaPath, instancePath, schema, value)))) &
-        +(!G.IsString(value) || !!(+(!Schema.IsMaxLength(schema) || ErrorMaxLength(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsMinLength(schema) || ErrorMinLength(current, context, schemaPath, instancePath, schema, value)) &
+        +(!G.IsString(value) || !!(+(!Schema.IsMinLength(schema) || ErrorMinLength(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxLength(schema) || ErrorMaxLength(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsFormat(schema) || ErrorFormat(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsPattern(schema) || ErrorPattern(current, context, schemaPath, instancePath, schema, value)))) &
-        +(!(G.IsNumber(value) || G.IsBigInt(value)) || !!(+(!Schema.IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsMaximum(schema) || ErrorMaximum(current, context, schemaPath, instancePath, schema, value)) &
+        +(!(G.IsNumber(value) || G.IsBigInt(value)) || !!(+(!Schema.IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMinimum(schema) || ErrorMinimum(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaximum(schema) || ErrorMaximum(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMultipleOf(schema) || ErrorMultipleOf(current, context, schemaPath, instancePath, schema, value)))) &
         +(!Schema.IsRef(schema) || ErrorRef(current, context, schemaPath, instancePath, schema, value)) &
         +(!Schema.IsRecursiveRef(schema) || ErrorRecursiveRef(current, context, schemaPath, instancePath, schema, value)) &

package/node_modules/typebox/build/schema/parse.mjs

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
+import { EnableParseErrors, DisableParseErrors } from '../system/settings/internal.mjs';
 import { Arguments } from '../system/arguments/index.mjs';
 import { Check } from './check.mjs';
 import { Errors } from './errors.mjs';
@@ -17,7 +18,9 @@ export class ParseError {
 // ThrowParseError
 // ------------------------------------------------------------------
 export function ThrowParseError(context, schema, value) {
+    EnableParseErrors();
     const result = Errors(context, schema, value);
+    DisableParseErrors();
     throw new ParseError(schema, value, result[1]);
 }
 /** Parses a value against the provided schema */

package/node_modules/typebox/build/schema/pointer/pointer.d.mts

@@ -1,10 +1,5 @@
-/** Returns an array of path indices for the given pointer */
 export declare function Indices(pointer: string): string[];
-/** Returns true if a value exists at the current pointer */
-export declare function Has(value: unknown, pointer: string): unknown;
-/** Gets a value at the pointer, or undefined if not exists */
+export declare function Has(value: unknown, pointer: string): boolean;
 export declare function Get(value: unknown, pointer: string): unknown;
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export declare function Delete(value: unknown, pointer: string): unknown;

package/node_modules/typebox/build/schema/pointer/pointer.mjs

@@ -1,106 +1,89 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Asserts
+// Throw
 // ------------------------------------------------------------------
-function AssertNotRoot(indices) {
-    if (indices.length === 0)
-        throw Error('Cannot set root');
+function Throw(message) {
+    throw Error(message);
 }
-function AssertCanSet(value) {
-    if (!Guard.IsObject(value))
-        throw Error('Cannot set value');
+function ThrowUnsafePropertyKey() {
+    Throw('Pointer contains unsafe property key');
 }
-function AssertIndex(index) {
-    if (Guard.IsUnsafePropertyKey(index))
-        throw Error('Pointer contains unsafe property key');
-}
-function AssertIndices(indices) {
-    for (const index of indices)
-        AssertIndex(index);
-}
-// ------------------------------------------------------------------
-// Indices
-// ------------------------------------------------------------------
-function IsNumericIndex(index) {
-    return /^(0|[1-9]\d*)$/.test(index);
-}
-function TakeIndexRight(indices) {
-    return [
-        indices.slice(0, indices.length - 1),
-        indices.slice(indices.length - 1)[0]
-    ];
-}
-function HasIndex(index, value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
-}
-function GetIndex(index, value) {
-    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
-}
-function GetIndices(indices, value) {
-    return indices.reduce((value, index) => GetIndex(index, value), value);
+function ThrowCannotSetRoot() {
+    Throw('Cannot set value');
 }
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
-/** Returns an array of path indices for the given pointer */
 export function Indices(pointer) {
-    if (Guard.IsEqual(pointer.length, 0))
-        return [];
-    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
-    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
+    const indices = pointer.split('/').map(index => index.replace(/~1/g, '/').replace(/~0/g, '~'));
+    return indices[0] === '' ? indices.slice(1) : indices;
 }
 // ------------------------------------------------------------------
 // Has
 // ------------------------------------------------------------------
-/** Returns true if a value exists at the current pointer */
 export function Has(value, pointer) {
     let current = value;
-    return Indices(pointer).every(index => {
-        if (!HasIndex(index, current))
+    for (const index of Indices(pointer)) {
+        if (!Guard.IsObject(current) || !Guard.HasPropertyKey(current, index))
             return false;
         current = current[index];
-        return true;
-    });
+    }
+    return true;
 }
 // ------------------------------------------------------------------
 // Get
 // ------------------------------------------------------------------
-/** Gets a value at the pointer, or undefined if not exists */
 export function Get(value, pointer) {
-    const indices = Indices(pointer);
-    return GetIndices(indices, value);
+    let current = value;
+    for (const index of Indices(pointer)) {
+        if (!Guard.IsObject(current) || Guard.IsUnsafePropertyKey(index))
+            return undefined;
+        current = current[index];
+    }
+    return current;
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+function Parent(value, indices, last) {
+    let current = value;
+    for (const index of indices) {
+        if (Guard.IsUnsafePropertyKey(index))
+            ThrowUnsafePropertyKey();
+        current = Guard.IsObject(current) ? current[index] : undefined;
+    }
+    if (Guard.IsUnsafePropertyKey(last))
+        ThrowUnsafePropertyKey();
+    if (!Guard.IsObject(current))
+        ThrowCannotSetRoot();
+    return current;
 }
 // ------------------------------------------------------------------
 // Set
 // ------------------------------------------------------------------
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export function Set(value, pointer, next) {
     const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    parent[index] = next;
+    const last = indices.pop();
+    if (Guard.IsUndefined(last))
+        ThrowCannotSetRoot();
+    Parent(value, indices, last)[last] = next;
     return value;
 }
 // ------------------------------------------------------------------
 // Delete
 // ------------------------------------------------------------------
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export function Delete(value, pointer) {
     const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
-        parent.splice(+index, 1);
+    const last = indices.pop();
+    if (Guard.IsUndefined(last))
+        ThrowCannotSetRoot();
+    const parent = Parent(value, indices, last);
+    if (Guard.IsArray(parent) && /^(0|[1-9]\d*)$/.test(last)) {
+        parent.splice(Number(last), 1);
     }
     else {
-        delete parent[index];
+        delete parent[last];
     }
     return value;
 }

package/node_modules/typebox/build/system/settings/internal.d.mts

@@ -0,0 +1,2 @@
+export declare function EnableParseErrors(): void;
+export declare function DisableParseErrors(): void;

package/node_modules/typebox/build/system/settings/internal.mjs

@@ -0,0 +1,20 @@
+import { Get } from './settings.mjs';
+// ------------------------------------------------------------------
+// TempMaxErrors
+// ------------------------------------------------------------------
+let TempMaxErrors = 0;
+// ------------------------------------------------------------------
+// [Internal] EnableParseErrors
+// ------------------------------------------------------------------
+export function EnableParseErrors() {
+    const settings = Get();
+    TempMaxErrors = settings.maxErrors;
+    settings.maxErrors = settings.maxParseErrors;
+}
+// ------------------------------------------------------------------
+// [Internal] DisableParseErrors
+// ------------------------------------------------------------------
+export function DisableParseErrors() {
+    const settings = Get();
+    settings.maxErrors = TempMaxErrors;
+}

package/node_modules/typebox/build/system/settings/settings.d.mts

@@ -16,6 +16,17 @@ export interface TSettings {
      * @default 8
      */
     maxErrors: number;
+    /**
+     * Specifies the maximum number of errors to gather for failed Parse operations. TypeBox will
+     * automatically run an error-gathering pass on failed Parses to attach diagnostics to the
+     * thrown exception. This setting controls the number of errors gathered in that pass. Higher
+     * values will reduce throughput on failure cases, so a maximum of 4 is recommended if more
+     * errors are needed. The default setting of 1 will terminate on the first error, while a
+     * setting of 0 will skip error gathering entirely.
+     *
+     * @default 1
+     */
+    maxParseErrors: number;
     /**
      * Specifies the maximum number of instantiations allowed within a top-level generic instantiation
      * context. This setting can be used to bound generic calls to a fixed count, which can be useful if

package/node_modules/typebox/build/system/settings/settings.mjs

@@ -1,8 +1,12 @@
 import { Guard } from '../../guard/index.mjs';
+// -------------------------------------------------------------------
+// State
+// -------------------------------------------------------------------
 // Internal mutable state
 const settings = {
     immutableTypes: false,
     maxErrors: 8,
+    maxParseErrors: 1,
     maxInstantiationCount: 128,
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
@@ -10,10 +14,14 @@ const settings = {
     correctiveParse: false,
     unionPrioritySort: true
 };
+// -------------------------------------------------------------------
+// Reset
+// -------------------------------------------------------------------
 /** Resets system settings to defaults */
 export function Reset() {
     settings.immutableTypes = false;
     settings.maxErrors = 8;
+    settings.maxParseErrors = 1;
     settings.maxInstantiationCount = 128;
     settings.useAcceleration = true;
     settings.exactOptionalPropertyTypes = false;
@@ -21,6 +29,9 @@ export function Reset() {
     settings.correctiveParse = false;
     settings.unionPrioritySort = true;
 }
+// -------------------------------------------------------------------
+// Set
+// -------------------------------------------------------------------
 /** Sets system settings */
 export function Set(options) {
     for (const key of Guard.Keys(options)) {
@@ -30,6 +41,9 @@ export function Set(options) {
         }
     }
 }
+// -------------------------------------------------------------------
+// Get
+// -------------------------------------------------------------------
 /** Gets current system settings */
 export function Get() {
     return settings;