@openclaw/facetime 2026.9.6 → 2026.9.7

package/node_modules/typebox/build/format/iri.mjs

@@ -1,9 +1,10 @@
 // deno-lint-ignore-file no-control-regex
-const IpvFutureMatchMaxLength = 2048;
-const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
-const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
-const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
+//
+// Removed by the following PR
+//
+// https://github.com/json-schema-org/JSON-Schema-Test-Suite/pull/1176
+//
 // NarrowIpvFuture
 //
 // Substitutes an IPvFuture address with a standard IPv6 loopback
@@ -13,12 +14,18 @@ const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // be expensive on large strings, this operation is strictly
 // limited to inputs under a defined length threshold.
 //
-// (review-optimization)
+// ------------------------------------------------------------------
+//
+// const IpvFutureMatchMaxLength = 2048
+// const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/ // Guarded By IpvFutureMatchMaxLength
+//
+// function NarrowIpvFuture(value: string): string {
+//   return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value
+// }
 //
 // ------------------------------------------------------------------
-function NarrowIpvFuture(value) {
-    return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value;
-}
+const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 /**
  * Returns true if the value is a valid Internationalized Resource Identifier.
  * @specification https://datatracker.ietf.org/doc/html/rfc3987
@@ -31,5 +38,5 @@ export function IsIri(value) {
     if (InvalidPercentEncoding.test(value))
         return false;
     // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
-    return URL.canParse(NarrowIpvFuture(value));
+    return URL.canParse(value);
 }

package/node_modules/typebox/build/guard/emit.mjs

@@ -97,10 +97,10 @@ export function IsGreaterEqualThan(left, right) {
 // String
 // --------------------------------------------------------------------------
 export function IsMinLength(value, length) {
-    return `Guard.IsMinLength(${value}, ${length})`;
+    return `(${value}.length >= ${(+length) << 1} || (${value}.length >= ${length} && Guard.CodePointCount(${value}) >= ${length}))`;
 }
 export function IsMaxLength(value, length) {
-    return `Guard.IsMaxLength(${value}, ${length})`;
+    return `(${value}.length <= ${length} || (${value}.length <= ${(+length) << 1} && Guard.CodePointCount(${value}) <= ${length}))`;
 }
 // --------------------------------------------------------------------------
 // Array

package/node_modules/typebox/build/guard/guard.d.mts

@@ -33,12 +33,14 @@ export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint
 /** Returns true if the value appears to be an instance of a class. */
 export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
-/** Returns the number of grapheme clusters in the string */
+/** Returns the total number of visual grapheme clusters in the string. */
 export declare function GraphemeCount(value: string): number;
-/** Returns true if the string has at most the given number of graphemes */
-export declare function IsMaxLength(value: string, length: number): boolean;
-/** Returns true if the string has at least the given number of graphemes */
-export declare function IsMinLength(value: string, length: number): boolean;
+/** Returns the total number of Unicode code points in the string. */
+export declare function CodePointCount(value: string): number;
+/** Returns true if the string length in Unicode code points does not exceed maxLength */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Returns true if the string length in Unicode code points is at least minLength */
+export declare function IsMinLength(value: string, minLength: number): boolean;
 /** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */

package/node_modules/typebox/build/guard/guard.mjs

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
-import * as String from './string.mjs';
+import * as UnicodeSegmentGuard from './unicode/unicode_segment.mjs';
+import * as UnicodeGuard from './unicode/unicode.mjs';
 // --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
