@openclaw/slack 2026.10.10 → 2026.11.5-beta.1

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

@@ -1,7 +1,7 @@
 import * as Idna from './idna/index.mjs';
 /**
  * Returns true if the value is a valid internationalized (IDN) hostname.
- * @specification https://tools.ietf.org/html/rfc3490
+ * @specification https://datatracker.ietf.org/doc/html/rfc5890
  * @specification https://tools.ietf.org/html/rfc5891
  * @specification https://tools.ietf.org/html/rfc5892
  * @specification https://tools.ietf.org/html/rfc5893

package/node_modules/typebox/build/format/ipv4.d.mts

@@ -1,5 +1,5 @@
 /**
- * Returns true if the value is a IPV4 address
- * @specification http://tools.ietf.org/html/rfc2673#section-3.2
+ * Returns true if the value is an IPv4 address
+ * @specification https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2
  */
 export declare function IsIPv4(value: string): boolean;

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

@@ -1,7 +1,7 @@
 const IPv4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
 /**
- * Returns true if the value is a IPV4 address
- * @specification http://tools.ietf.org/html/rfc2673#section-3.2
+ * Returns true if the value is an IPv4 address
+ * @specification https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2
  */
 export function IsIPv4(value) {
     return IPv4.test(value);

package/node_modules/typebox/build/format/ipv6.d.mts

@@ -1,5 +1,5 @@
 /**
  * Returns true if the value is an IPv6 address
- * @specification http://tools.ietf.org/html/rfc2373#section-2.2
+ * @specification https://datatracker.ietf.org/doc/html/rfc4291#section-2.2
  */
 export declare function IsIPv6(value: string): boolean;

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

@@ -1,7 +1,7 @@
 const IPv6 = /^(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:)?[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)$/i;
 /**
  * Returns true if the value is an IPv6 address
- * @specification http://tools.ietf.org/html/rfc2373#section-2.2
+ * @specification https://datatracker.ietf.org/doc/html/rfc4291#section-2.2
  */
 export function IsIPv6(value) {
     return IPv6.test(value);

package/node_modules/typebox/build/format/relative_json_pointer.d.mts

@@ -1,6 +1,6 @@
 /**
- * Returns true if the value is a relative json pointer
- * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * Returns true if the value is a relative JSON Pointer
+ * @specification https://datatracker.ietf.org/doc/html/draft-handrews-relative-json-pointer/
  * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsRelativeJsonPointer(value: string): boolean;

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

@@ -1,7 +1,7 @@
 const RelativeJsonPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
 /**
- * Returns true if the value is a relative json pointer
- * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * Returns true if the value is a relative JSON Pointer
+ * @specification https://datatracker.ietf.org/doc/html/draft-handrews-relative-json-pointer/
  * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsRelativeJsonPointer(value) {

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

@@ -106,6 +106,7 @@ export function Build(...args) {
         2: (context, schema) => [context, schema],
         1: (schema) => [{}, schema]
     });
+    Engine.ResetUnique();
     Engine.ResetExternal();
     Engine.ResetFunctions();
     const stack = Engine.Stack(context, schema);

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

@@ -1,2 +1,4 @@
-/** Returns a Unique Variable Name */
-export declare function Unique(): string;
+/** Creates a unique variable name */
+export declare function CreateUnique(): string;
+/** Resets the unique variable name counter */
+export declare function ResetUnique(): void;

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

@@ -1,5 +1,9 @@
 let index = 0;
-/** Returns a Unique Variable Name */
-export function Unique() {
-    return `var_${index++}`;
+/** Creates a unique variable name */
+export function CreateUnique() {
+    return `unique_${index++}`;
+}
+/** Resets the unique variable name counter */
+export function ResetUnique() {
+    index = 0;
 }

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -13,14 +13,14 @@ function IsValid(schema) {
 // Build
 // ------------------------------------------------------------------
 function BuildAdditionalItemsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique(), Unique()];
+    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
     const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
     const addIndex = context.AddIndex(index);
     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 [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
     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));

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

@@ -1,9 +1,6 @@
 import * as Schema from '../types/index.mjs';
 import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function CanAdditionalPropertiesFast(_context: BuildContext, schema: Schema.XAdditionalProperties, _value: string): schema is Schema.XAdditionalProperties & Schema.XRequired;
-export declare function BuildAdditionalPropertiesFast(_context: BuildContext, schema: Schema.XAdditionalProperties & Schema.XRequired, value: string): string;
-export declare function BuildAdditionalPropertiesStandard(stack: Stack.XStack, context: BuildContext, schema: Schema.XAdditionalProperties, value: string): string;
 export declare function BuildAdditionalProperties(stack: Stack.XStack, context: BuildContext, schema: Schema.XAdditionalProperties, value: string): string;
 export declare function CheckAdditionalProperties(stack: Stack.XStack, context: CheckContext, schema: Schema.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
 export declare function ErrorAdditionalProperties(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;

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

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

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -13,13 +13,13 @@ function IsValid(schema) {
 // Build
 // ------------------------------------------------------------------
 function BuildContainsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique(), Unique()];
+    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
     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 [item] = [Unique.CreateUnique()];
     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);

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

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

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

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

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

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
+import * as Unique from './_unique.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
@@ -44,14 +45,16 @@ function ErrorItemsSized(stack, context, schemaPath, instancePath, 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 [item] = [Unique.CreateUnique()];
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, item);
     const addIndex = context.AddIndex('index');
-    return E.Every(value, E.Constant(offset), ['element', 'index'], E.And(isSchema, addIndex));
+    return E.Every(value, E.Constant(offset), [item, '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);
+    const [item] = [Unique.CreateUnique()];
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, item);
+    return E.Every(value, E.Constant(offset), [item, 'index'], isSchema);
 }
 function BuildItemsUnsized(stack, context, schema, value) {
     return context.UseUnevaluated()

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -15,7 +15,7 @@ function IsValid(schema) {
 export function BuildMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const [item] = [Unique()];
+    const [item] = [Unique.CreateUnique()];
     const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.IsLessEqualThan(count, E.Constant(schema.maxContains));
 }

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -13,12 +13,12 @@ function IsValid(schema) {
 // Build
 // ------------------------------------------------------------------
 function BuildMinContainsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique(), Unique()];
+    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
     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 [item] = [Unique.CreateUnique()];
     const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
     return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
 }

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

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Reducer } from './_reducer.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { CheckContext, ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
@@ -11,7 +11,7 @@ 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 [result] = [Unique.CreateUnique()];
     const results = E.ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(stack, context, schema, value)));
     const count = E.Counted(results, [result, '_'], E.IsEqual(result, E.Constant(true)));
     return E.IsEqual(count, E.Constant(1));

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

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
+import * as Unique from './_unique.mjs';
 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';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
