@openclaw/matrix 2026.8.1-beta.2 → 2026.8.1

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

@@ -4,7 +4,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors, _Stack_FromContext, _Stack_FromRef;
+var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors;
 import * as Schema from '../types/index.mjs';
 import { Guard as G } from '../../guard/index.mjs';
 import { Resolve } from '../resolve/index.mjs';
@@ -22,7 +22,7 @@ export class Stack {
     // Base
     // ----------------------------------------------------------------
     BaseURL() {
-        return this.ids.reduce((result, schema) => new URL(schema.$id, result), new URL('http://unknown'));
+        return this.ids.reduce((result, schema) => new URL(schema.$id, result), Resolve.DefaultBase);
     }
     Base() {
         return this.ids[this.ids.length - 1] ?? this.schema;
@@ -58,23 +58,29 @@ export class Stack {
         if (Schema.IsDynamicAnchor(schema))
             this.dynamicAnchors.pop();
     }
+    // ----------------------------------------------------------------
+    // Ref
+    // ----------------------------------------------------------------
     Ref(ref) {
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromContext).call(this, ref) ?? __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromRef).call(this, ref);
+        const root = this.schema;
+        return !ref.$ref.startsWith('#')
+            ? Resolve.Ref(this.context, root, ref.$ref)
+            : Resolve.Ref(this.context, this.Base(), ref.$ref);
     }
     // ----------------------------------------------------------------
     // RecursiveRef
     // ----------------------------------------------------------------
     RecursiveRef(recursiveRef) {
         return Schema.IsRecursiveAnchorTrue(this.Base())
-            ? Resolve.Ref(this.recursiveAnchors[0], recursiveRef.$recursiveRef)
-            : Resolve.Ref(this.Base(), recursiveRef.$recursiveRef);
+            ? Resolve.Ref(this.context, this.recursiveAnchors[0], recursiveRef.$recursiveRef)
+            : Resolve.Ref(this.context, this.Base(), recursiveRef.$recursiveRef);
     }
     // ----------------------------------------------------------------
     // DynamicRef
     // ----------------------------------------------------------------
     DynamicRef(dynamicRef) {
         const root = this.schema;
-        return Resolve.DynamicRef(root, this.Base(), dynamicRef, this.dynamicAnchors);
+        return Resolve.DynamicRef(this.context, root, this.Base(), dynamicRef, this.dynamicAnchors);
     }
 }
 _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
@@ -97,11 +103,4 @@ _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_P
         this.dynamicAnchors.pop();
     for (const key of G.Keys(current))
         __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
-}, _Stack_FromContext = function _Stack_FromContext(ref) {
-    return G.HasPropertyKey(this.context, ref.$ref) ? this.context[ref.$ref] : undefined;
-}, _Stack_FromRef = function _Stack_FromRef(ref) {
-    const root = this.schema;
-    return !ref.$ref.startsWith('#')
-        ? Resolve.Ref(root, ref.$ref)
-        : Resolve.Ref(this.Base(), ref.$ref);
 };

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

