@openclaw/slack 2026.8.1-beta.3 → 2026.8.1

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;

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

@@ -1 +1,202 @@
-export * from './ref.mjs';
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+import * as Schema from '../types/index.mjs';
+// ------------------------------------------------------------------
+// DefaultBase
+// ------------------------------------------------------------------
+export const DefaultBase = new URL('https://json-schema.org');
+// ------------------------------------------------------------------
+// Match: Id
+// ------------------------------------------------------------------
+function MatchId(schema, base, ref) {
+    if (schema.$id === ref.hash)
+        return schema;
+    const absoluteId = new URL(schema.$id, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
+        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Match: Anchor
+// ------------------------------------------------------------------
+function MatchAnchor(schema, base, ref) {
+    const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
+}
+// ------------------------------------------------------------------
+// Match: DynamicAnchor
+// ------------------------------------------------------------------
+function MatchDynamicAnchor(schema, base, ref) {
+    const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
+}
+// ------------------------------------------------------------------
+// Match: Hash
+//
+// Resolves JSON Pointer fragments only. Plain anchor-style fragments
+// (no leading '/') are handled exclusively by MatchAnchor and
+// MatchDynamicAnchor to prevent accidentally resolving an anchor name
+// as a pointer into the schema tree.
+//
+// ------------------------------------------------------------------
+function MatchHash(schema, _base, ref) {
+    if (ref.href.endsWith('#'))
+        return schema;
+    if (!ref.hash.startsWith('#'))
+        return undefined;
+    const fragment = decodeURIComponent(ref.hash.slice(1));
+    if (!fragment.startsWith('/'))
+        return undefined;
+    return Pointer.Get(schema, fragment);
+}
+// ------------------------------------------------------------------
+// Match
+// ------------------------------------------------------------------
+function Match(schema, base, ref) {
+    if (Schema.IsId(schema)) {
+        const result = MatchId(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsAnchor(schema)) {
+        const result = MatchAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Schema.IsDynamicAnchor(schema)) {
+        const result = MatchDynamicAnchor(schema, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    return MatchHash(schema, base, ref);
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+function FromArray(schema, base, ref) {
+    return schema.reduce((result, item) => {
+        const match = FromValue(item, base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+function SkipProperty(key) {
+    // these are explicit data encoded in a schema, they should not
+    // be considered valid targets used for de-referencing.
+    return Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum');
+}
+function FromObject(schema, base, ref) {
+    return Guard.Keys(schema).reduce((result, key) => {
+        if (SkipProperty(key))
+            return result;
+        const match = FromValue(schema[key], base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
+}
+// ------------------------------------------------------------------
+// FromValue
+// ------------------------------------------------------------------
+function FromValue(schema, base, ref) {
+    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema)
+        ? new URL(schema.$id, base.href)
+        : base;
+    if (Schema.IsSchemaObject(schema)) {
+        const result = Match(schema, nextBase, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Guard.IsArray(schema))
+        return FromArray(schema, nextBase, ref);
+    if (Guard.IsObject(schema))
+        return FromObject(schema, nextBase, ref);
+    return undefined;
+}
+// ------------------------------------------------------------------
+// CanonicalHref
+//
+// Returns the URL's href with its fragment removed, as a string.
+// This is the canonical URI a document is identified and keyed by
+// in context.
+// ------------------------------------------------------------------
+function CanonicalHref(url) {
+    return url.href.split('#')[0];
+}
+// ------------------------------------------------------------------
+// RefContext: Phase 1
+//
+// A ContextRef targets a simple key name in the context and is
+// used for fast resolution of inline referential TypeBox types.
+// ------------------------------------------------------------------
+function RefContext(context, ref) {
+    return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
+}
+// ------------------------------------------------------------------
+// RefLocal: Phase 2
+//
+// Resolves the ref's fragment within the current schema resource,
+// either as a JSON Pointer or a plain-name fragment ($anchor,
+// $dynamicAnchor), per the JSON Schema spec.
+// ------------------------------------------------------------------
+function RefLocal(schema, base, ref) {
+    return FromValue(schema, base, ref);
+}
+// ------------------------------------------------------------------
+// RefRemote: Phase 3
+//
+// Locates the schema resource identified by the ref's base URI, then
+// resolves the ref's fragment within that resource, either as a JSON
+// Pointer or a plain-name fragment, per the JSON Schema spec.
+// ------------------------------------------------------------------
+function RefRemote(context, base, ref) {
+    const targetDocumentHref = CanonicalHref(ref);
+    if (Guard.IsEqual(targetDocumentHref, CanonicalHref(base)))
+        return undefined;
+    if (!Guard.HasPropertyKey(context, targetDocumentHref))
+        return undefined;
+    const remoteSchema = context[targetDocumentHref];
+    const remoteBase = (Schema.IsSchemaObject(remoteSchema) && Schema.IsId(remoteSchema)) ? new URL(remoteSchema.$id, DefaultBase.href) : new URL(targetDocumentHref);
+    return FromValue(remoteSchema, remoteBase, ref);
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+export function Ref(context, schema, ref) {
+    const initialBase = Schema.IsId(schema) ? new URL(schema.$id, DefaultBase.href) : DefaultBase;
+    const initialRef = new URL(ref, initialBase.href);
+    return RefContext(context, ref) ?? RefLocal(schema, initialBase, initialRef) ?? RefRemote(context, initialBase, initialRef);
+}
+// ------------------------------------------------------------------
+// DynamicRef
+// ------------------------------------------------------------------
+export function DynamicRef(context, root, base, dynamicRef, dynamicAnchors) {
+    // Resolve the static target using either the local base (for fragment‑only references)
+    // or the document root (for absolute URI references).
+    const fragmentTarget = dynamicRef.$dynamicRef.startsWith('#')
+        ? Ref(context, base, dynamicRef.$dynamicRef)
+        : Ref(context, root, dynamicRef.$dynamicRef);
+    if (Guard.IsUndefined(fragmentTarget))
+        return undefined;
+    // Dynamic override only applies if the resolved target itself declares a $dynamicAnchor.
+    // If it does not, return the static target unchanged.
+    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
+        return fragmentTarget;
+    // Extract the fragment portion of the reference. According to the test suite,
+    // only plain fragment names (e.g., "#foo") trigger the dynamic scope; JSON 
+    // Pointer fragments (e.g., "#/definitions/foo") bypass dynamic resolution.
+    const fragment = new URL(dynamicRef.$dynamicRef, DefaultBase).hash;
+    if (fragment.startsWith('#/'))
+        return fragmentTarget;
+    // Search the live dynamic anchor stack for a schema whose $dynamicAnchor matches the
+    // target's $dynamicAnchor. The stack reflects the current evaluation path, and
+    // find() returns the outermost (first encountered) match, which is the correct
+    // lexical scope per the specification.
+    const anchorTarget = dynamicAnchors.find(anchor => anchor.$dynamicAnchor === fragmentTarget.$dynamicAnchor);
+    return anchorTarget ?? fragmentTarget;
+}

package/node_modules/typebox/build/schema/static/propertyNames.d.mts

@@ -0,0 +1,5 @@
+import type { XSchema } from '../types/schema.mjs';
+import type { XStaticSchema } from './schema.mjs';
+export type XStaticPropertyNames<Stack extends string[], Root extends XSchema, Schema extends XSchema, StaticKey extends unknown = XStaticSchema<Stack, Root, Schema>, Result extends Record<string, unknown> = [StaticKey] extends [PropertyKey] ? {
+    [Key in StaticKey]?: unknown;
+} : {}> = Result;

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

@@ -0,0 +1,3 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+export {};

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

@@ -9,6 +9,7 @@ import type { XOneOf } from '../types/oneOf.mjs';
 import type { XPatternProperties } from '../types/patternProperties.mjs';
 import type { XPrefixItems } from '../types/prefixItems.mjs';
 import type { XProperties } from '../types/properties.mjs';
+import type { XPropertyNames } from '../types/propertyNames.mjs';
 import type { XRef } from '../types/ref.mjs';
 import type { XRequired } from '../types/required.mjs';
 import type { XSchema } from '../types/schema.mjs';
@@ -25,6 +26,7 @@ import type { XStaticOneOf } from './oneOf.mjs';
 import type { XStaticPatternProperties } from './patternProperties.mjs';
 import type { XStaticPrefixItems } from './prefixItems.mjs';
 import type { XStaticProperties } from './properties.mjs';
+import type { XStaticPropertyNames } from './propertyNames.mjs';
 import type { XStaticRef } from './ref.mjs';
 import type { XStaticRequired } from './required.mjs';
 import type { XStaticType } from './type.mjs';
@@ -41,6 +43,7 @@ type XFromKeywords<Stack extends string[], Root extends XSchema, Schema extends
     Schema extends XPatternProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticPatternProperties<Stack, Root, Properties> : unknown,
     Schema extends XPrefixItems<infer Types extends XSchema[]> ? XStaticPrefixItems<Stack, Root, Schema, Types> : unknown,
     Schema extends XProperties<infer Properties extends Record<PropertyKey, XSchema>> ? XStaticProperties<Stack, Root, Schema, Properties> : unknown,
+    Schema extends XPropertyNames<infer Type extends XSchema> ? XStaticPropertyNames<Stack, Root, Type> : unknown,
     Schema extends XRef<infer Ref extends string> ? XStaticRef<Stack, Root, Ref> : unknown,
     Schema extends XRequired<infer Keys extends string[]> ? XStaticRequired<Stack, Root, Schema, Keys> : unknown,
     Schema extends XType<infer TypeName extends string[] | string> ? XStaticType<TypeName> : unknown,

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

@@ -6,8 +6,6 @@ export * from './anchor.mjs';
 export * from './anyOf.mjs';
 export * from './const.mjs';
 export * from './contains.mjs';
-export * from './contentEncoding.mjs';
-export * from './contentMediaType.mjs';
 export * from './default.mjs';
 export * from './defs.mjs';
 export * from './dependencies.mjs';

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

@@ -12,8 +12,6 @@ export * from './anchor.mjs';
 export * from './anyOf.mjs';
 export * from './const.mjs';
 export * from './contains.mjs';
-export * from './contentEncoding.mjs';
-export * from './contentMediaType.mjs';
 export * from './default.mjs';
 export * from './defs.mjs';
 export * from './dependencies.mjs';