@@ -10,7 +10,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 export function BuildPatternProperties(stack, context, schema, value) {
     return E.ReduceAnd(G.Entries(schema.patternProperties).map(([pattern, schema]) => {
-        const [key, prop] = [Unique(), Unique()];
+        const [key, prop] = [Unique.CreateUnique(), Unique.CreateUnique()];
         const regexp = Externals.CreateVariable(UnicodeRegExp(pattern));
         const notKey = E.Not(E.Call(E.Member(regexp, 'test'), [key]));
         const isSchema = BuildSchemaPushStack(stack, context, schema, prop);

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

@@ -1,13 +1,13 @@
 // deno-fmt-ignore-file
 import * as Pathing from './_pathing.mjs';
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildPropertyNames(stack, context, schema, value) {
-    const [key, _index] = [Unique(), Unique()];
+    const [key, _index] = [Unique.CreateUnique(), Unique.CreateUnique()];
     return E.Every(E.Keys(value), E.Constant(0), [key, _index], BuildSchema(stack, context, schema.propertyNames, key));
 }
 // ------------------------------------------------------------------

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

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
@@ -7,7 +7,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildUnevaluatedItems(stack, context, schema, value) {
-    const [index, item] = [Unique(), Unique()];
+    const [index, item] = [Unique.CreateUnique(), Unique.CreateUnique()];
     const indices = E.Call(E.Member('context', 'GetIndices'), []);
     const hasIndex = E.Call(E.Member('indices', 'has'), [index]);
     const isSchema = BuildSchema(stack, context, schema.unevaluatedItems, item);

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

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { Unique } from './_unique.mjs';
+import * as Unique from './_unique.mjs';
 import { ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
@@ -7,7 +7,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // Build
 // ------------------------------------------------------------------
 export function BuildUnevaluatedProperties(stack, context, schema, value) {
-    const [key, prop] = [Unique(), Unique()];
+    const [key, prop] = [Unique.CreateUnique(), Unique.CreateUnique()];
     const keys = E.Call(E.Member('context', 'GetKeys'), []);
     const hasKey = E.Call(E.Member('keys', 'has'), [key]);
     const addKey = E.Call(E.Member('context', 'AddKey'), [key]);

package/node_modules/typebox/build/system/hashing/hash.mjs

@@ -1,16 +1,16 @@
 // deno-fmt-ignore-file
 import { Unreachable } from '../unreachable/index.mjs';
-import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+import { GlobalsGuard, Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // InstanceKeys
 //
-// Retrieves all enumerable and non-enumerable own property keys 
-// and inherited prototype keys (excluding symbols and the 'constructor') 
+// Retrieves all enumerable and non-enumerable own property keys
+// and inherited prototype keys (excluding symbols and the 'constructor')
 // from an object instance.
 //
-// This function is useful for differentiating between class instances 
-// based on their structural keys rather than relying on the 
-// constructor name. It provides a more reliable structural comparison 
+// This function is useful for differentiating between class instances
+// based on their structural keys rather than relying on the
+// constructor name. It provides a more reliable structural comparison
 // by capturing both own and prototype properties.
 //
 // ------------------------------------------------------------------
@@ -40,38 +40,57 @@ function IsIEEE754(value) {
 // ------------------------------------------------------------------
 // ByteMarker
 // ------------------------------------------------------------------
-var ByteMarker;
-(function (ByteMarker) {
-    ByteMarker[ByteMarker["Array"] = 0] = "Array";
-    ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
-    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
-    ByteMarker[ByteMarker["Date"] = 3] = "Date";
-    ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
-    ByteMarker[ByteMarker["Function"] = 5] = "Function";
-    ByteMarker[ByteMarker["Null"] = 6] = "Null";
-    ByteMarker[ByteMarker["Number"] = 7] = "Number";
-    ByteMarker[ByteMarker["Object"] = 8] = "Object";
-    ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
-    ByteMarker[ByteMarker["String"] = 10] = "String";
-    ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
-    ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
-    ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
-})(ByteMarker || (ByteMarker = {}));
+const ByteMarker = {
+    Array: 0x0,
+    BigInt: 0x1,
+    Boolean: 0x2,
+    Date: 0x3,
+    Constructor: 0x4,
+    Function: 0x5,
+    Null: 0x6,
+    Number: 0x7,
+    Object: 0x8,
+    RegExp: 0x9,
+    String: 0xA,
+    Symbol: 0xB,
+    TypeArray: 0xC,
+    Undefined: 0xD
+};
 // ------------------------------------------------------------------
 // State
 // ------------------------------------------------------------------
-let Accumulator = BigInt('14695981039346656037');
-const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)];
-const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+//
+// The 64-bit accumulator is held as four 16-bit limbs (A0 is the least
+// significant) so the FNV1A64 operation can be computed with number
+// arithmetic, avoiding a BigInt multiply and modulo for every byte.
+//
+// Offset: 14695981039346656037 (0xCBF29CE484222325)
+//
+// ------------------------------------------------------------------
+let A0 = 0x2325, A1 = 0x8422, A2 = 0x9CE4, A3 = 0xCBF2;
 const F64 = new Float64Array(1);
 const F64In = new DataView(F64.buffer);
 const F64Out = new Uint8Array(F64.buffer);
 // ------------------------------------------------------------------
 // Operation
+//
+// Prime: 1099511628211 (0x100000001B3 = 2^40 + 0x1B3)
+//
+// The multiply is computed as (A * 0x1B3) + (A << 40) modulo 2^64, 
+// where (A << 40) adds (A0 << 8) to the third limb and (A1 << 8) 
+// to the fourth.
+//
 // ------------------------------------------------------------------
 function FNV1A64_OP(byte) {
-    Accumulator = Accumulator ^ Bytes[byte];
-    Accumulator = (Accumulator * Prime) % Size;
+    const L0 = A0 ^ byte;
+    const T0 = L0 * 0x1B3;
+    const T1 = A1 * 0x1B3 + (T0 >>> 16);
+    const T2 = A2 * 0x1B3 + (T1 >>> 16) + (L0 << 8);
+    const T3 = A3 * 0x1B3 + (T2 >>> 16) + (A1 << 8);
+    A0 = T0 & 0xFFFF;
+    A1 = T1 & 0xFFFF;
+    A2 = T2 & 0xFFFF;
+    A3 = T3 & 0xFFFF;
 }
 // ------------------------------------------------------------------
 // Array
@@ -159,8 +178,15 @@ function FromRegExp(value) {
 const encoder = new TextEncoder();
 function FromString(value) {
     FNV1A64_OP(ByteMarker.String);
-    for (const byte of encoder.encode(value)) {
-        FNV1A64_OP(byte);
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code > 0x7F) {
+            for (const byte of encoder.encode(value.slice(i))) {
+                FNV1A64_OP(byte);
+            }
+            return;
+        }
+        FNV1A64_OP(code);
     }
 }
 // ------------------------------------------------------------------
@@ -220,13 +246,16 @@ function FromValue(value) {
 // ------------------------------------------------------------------
 // Hash
 // ------------------------------------------------------------------
+function Hex(limb) {
+    return limb.toString(16).padStart(4, '0');
+}
 /** Generates a FNV1A-64 non cryptographic hash of the given value */
 export function HashCode(value) {
-    Accumulator = BigInt('14695981039346656037');
-    FromValue(value);
-    return Accumulator;
+    return BigInt(`0x${Hash(value)}`);
 }
 /** Generates a FNV1A-64 non cryptographic hash of the given value */
 export function Hash(value) {
-    return HashCode(value).toString(16).padStart(16, '0');
+    A0 = 0x2325, A1 = 0x8422, A2 = 0x9CE4, A3 = 0xCBF2;
+    FromValue(value);
+    return `${Hex(A3)}${Hex(A2)}${Hex(A1)}${Hex(A0)}`;
 }

package/node_modules/typebox/build/system/locale/en_US.mjs

@@ -33,7 +33,8 @@ export function en_US(error) {
         case 'unevaluatedProperties': return 'must not have unevaluated properties';
         case 'uniqueItems': return `must not have duplicate items`;
         case '~refine': return error.params.message;
-        // deno-coverage-ignore - unreachable
+        // deno-coverage-ignore-start - unreachable
         default: return 'an unknown validation error occurred';
+        // deno-coverage-ignore-stop
     }
 }

package/node_modules/typebox/build/system/memory/assign.d.mts

@@ -1,14 +1,8 @@
 type ObjectLike = Record<PropertyKey, any>;
-/**
- * Performs an Object assign using the Left and Right object types. We track this operation as it
- * creates a new GC handle per assignment.
- */
+/** Performs an Object assign using the Left and Right object types. */
 export type TAssign<Left extends ObjectLike, Right extends ObjectLike, Assigned extends ObjectLike = Omit<Left, keyof Right> & Right> = {
     [Key in keyof Assigned]: Assigned[Key];
 } & {};
-/**
- * Performs an Object assign using the Left and Right object types. We track this operation as it
- * creates a new GC handle per assignment.
- */
+/** Performs an Object assign using the Left and Right object types. */
 export declare function Assign<Left extends ObjectLike, Right extends ObjectLike>(left: Left, right: Right): TAssign<Left, Right>;
 export {};

package/node_modules/typebox/build/system/memory/assign.mjs

@@ -1,12 +1,19 @@
 // deno-lint-ignore-file ban-types no-explicit-any
 // deno-fmt-ignore-file
 import { Metrics } from './metrics.mjs';
-import { Freeze } from './freeze.mjs';
-/**
- * Performs an Object assign using the Left and Right object types. We track this operation as it
- * creates a new GC handle per assignment.
- */
+import { Finalize } from './finalize.mjs';
+import { Keys } from './keys.mjs';
+/** Performs an Object assign using the Left and Right object types. */
 export function Assign(left, right) {
     Metrics.assign += 1;
-    return Freeze({ ...left, ...right });
+    const result = {}, rightKeys = Keys(right), leftKeys = Keys(left);
+    for (const key of leftKeys) {
+        if (rightKeys.includes(key))
+            continue;
+        Object.defineProperty(result, key, Object.getOwnPropertyDescriptor(left, key));
+    }
+    for (const key of rightKeys) {
+        Object.defineProperty(result, key, Object.getOwnPropertyDescriptor(right, key));
+    }
+    return Finalize(result);
 }

package/node_modules/typebox/build/system/memory/clone.d.mts

@@ -1,5 +1,4 @@
-/**
- * Returns a Clone of the given value. This function is similar to structuredClone()
- * but also supports deep cloning instances of Map, Set and TypeArray.
- */
-export declare function Clone<Value extends unknown = unknown>(value: Value): Value;
+type ObjectLike = Record<PropertyKey, any>;
+/** Returns a shallow clone of the given object. */
+export declare function Clone<Value extends ObjectLike = ObjectLike>(value: Value): Value;
+export {};