@@ -12,15 +12,25 @@ function IsValid(schema) {
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildAdditionalItems(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return E.Constant(true);
+function BuildAdditionalItemsStandard(stack, context, schema, value) {
     const [item, index] = [Unique(), Unique()];
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
     const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
     const addIndex = context.AddIndex(index);
-    const guarded = context.UseUnevaluated() ? E.Or(isLength, E.And(isSchema, addIndex)) : E.Or(isLength, isSchema);
-    return E.Call(E.Member(value, 'every'), [E.ArrowFunction([item, index], guarded)]);
+    return E.Every(value, E.Constant(0), [item, index], E.Or(isLength, E.And(isSchema, addIndex)));
+}
+function BuildAdditionalItemsFast(stack, context, schema, value) {
+    const [item, index] = [Unique(), Unique()];
+    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
+    const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
+    return E.Every(value, E.Constant(0), [item, index], E.Or(isLength, isSchema));
+}
+export function BuildAdditionalItems(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    return context.UseUnevaluated()
+        ? BuildAdditionalItemsStandard(stack, context, schema, value)
+        : BuildAdditionalItemsFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
@@ -28,7 +38,7 @@ export function BuildAdditionalItems(stack, context, schema, value) {
 export function CheckAdditionalItems(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    const isAdditionalItems = value.every((item, index) => {
+    const isAdditionalItems = G.Every(value, 0, (item, index) => {
         return G.IsLessThan(index, schema.items.length)
             || (CheckSchemaPushStack(stack, context, schema.additionalItems, item) && context.AddIndex(index));
     });
@@ -40,7 +50,7 @@ export function CheckAdditionalItems(stack, context, schema, value) {
 export function ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema, value) {
     if (!IsValid(schema))
         return true;
-    const isAdditionalItems = value.every((item, index) => {
+    const isAdditionalItems = G.Every(value, 0, (item, index) => {
         const nextSchemaPath = `${schemaPath}/additionalItems`;
         const nextInstancePath = `${instancePath}/${index}`;
         return G.IsLessThan(index, schema.items.length) ||

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

@@ -3,6 +3,7 @@ import * as S from '../types/index.mjs';
 import * as V from './_externals.mjs';
 import { Unique } from './_unique.mjs';
 import { AccumulatedErrorContext } from './_context.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -58,7 +59,7 @@ export function BuildAdditionalPropertiesFast(_context, schema, value) {
 // ------------------------------------------------------------------
 export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
     const [key, _index] = [Unique(), Unique()];
-    const regexp = V.CreateVariable(new RegExp(GetPropertiesPattern(schema)));
+    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);
@@ -78,7 +79,7 @@ export function BuildAdditionalProperties(stack, context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckAdditionalProperties(stack, context, schema, value) {
-    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
     const isAdditionalProperties = G.Every(G.Keys(value), 0, (key, _index) => {
         return regexp.test(key) ||
             (CheckSchemaPushStack(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
@@ -89,7 +90,7 @@ export function CheckAdditionalProperties(stack, context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value) {
-    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
     const additionalProperties = [];
     const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;

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

@@ -12,13 +12,24 @@ function IsValid(schema) {
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
+function BuildContainsStandard(stack, context, schema, value) {
+    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()];
+    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);
+}
 export function BuildContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const item = Unique();
-    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
-    const isSome = E.Call(E.Member(value, 'some'), [E.ArrowFunction([item], BuildSchema(stack, context, schema.contains, item))]);
-    return E.And(isLength, isSome);
+    return context.UseUnevaluated()
+        ? BuildContainsStandard(stack, context, schema, value)
+        : BuildContainsFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
@@ -26,8 +37,9 @@ export function BuildContains(stack, context, schema, value) {
 export function CheckContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    return !G.IsEqual(value.length, 0) &&
-        value.some((item) => CheckSchema(stack, context, schema.contains, item));
+    return !G.IsEqual(value.length, 0) && G.SomeAll(value, (item, index) => {
+        return CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index);
+    });
 }
 // ------------------------------------------------------------------
 // Error

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

@@ -16,7 +16,7 @@ export function BuildEnum(_stack, _context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckEnum(_stack, _context, schema, value) {
-    return schema.enum.some(option => G.IsValueLike(option)
+    return G.Some(schema.enum, option => G.IsValueLike(option)
         ? G.IsEqual(value, option)
         : G.IsDeepEqual(value, option));
 }

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

@@ -5,15 +5,26 @@ import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from
 // ------------------------------------------------------------------
 // ItemsSized
 // ------------------------------------------------------------------
-function BuildItemsSized(stack, context, schema, value) {
+function BuildItemsSizedStandard(stack, context, schema, value) {
     return E.ReduceAnd(schema.items.map((schema, index) => {
         const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
         const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
         const addIndex = context.AddIndex(E.Constant(index));
-        const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
-        return E.Or(isLength, guarded);
+        return E.Or(isLength, E.And(isSchema, addIndex));
     }));
 }
+function BuildItemsSizedFast(stack, context, schema, value) {
+    return E.ReduceAnd(schema.items.map((schema, index) => {
+        const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
+        const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
+        return E.Or(isLength, isSchema);
+    }));
+}
+function BuildItemsSized(stack, context, schema, value) {
+    return context.UseUnevaluated()
+        ? BuildItemsSizedStandard(stack, context, schema, value)
+        : BuildItemsSizedFast(stack, context, schema, value);
+}
 function CheckItemsSized(stack, context, schema, value) {
     return G.Every(schema.items, 0, (schema, index) => {
         return G.IsLessEqualThan(value.length, index)
@@ -31,12 +42,21 @@ function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value
 // ------------------------------------------------------------------
 // ItemsUnsized
 // ------------------------------------------------------------------
-function BuildItemsUnsized(stack, context, schema, value) {
+function BuildItemsUnsizedStandard(stack, context, schema, value) {
     const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
     const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
     const addIndex = context.AddIndex('index');
-    const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
-    return E.Every(value, E.Constant(offset), ['element', 'index'], guarded);
+    return E.Every(value, E.Constant(offset), ['element', 'index'], E.And(isSchema, addIndex));
+}
+function BuildItemsUnsizedFast(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
+    return E.Every(value, E.Constant(offset), ['element', 'index'], isSchema);
+}
+function BuildItemsUnsized(stack, context, schema, value) {
+    return context.UseUnevaluated()
+        ? BuildItemsUnsizedStandard(stack, context, schema, value)
+        : BuildItemsUnsizedFast(stack, context, schema, value);
 }
 function CheckItemsUnsized(stack, context, schema, value) {
     const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;

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

@@ -15,8 +15,8 @@ function IsValid(schema) {
 export function BuildMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const [result, item] = [Unique(), Unique()];
-    const count = E.Call(E.Member(value, 'reduce'), [E.ArrowFunction([result, item], E.Ternary(BuildSchema(stack, context, schema.contains, item), E.PrefixIncrement(result), result)), E.Constant(0)]);
+    const [item] = [Unique()];
+    const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.IsLessEqualThan(count, E.Constant(schema.maxContains));
 }
 // ------------------------------------------------------------------
@@ -25,7 +25,7 @@ export function BuildMaxContains(stack, context, schema, value) {
 export function CheckMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    const count = value.reduce((result, item) => CheckSchema(stack, context, schema.contains, item) ? ++result : result, 0);
+    const count = G.Counted(value, (item) => CheckSchema(stack, context, schema.contains, item));
     return G.IsLessEqualThan(count, schema.maxContains);
 }
 // ------------------------------------------------------------------

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

@@ -12,12 +12,22 @@ function IsValid(schema) {
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
+function BuildMinContainsStandard(stack, context, schema, value) {
+    const [item, index] = [Unique(), Unique()];
+    const count = E.Counted(value, [item, index], E.And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index)));
+    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+}
+function BuildMinContainsFast(stack, context, schema, value) {
+    const [item] = [Unique()];
+    const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
+    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+}
 export function BuildMinContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const [result, item] = [Unique(), Unique()];
-    const count = E.Call(E.Member(value, 'reduce'), [E.ArrowFunction([result, item], E.Ternary(BuildSchema(stack, context, schema.contains, item), E.PrefixIncrement(result), result)), E.Constant(0)]);
-    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+    return context.UseUnevaluated()
+        ? BuildMinContainsStandard(stack, context, schema, value)
+        : BuildMinContainsFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
@@ -25,7 +35,7 @@ export function BuildMinContains(stack, context, schema, value) {
 export function CheckMinContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    const count = value.reduce((result, item) => CheckSchema(stack, context, schema.contains, item) ? ++result : result, 0);
+    const count = G.Counted(value, (item, index) => CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index));
     return G.IsGreaterEqualThan(count, schema.minContains);
 }
 // ------------------------------------------------------------------

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

@@ -6,14 +6,16 @@ import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-function BuildNotUnevaluated(stack, context, schema, value) {
+function BuildNotStandard(stack, context, schema, value) {
     return Reducer(stack, context, [schema.not], value, E.Not(E.IsEqual(E.Member('results', 'length'), E.Constant(1))));
 }
 function BuildNotFast(stack, context, schema, value) {
     return E.Not(BuildSchema(stack, context, schema.not, value));
 }
 export function BuildNot(stack, context, schema, value) {
-    return context.UseUnevaluated() ? BuildNotUnevaluated(stack, context, schema, value) : BuildNotFast(stack, context, schema, value);
+    return context.UseUnevaluated()
+        ? BuildNotStandard(stack, context, schema, value)
+        : BuildNotFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check

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

@@ -3,22 +3,23 @@ import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { Unique } from './_unique.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-function BuildOneOfUnevaluated(stack, context, schema, value) {
+function BuildOneOfStandard(stack, context, schema, value) {
     return Reducer(stack, context, schema.oneOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(1)));
 }
 function BuildOneOfFast(stack, context, schema, value) {
+    const [result] = [Unique()];
     const results = E.ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(stack, context, schema, value)));
-    const count = E.Call(E.Member(results, 'reduce'), [
-        E.ArrowFunction(['count', 'result'], E.Ternary(E.IsEqual('result', E.Constant(true)), E.PrefixIncrement('count'), 'count')),
-        E.Constant(0),
-    ]);
+    const count = E.Counted(results, [result, '_'], E.IsEqual(result, E.Constant(true)));
     return E.IsEqual(count, E.Constant(1));
 }
 export function BuildOneOf(stack, context, schema, value) {
-    return context.UseUnevaluated() ? BuildOneOfUnevaluated(stack, context, schema, value) : BuildOneOfFast(stack, context, schema, value);
+    return context.UseUnevaluated()
+        ? BuildOneOfStandard(stack, context, schema, value)
+        : BuildOneOfFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check

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

@@ -1,18 +1,19 @@
 // deno-fmt-ignore-file
 import * as Externals from './_externals.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildPattern(_stack, _context, schema, value) {
-    const regexp = Externals.CreateVariable(G.IsString(schema.pattern) ? new RegExp(schema.pattern, 'u') : schema.pattern);
+    const regexp = Externals.CreateVariable(G.IsString(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern);
     return E.Call(E.Member(regexp, 'test'), [value]);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckPattern(_stack, _context, schema, value) {
-    const regexp = G.IsString(schema.pattern) ? new RegExp(schema.pattern, 'u') : schema.pattern;
+    const regexp = G.IsString(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern;
     return regexp.test(value);
 }
 // ------------------------------------------------------------------

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

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import * as Externals from './_externals.mjs';
 import { Unique } from './_unique.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -9,7 +10,7 @@ import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from
 export function BuildPatternProperties(stack, context, schema, value) {
     return E.ReduceAnd(G.Entries(schema.patternProperties).map(([pattern, schema]) => {
         const [key, prop] = [Unique(), Unique()];
-        const regexp = Externals.CreateVariable(new RegExp(pattern, 'u'));
+        const regexp = Externals.CreateVariable(UnicodeRegExp(pattern));
         const notKey = E.Not(E.Call(E.Member(regexp, 'test'), [key]));
         const isSchema = BuildSchemaPushStack(stack, context, schema, prop);
         const addKey = context.AddKey(key);
@@ -22,7 +23,7 @@ export function BuildPatternProperties(stack, context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckPatternProperties(stack, context, schema, value) {
     return G.Every(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
-        const regexp = new RegExp(pattern, 'u');
+        const regexp = UnicodeRegExp(pattern);
         return G.Every(G.Entries(value), 0, ([key, prop]) => {
             return !regexp.test(key) || CheckSchemaPushStack(stack, context, schema, prop) && context.AddKey(key);
         });
@@ -34,7 +35,7 @@ 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 regexp = new RegExp(pattern, 'u');
+        const regexp = UnicodeRegExp(pattern);
         return G.EveryAll(G.Entries(value), 0, ([key, value]) => {
             const nextInstancePath = `${instancePath}/${key}`;
             const notKey = !regexp.test(key);

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

@@ -5,7 +5,7 @@ import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
-// BuildRefStandard
+// BuildRef
 // ------------------------------------------------------------------
 function BuildRefStandard(stack, context, target, value) {
     const interior = E.ArrowFunction(['context', 'value'], Functions.CreateFunction(stack, context, target, 'value'));
@@ -17,15 +17,9 @@ function BuildRefStandard(stack, context, target, value) {
     ]));
     return E.Call(exterior, ['context', value]);
 }
-// ------------------------------------------------------------------
-// BuildRefStandard
-// ------------------------------------------------------------------
 function BuildRefFast(stack, context, target, value) {
     return Functions.CreateFunction(stack, context, target, value);
 }
-// ------------------------------------------------------------------
-// BuildRef
-// ------------------------------------------------------------------
 export function BuildRef(stack, context, schema, value) {
     const target = stack.Ref(schema) ?? false;
     return context.UseUnevaluated()

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

@@ -45,12 +45,21 @@ import { BuildUnevaluatedItems, CheckUnevaluatedItems, ErrorUnevaluatedItems } f
 import { BuildUnevaluatedProperties, CheckUnevaluatedProperties, ErrorUnevaluatedProperties } from './unevaluatedProperties.mjs';
 import { BuildUniqueItems, CheckUniqueItems, ErrorUniqueItems } from './uniqueItems.mjs';
 // ----------------------------------------------------------------
-// HasTypeName
+// HasTypeName (Optimization)
+//
+// We only consider a schema as having a type name when the schema 
+// has a single type string, or when every element in the type 
+// array is the same. For a type array, we must treat multi-variant 
+// types as unions and therefore can NOT use an optimized forward 
+// type check.
+//
 // ----------------------------------------------------------------
 function HasTypeName(schema, typename) {
-    return Schema.IsType(schema) &&
-        (G.IsArray(schema.type) && schema.type.includes(typename) ||
-            G.IsEqual(schema.type, typename));
+    return (Schema.IsType(schema) &&
+        ((G.IsArray(schema.type) &&
+            G.IsGreaterThan(schema.type.length, 0) &&
+            G.Every(schema.type, 0, type => G.IsEqual(type, typename))) ||
+            G.IsEqual(schema.type, typename)));
 }
 // ----------------------------------------------------------------
 // HasObject

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

@@ -48,7 +48,7 @@ function BuildTypeNames(stack, context, typenames, value) {
     return E.ReduceOr(typenames.map(type => BuildTypeName(stack, context, type, value)));
 }
 function CheckTypeNames(stack, context, types, schema, value) {
-    return types.some(type => CheckTypeName(stack, context, type, schema, value));
+    return G.Some(types, type => CheckTypeName(stack, context, type, schema, value));
 }
 // ------------------------------------------------------------------
 // Type

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

@@ -1 +1,4 @@
-export * from './ref.mjs';
+import * as Schema from '../types/index.mjs';
+export declare const DefaultBase: URL;
+export declare function Ref(context: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
+export declare function DynamicRef(context: Record<string, Schema.XSchema>, root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;