@@ -123,17 +124,21 @@ export function IsValueLike(value) {
 // --------------------------------------------------------------------------
 // String
 // --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in the string */
+/** Returns the total number of visual grapheme clusters in the string. */
 export function GraphemeCount(value) {
-    return String.GraphemeCount(value);
+    return UnicodeSegmentGuard.GraphemeCount(value);
 }
-/** Returns true if the string has at most the given number of graphemes */
-export function IsMaxLength(value, length) {
-    return String.IsMaxLength(value, length);
+/** Returns the total number of Unicode code points in the string. */
+export function CodePointCount(value) {
+    return UnicodeGuard.CodePointCount(value);
 }
-/** Returns true if the string has at least the given number of graphemes */
-export function IsMinLength(value, length) {
-    return String.IsMinLength(value, length);
+/** Returns true if the string length in Unicode code points does not exceed maxLength */
+export function IsMaxLength(value, maxLength) {
+    return UnicodeGuard.IsMaxLength(value, maxLength);
+}
+/** Returns true if the string length in Unicode code points is at least minLength */
+export function IsMinLength(value, minLength) {
+    return UnicodeGuard.IsMinLength(value, minLength);
 }
 // --------------------------------------------------------------------------
 // Array

package/node_modules/typebox/build/guard/index.mjs

@@ -1,6 +1,12 @@
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
 export * as EmitGuard from './emit.mjs';
 export * as GlobalsGuard from './globals.mjs';
 export * as NativeGuard from './native.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
 import * as Guard from './guard.mjs';
 export * as Guard from './guard.mjs';
 export default Guard;

package/node_modules/typebox/build/guard/unicode/unicode.d.mts

@@ -0,0 +1,6 @@
+/** Returns the total number of Unicode code points in the string */
+export declare function CodePointCount(value: string): number;
+/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
+export declare function IsMinLength(value: string, minLength: number): boolean;

package/node_modules/typebox/build/guard/unicode/unicode.mjs

@@ -0,0 +1,35 @@
+// ------------------------------------------------------------------
+// CodePointCount (10-bit Shift Branchless)
+//
+// Counts code points by enumerating UTF-16 sequences and incrementing
+// when not within a high/low pairing. Because surrogate blocks are
+// 1024 (2^10) wide and aligned, by shifting right by (0xA), we can
+// collapse each unit to a constant per block (high: 0x36, low: 0x37)
+// and shift again into a packed (0x3637) for comparison. Fetch calls
+// to charCodeAt(...) are kept to one call per iteration.
+//
+// ------------------------------------------------------------------
+/** Returns the total number of Unicode code points in the string */
+export function CodePointCount(value) {
+    let result = 0, index = 0, prev = 0;
+    while (index < value.length) {
+        const next = value.charCodeAt(index++) >> 0xA; // shift  (10-bits into high/low)
+        result += +(((prev << 8) | next) !== 0x3637); // packed (or +!(prev === 0x36 && next === 0x37))
+        prev = next;
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// IsMaxLength
+// ------------------------------------------------------------------
+/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
+export function IsMaxLength(value, maxLength) {
+    return value.length <= maxLength || (value.length <= (maxLength << 1) && CodePointCount(value) <= maxLength);
+}
+// ------------------------------------------------------------------
+// IsMinLength
+// ------------------------------------------------------------------
+/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
+export function IsMinLength(value, minLength) {
+    return value.length >= (minLength << 1) || (value.length >= minLength && CodePointCount(value) >= minLength);
+}

package/node_modules/typebox/build/guard/{string.mjs → unicode/unicode_segment.mjs}

@@ -91,26 +91,12 @@ function IsGraphemeCodePoint(value) {
         IsZeroWidthJoiner(value)));
 }
 // --------------------------------------------------------------------------
-// GraphemeCount
-// --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in a string */
-export function GraphemeCount(value) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        count++;
-    }
-    return count;
-}
-// --------------------------------------------------------------------------
 // IsMinLengthSegmented
 // --------------------------------------------------------------------------
 /** Checks if a string has at least a minimum number of grapheme clusters */
 function IsMinLengthSegmented(value, minLength) {
     // if (minLength === 0) return true // 0-length (unreachable)
-    let count = 0;
-    let index = 0;
+    let count = 0, index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
         if ((++count) >= minLength)
@@ -123,8 +109,7 @@ function IsMinLengthSegmented(value, minLength) {
 // --------------------------------------------------------------------------
 /** Checks if a string has at most a maximum number of grapheme clusters */
 function IsMaxLengthSegmented(value, maxLength) {
-    let count = 0;
-    let index = 0;
+    let count = 0, index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
         if ((++count) > maxLength)
@@ -133,7 +118,19 @@ function IsMaxLengthSegmented(value, maxLength) {
     return true;
 }
 // --------------------------------------------------------------------------
-// IsMinLengthFast
+// GraphemeCount
+// --------------------------------------------------------------------------
+/** Returns the number of grapheme clusters in a string */
+export function GraphemeCount(value) {
+    let count = 0, index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+    }
+    return count;
+}
+// --------------------------------------------------------------------------
+// IsMinLength
 // --------------------------------------------------------------------------
 /** Fast check for minimum grapheme length, falls back to full check if needed */
 export function IsMinLength(value, minLength) {
@@ -151,7 +148,7 @@ export function IsMinLength(value, minLength) {
     }
 }
 // --------------------------------------------------------------------------
-// IsMaxLengthFast
+// IsMaxLength
 // --------------------------------------------------------------------------
 /** Fast check for maximum grapheme length, falls back to full check if needed */
 export function IsMaxLength(value, maxLength) {

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

@@ -4,7 +4,6 @@ import { Arguments } from '../system/arguments/index.mjs';
 import { Environment } from '../system/environment/index.mjs';
 import { Hashing } from '../system/hashing/index.mjs';
 import { Guard } from '../guard/index.mjs';
-import { Format } from '../format/index.mjs';
 import * as Engine from './engine/index.mjs';
 // ------------------------------------------------------------------
 // CreateCode
@@ -20,8 +19,8 @@ function CreateCode(build) {
 // CreateEvaluatedCheck
 // ------------------------------------------------------------------
 function CreateEvaluatedCheck(build, code) {
-    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
-    return factory(Engine.CheckContext, Guard, Format, Hashing, build.External().variables);
+    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Hashing', build.External().identifier, code);
+    return factory(Engine.CheckContext, Guard, Hashing, build.External().variables);
 }
 // ------------------------------------------------------------------
 // CreateDynamicCheck

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

@@ -0,0 +1 @@
+export declare function EncodeFragment(fragment: string): string;

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)) &