claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/memory/high-performance-serialization.js

@@ -5,628 +5,766 @@
  * optimized for nanosecond-level performance in the memory store. The
  * algorithms are designed to minimize CPU cycles, memory allocations,
  * and cache misses while maintaining excellent hash distribution.
- */ /**
+ */
+
+/**
  * High-performance hash functions optimized for different key types
- */ export class HighPerformanceHash {
-    /**
+ */
+export class HighPerformanceHash {
+  /**
    * XXHash32 - Extremely fast hash function for small to medium keys
    * Optimized for keys up to 64 bytes with excellent distribution
-   */ static xxhash32(key, seed = 0x811C9DC5) {
-        if (typeof key === 'string') {
-            return this.xxhash32String(key, seed);
-        } else if (key instanceof Uint8Array) {
-            return this.xxhash32Bytes(key, seed);
-        } else {
-            return this.xxhash32Generic(key, seed);
-        }
-    }
-    /**
+   */
+  static xxhash32(key, seed = 0x811C9DC5) {
+    if (typeof key === 'string') {
+      return this.xxhash32String(key, seed);
+    } else if (key instanceof Uint8Array) {
+      return this.xxhash32Bytes(key, seed);
+    } else {
+      return this.xxhash32Generic(key, seed);
+    }
+  }
+
+  /**
    * Optimized XXHash32 for string keys
-   */ static xxhash32String(str, seed = 0x811C9DC5) {
-        const PRIME32_1 = 0x9E3779B1;
-        const PRIME32_2 = 0x85EBCA77;
-        const PRIME32_3 = 0xC2B2AE3D;
-        const PRIME32_4 = 0x27D4EB2F;
-        const PRIME32_5 = 0x165667B1;
-        let hash = seed + PRIME32_5 >>> 0;
-        const len = str.length;
-        let i = 0;
-        // Process 4-character chunks
-        while(i <= len - 4){
-            let chunk = (str.charCodeAt(i) | str.charCodeAt(i + 1) << 8 | str.charCodeAt(i + 2) << 16 | str.charCodeAt(i + 3) << 24) >>> 0;
-            chunk = Math.imul(chunk, PRIME32_2);
-            chunk = (chunk << 13 | chunk >>> 19) >>> 0;
-            chunk = Math.imul(chunk, PRIME32_1);
-            hash ^= chunk;
-            hash = (hash << 13 | hash >>> 19) >>> 0;
-            hash = Math.imul(hash, 5) + 0xE6546B64 >>> 0;
-            i += 4;
-        }
-        // Process remaining characters
-        while(i < len){
-            let char = str.charCodeAt(i) >>> 0;
-            char = Math.imul(char, PRIME32_5);
-            char = (char << 11 | char >>> 21) >>> 0;
-            hash ^= char;
-            hash = (hash << 13 | hash >>> 19) >>> 0;
-            hash = Math.imul(hash, PRIME32_1);
-            i++;
-        }
-        // Final avalanche
-        hash ^= len;
-        hash ^= hash >>> 16;
-        hash = Math.imul(hash, PRIME32_2);
-        hash ^= hash >>> 13;
-        hash = Math.imul(hash, PRIME32_3);
-        hash ^= hash >>> 16;
-        return hash >>> 0;
-    }
-    /**
+   */
+  static xxhash32String(str, seed = 0x811C9DC5) {
+    const PRIME32_1 = 0x9E3779B1;
+    const PRIME32_2 = 0x85EBCA77;
+    const PRIME32_3 = 0xC2B2AE3D;
+    const PRIME32_4 = 0x27D4EB2F;
+    const PRIME32_5 = 0x165667B1;
+
+    let hash = (seed + PRIME32_5) >>> 0;
+    const len = str.length;
+    let i = 0;
+
+    // Process 4-character chunks
+    while (i <= len - 4) {
+      let chunk = (str.charCodeAt(i) |
+                  (str.charCodeAt(i + 1) << 8) |
+                  (str.charCodeAt(i + 2) << 16) |
+                  (str.charCodeAt(i + 3) << 24)) >>> 0;
+
+      chunk = Math.imul(chunk, PRIME32_2);
+      chunk = ((chunk << 13) | (chunk >>> 19)) >>> 0;
+      chunk = Math.imul(chunk, PRIME32_1);
+
+      hash ^= chunk;
+      hash = ((hash << 13) | (hash >>> 19)) >>> 0;
+      hash = (Math.imul(hash, 5) + 0xE6546B64) >>> 0;
+      i += 4;
+    }
+
+    // Process remaining characters
+    while (i < len) {
+      let char = str.charCodeAt(i) >>> 0;
+      char = Math.imul(char, PRIME32_5);
+      char = ((char << 11) | (char >>> 21)) >>> 0;
+      hash ^= char;
+      hash = ((hash << 13) | (hash >>> 19)) >>> 0;
+      hash = Math.imul(hash, PRIME32_1);
+      i++;
+    }
+
+    // Final avalanche
+    hash ^= len;
+    hash ^= hash >>> 16;
+    hash = Math.imul(hash, PRIME32_2);
+    hash ^= hash >>> 13;
+    hash = Math.imul(hash, PRIME32_3);
+    hash ^= hash >>> 16;
+
+    return hash >>> 0;
+  }
+
+  /**
    * Optimized XXHash32 for byte arrays
-   */ static xxhash32Bytes(bytes, seed = 0x811C9DC5) {
-        const PRIME32_1 = 0x9E3779B1;
-        const PRIME32_2 = 0x85EBCA77;
-        const PRIME32_3 = 0xC2B2AE3D;
-        const PRIME32_4 = 0x27D4EB2F;
-        const PRIME32_5 = 0x165667B1;
-        let hash = seed + PRIME32_5 >>> 0;
-        const len = bytes.length;
-        let i = 0;
-        // Process 4-byte chunks using DataView for optimal performance
-        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        while(i <= len - 4){
-            let chunk = view.getUint32(i, true); // little-endian
-            chunk = Math.imul(chunk, PRIME32_2);
-            chunk = (chunk << 13 | chunk >>> 19) >>> 0;
-            chunk = Math.imul(chunk, PRIME32_1);
-            hash ^= chunk;
-            hash = (hash << 13 | hash >>> 19) >>> 0;
-            hash = Math.imul(hash, 5) + 0xE6546B64 >>> 0;
-            i += 4;
-        }
-        // Process remaining bytes
-        while(i < len){
-            let byte = bytes[i] >>> 0;
-            byte = Math.imul(byte, PRIME32_5);
-            byte = (byte << 11 | byte >>> 21) >>> 0;
-            hash ^= byte;
-            hash = (hash << 13 | hash >>> 19) >>> 0;
-            hash = Math.imul(hash, PRIME32_1);
-            i++;
-        }
-        // Final avalanche
-        hash ^= len;
-        hash ^= hash >>> 16;
-        hash = Math.imul(hash, PRIME32_2);
-        hash ^= hash >>> 13;
-        hash = Math.imul(hash, PRIME32_3);
-        hash ^= hash >>> 16;
-        return hash >>> 0;
-    }
-    /**
+   */
+  static xxhash32Bytes(bytes, seed = 0x811C9DC5) {
+    const PRIME32_1 = 0x9E3779B1;
+    const PRIME32_2 = 0x85EBCA77;
+    const PRIME32_3 = 0xC2B2AE3D;
+    const PRIME32_4 = 0x27D4EB2F;
+    const PRIME32_5 = 0x165667B1;
+
+    let hash = (seed + PRIME32_5) >>> 0;
+    const len = bytes.length;
+    let i = 0;
+
+    // Process 4-byte chunks using DataView for optimal performance
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+    while (i <= len - 4) {
+      let chunk = view.getUint32(i, true); // little-endian
+
+      chunk = Math.imul(chunk, PRIME32_2);
+      chunk = ((chunk << 13) | (chunk >>> 19)) >>> 0;
+      chunk = Math.imul(chunk, PRIME32_1);
+
+      hash ^= chunk;
+      hash = ((hash << 13) | (hash >>> 19)) >>> 0;
+      hash = (Math.imul(hash, 5) + 0xE6546B64) >>> 0;
+      i += 4;
+    }
+
+    // Process remaining bytes
+    while (i < len) {
+      let byte = bytes[i] >>> 0;
+      byte = Math.imul(byte, PRIME32_5);
+      byte = ((byte << 11) | (byte >>> 21)) >>> 0;
+      hash ^= byte;
+      hash = ((hash << 13) | (hash >>> 19)) >>> 0;
+      hash = Math.imul(hash, PRIME32_1);
+      i++;
+    }
+
+    // Final avalanche
+    hash ^= len;
+    hash ^= hash >>> 16;
+    hash = Math.imul(hash, PRIME32_2);
+    hash ^= hash >>> 13;
+    hash = Math.imul(hash, PRIME32_3);
+    hash ^= hash >>> 16;
+
+    return hash >>> 0;
+  }
+
+  /**
    * Generic XXHash32 for any serializable value
-   */ static xxhash32Generic(value, seed = 0x811C9DC5) {
-        const serialized = FastSerializer.serialize(value);
-        return this.xxhash32Bytes(serialized, seed);
-    }
-    /**
+   */
+  static xxhash32Generic(value, seed = 0x811C9DC5) {
+    const serialized = FastSerializer.serialize(value);
+    return this.xxhash32Bytes(serialized, seed);
+  }
+
+  /**
    * FNV-1a hash - Fast and simple, good for short keys
-   */ static fnv1a32(key) {
-        let hash = 0x811C9DC5;
-        if (typeof key === 'string') {
-            for(let i = 0; i < key.length; i++){
-                hash ^= key.charCodeAt(i);
-                hash = Math.imul(hash, 0x01000193);
-            }
-        } else if (key instanceof Uint8Array) {
-            for(let i = 0; i < key.length; i++){
-                hash ^= key[i];
-                hash = Math.imul(hash, 0x01000193);
-            }
-        } else {
-            const serialized = FastSerializer.serialize(key);
-            return this.fnv1a32(serialized);
-        }
-        return hash >>> 0;
-    }
-    /**
+   */
+  static fnv1a32(key) {
+    let hash = 0x811C9DC5;
+
+    if (typeof key === 'string') {
+      for (let i = 0; i < key.length; i++) {
+        hash ^= key.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+      }
+    } else if (key instanceof Uint8Array) {
+      for (let i = 0; i < key.length; i++) {
+        hash ^= key[i];
+        hash = Math.imul(hash, 0x01000193);
+      }
+    } else {
+      const serialized = FastSerializer.serialize(key);
+      return this.fnv1a32(serialized);
+    }
+
+    return hash >>> 0;
+  }
+
+  /**
    * CityHash32 variant - Good distribution for medium keys
-   */ static cityHash32(key) {
-        const bytes = typeof key === 'string' ? new TextEncoder().encode(key) : key;
-        const len = bytes.length;
-        if (len <= 4) return this.cityHash32Short(bytes);
-        if (len <= 8) return this.cityHash32Medium(bytes);
-        return this.cityHash32Long(bytes);
-    }
-    static cityHash32Short(bytes) {
-        const len = bytes.length;
-        let a = len;
-        let b = len * 5;
-        let c = 9;
-        if (len >= 1) a ^= bytes[0];
-        if (len >= 2) b ^= bytes[1];
-        if (len >= 3) c ^= bytes[2];
-        if (len >= 4) a ^= bytes[3] << 24;
-        return this.cityHashFinalize32(a, b, c);
-    }
-    static cityHash32Medium(bytes) {
-        const len = bytes.length;
-        let a = len;
-        let b = len * 5;
-        let c = 9;
-        // Process first 4 bytes
-        if (len >= 4) {
-            a ^= (bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24) >>> 0;
-        }
-        // Process next 4 bytes
-        if (len >= 8) {
-            b ^= (bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24) >>> 0;
-        }
-        return this.cityHashFinalize32(a, b, c);
-    }
-    static cityHash32Long(bytes) {
-        // Simplified long version for demonstration
-        return this.xxhash32Bytes(bytes);
-    }
-    static cityHashFinalize32(a, b, c) {
-        a = Math.imul(a - c, 0x9E3779B1) >>> 0;
-        b = Math.imul(b - a, 0x9E3779B1) >>> 0;
-        c = Math.imul(c - b, 0x9E3779B1) >>> 0;
-        a = Math.imul(a - c, 0x9E3779B1) >>> 0;
-        b = Math.imul(b - a, 0x9E3779B1) >>> 0;
-        c = Math.imul(c - b, 0x9E3779B1) >>> 0;
-        return c >>> 0;
-    }
-    /**
+   */
+  static cityHash32(key) {
+    const bytes = typeof key === 'string' ? new TextEncoder().encode(key) : key;
+    const len = bytes.length;
+
+    if (len <= 4) return this.cityHash32Short(bytes);
+    if (len <= 8) return this.cityHash32Medium(bytes);
+    return this.cityHash32Long(bytes);
+  }
+
+  static cityHash32Short(bytes) {
+    const len = bytes.length;
+    let a = len;
+    let b = len * 5;
+    let c = 9;
+
+    if (len >= 1) a ^= bytes[0];
+    if (len >= 2) b ^= bytes[1];
+    if (len >= 3) c ^= bytes[2];
+    if (len >= 4) a ^= bytes[3] << 24;
+
+    return this.cityHashFinalize32(a, b, c);
+  }
+
+  static cityHash32Medium(bytes) {
+    const len = bytes.length;
+    let a = len;
+    let b = len * 5;
+    let c = 9;
+
+    // Process first 4 bytes
+    if (len >= 4) {
+      a ^= (bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24)) >>> 0;
+    }
+
+    // Process next 4 bytes
+    if (len >= 8) {
+      b ^= (bytes[4] | (bytes[5] << 8) | (bytes[6] << 16) | (bytes[7] << 24)) >>> 0;
+    }
+
+    return this.cityHashFinalize32(a, b, c);
+  }
+
+  static cityHash32Long(bytes) {
+    // Simplified long version for demonstration
+    return this.xxhash32Bytes(bytes);
+  }
+
+  static cityHashFinalize32(a, b, c) {
+    a = Math.imul(a - c, 0x9E3779B1) >>> 0;
+    b = Math.imul(b - a, 0x9E3779B1) >>> 0;
+    c = Math.imul(c - b, 0x9E3779B1) >>> 0;
+    a = Math.imul(a - c, 0x9E3779B1) >>> 0;
+    b = Math.imul(b - a, 0x9E3779B1) >>> 0;
+    c = Math.imul(c - b, 0x9E3779B1) >>> 0;
+    return c >>> 0;
+  }
+
+  /**
    * MurmurHash3 - Excellent distribution for hash tables
-   */ static murmurHash3_32(key, seed = 0x12345678) {
-        const bytes = typeof key === 'string' ? new TextEncoder().encode(key) : key;
-        const len = bytes.length;
-        const c1 = 0xCC9E2D51;
-        const c2 = 0x1B873593;
-        let h1 = seed;
-        let i = 0;
-        // Process 4-byte chunks
-        while(i <= len - 4){
-            let k1 = (bytes[i] | bytes[i + 1] << 8 | bytes[i + 2] << 16 | bytes[i + 3] << 24) >>> 0;
-            k1 = Math.imul(k1, c1);
-            k1 = (k1 << 15 | k1 >>> 17) >>> 0;
-            k1 = Math.imul(k1, c2);
-            h1 ^= k1;
-            h1 = (h1 << 13 | h1 >>> 19) >>> 0;
-            h1 = Math.imul(h1, 5) + 0xE6546B64 >>> 0;
-            i += 4;
-        }
-        // Process remaining bytes
-        let k1 = 0;
-        switch(len & 3){
-            case 3:
-                k1 ^= bytes[i + 2] << 16;
-            case 2:
-                k1 ^= bytes[i + 1] << 8;
-            case 1:
-                k1 ^= bytes[i];
-                k1 = Math.imul(k1, c1);
-                k1 = (k1 << 15 | k1 >>> 17) >>> 0;
-                k1 = Math.imul(k1, c2);
-                h1 ^= k1;
-        }
-        // Finalization
-        h1 ^= len;
-        h1 ^= h1 >>> 16;
-        h1 = Math.imul(h1, 0x85EBCA6B);
-        h1 ^= h1 >>> 13;
-        h1 = Math.imul(h1, 0xC2B2AE35);
-        h1 ^= h1 >>> 16;
-        return h1 >>> 0;
-    }
-    /**
+   */
+  static murmurHash3_32(key, seed = 0x12345678) {
+    const bytes = typeof key === 'string' ? new TextEncoder().encode(key) : key;
+    const len = bytes.length;
+    const c1 = 0xCC9E2D51;
+    const c2 = 0x1B873593;
+    let h1 = seed;
+    let i = 0;
+
+    // Process 4-byte chunks
+    while (i <= len - 4) {
+      let k1 = (bytes[i] | (bytes[i + 1] << 8) | (bytes[i + 2] << 16) | (bytes[i + 3] << 24)) >>> 0;
+
+      k1 = Math.imul(k1, c1);
+      k1 = ((k1 << 15) | (k1 >>> 17)) >>> 0;
+      k1 = Math.imul(k1, c2);
+
+      h1 ^= k1;
+      h1 = ((h1 << 13) | (h1 >>> 19)) >>> 0;
+      h1 = (Math.imul(h1, 5) + 0xE6546B64) >>> 0;
+      i += 4;
+    }
+
+    // Process remaining bytes
+    let k1 = 0;
+    switch (len & 3) {
+      case 3: k1 ^= bytes[i + 2] << 16;
+      case 2: k1 ^= bytes[i + 1] << 8;
+      case 1: k1 ^= bytes[i];
+        k1 = Math.imul(k1, c1);
+        k1 = ((k1 << 15) | (k1 >>> 17)) >>> 0;
+        k1 = Math.imul(k1, c2);
+        h1 ^= k1;
+    }
+
+    // Finalization
+    h1 ^= len;
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x85EBCA6B);
+    h1 ^= h1 >>> 13;
+    h1 = Math.imul(h1, 0xC2B2AE35);
+    h1 ^= h1 >>> 16;
+
+    return h1 >>> 0;
+  }
+
+  /**
    * Select optimal hash function based on key characteristics
-   */ static selectOptimalHash(key) {
-        if (typeof key === 'string') {
-            if (key.length <= 16) return 'fnv1a32';
-            if (key.length <= 64) return 'xxhash32';
-            return 'murmurHash3_32';
-        } else if (key instanceof Uint8Array) {
-            if (key.length <= 4) return 'fnv1a32';
-            if (key.length <= 32) return 'xxhash32';
-            return 'cityHash32';
-        } else {
-            return 'xxhash32'; // Default for generic objects
-        }
-    }
-    /**
+   */
+  static selectOptimalHash(key) {
+    if (typeof key === 'string') {
+      if (key.length <= 16) return 'fnv1a32';
+      if (key.length <= 64) return 'xxhash32';
+      return 'murmurHash3_32';
+    } else if (key instanceof Uint8Array) {
+      if (key.length <= 4) return 'fnv1a32';
+      if (key.length <= 32) return 'xxhash32';
+      return 'cityHash32';
+    } else {
+      return 'xxhash32'; // Default for generic objects
+    }
+  }
+
+  /**
    * Adaptive hash function that selects the best algorithm
-   */ static adaptiveHash(key, seed = 0x811C9DC5) {
-        const algorithm = this.selectOptimalHash(key);
-        switch(algorithm){
-            case 'fnv1a32':
-                return this.fnv1a32(key);
-            case 'xxhash32':
-                return this.xxhash32(key, seed);
-            case 'murmurHash3_32':
-                return this.murmurHash3_32(key, seed);
-            case 'cityHash32':
-                return this.cityHash32(key);
-            default:
-                return this.xxhash32(key, seed);
-        }
-    }
-}
+   */
+  static adaptiveHash(key, seed = 0x811C9DC5) {
+    const algorithm = this.selectOptimalHash(key);
+
+    switch (algorithm) {
+      case 'fnv1a32': return this.fnv1a32(key);
+      case 'xxhash32': return this.xxhash32(key, seed);
+      case 'murmurHash3_32': return this.murmurHash3_32(key, seed);
+      case 'cityHash32': return this.cityHash32(key);
+      default: return this.xxhash32(key, seed);
+    }
+  }
+}
+
 /**
  * Ultra-fast serialization for JavaScript values
- */ export class FastSerializer {
-    /**
+ */
+export class FastSerializer {
+  /**
    * Serialize JavaScript value to Uint8Array with minimal overhead
-   */ static serialize(value) {
-        const type = typeof value;
-        switch(type){
-            case 'string':
-                return this.serializeString(value);
-            case 'number':
-                return this.serializeNumber(value);
-            case 'boolean':
-                return this.serializeBoolean(value);
-            case 'object':
-                if (value === null) return this.serializeNull();
-                if (value instanceof Uint8Array) return value;
-                if (value instanceof ArrayBuffer) return new Uint8Array(value);
-                if (Array.isArray(value)) return this.serializeArray(value);
-                return this.serializeObject(value);
-            case 'undefined':
-                return this.serializeUndefined();
-            default:
-                return this.serializeString(String(value));
-        }
-    }
-    /**
+   */
+  static serialize(value) {
+    const type = typeof value;
+
+    switch (type) {
+      case 'string':
+        return this.serializeString(value);
+      case 'number':
+        return this.serializeNumber(value);
+      case 'boolean':
+        return this.serializeBoolean(value);
+      case 'object':
+        if (value === null) return this.serializeNull();
+        if (value instanceof Uint8Array) return value;
+        if (value instanceof ArrayBuffer) return new Uint8Array(value);
+        if (Array.isArray(value)) return this.serializeArray(value);
+        return this.serializeObject(value);
+      case 'undefined':
+        return this.serializeUndefined();
+      default:
+        return this.serializeString(String(value));
+    }
+  }
+
+  /**
    * High-performance string serialization using TextEncoder
-   */ static serializeString(str) {
-        // Cache TextEncoder instance for reuse
-        if (!this._textEncoder) {
-            this._textEncoder = new TextEncoder();
-        }
-        const encoded = this._textEncoder.encode(str);
-        const result = new Uint8Array(encoded.length + 5);
-        result[0] = 0x01; // String type marker
-        result[1] = encoded.length >>> 24 & 0xFF;
-        result[2] = encoded.length >>> 16 & 0xFF;
-        result[3] = encoded.length >>> 8 & 0xFF;
-        result[4] = encoded.length & 0xFF;
-        result.set(encoded, 5);
-        return result;
-    }
-    /**
+   */
+  static serializeString(str) {
+    // Cache TextEncoder instance for reuse
+    if (!this._textEncoder) {
+      this._textEncoder = new TextEncoder();
+    }
+
+    const encoded = this._textEncoder.encode(str);
+    const result = new Uint8Array(encoded.length + 5);
+
+    result[0] = 0x01; // String type marker
+    result[1] = (encoded.length >>> 24) & 0xFF;
+    result[2] = (encoded.length >>> 16) & 0xFF;
+    result[3] = (encoded.length >>> 8) & 0xFF;
+    result[4] = encoded.length & 0xFF;
+    result.set(encoded, 5);
+
+    return result;
+  }
+
+  /**
    * Optimized number serialization
-   */ static serializeNumber(num) {
-        const result = new Uint8Array(9);
-        const view = new DataView(result.buffer);
-        result[0] = 0x02; // Number type marker
-        view.setFloat64(1, num, true); // little-endian
-        return result;
-    }
-    /**
+   */
+  static serializeNumber(num) {
+    const result = new Uint8Array(9);
+    const view = new DataView(result.buffer);
+
+    result[0] = 0x02; // Number type marker
+    view.setFloat64(1, num, true); // little-endian
+
+    return result;
+  }
+
+  /**
    * Compact boolean serialization
-   */ static serializeBoolean(bool) {
-        return new Uint8Array([
-            0x03,
-            bool ? 1 : 0
-        ]);
-    }
-    /**
+   */
+  static serializeBoolean(bool) {
+    return new Uint8Array([0x03, bool ? 1 : 0]);
+  }
+
+  /**
    * Null value serialization
-   */ static serializeNull() {
-        return new Uint8Array([
-            0x04
-        ]);
-    }
-    /**
+   */
+  static serializeNull() {
+    return new Uint8Array([0x04]);
+  }
+
+  /**
    * Undefined value serialization
-   */ static serializeUndefined() {
-        return new Uint8Array([
-            0x05
-        ]);
-    }
-    /**
+   */
+  static serializeUndefined() {
+    return new Uint8Array([0x05]);
+  }
+
+  /**
    * Array serialization with length prefix
-   */ static serializeArray(arr) {
-        const serializedItems = arr.map((item)=>this.serialize(item));
-        const totalLength = serializedItems.reduce((sum, item)=>sum + item.length, 0);
-        const result = new Uint8Array(totalLength + 5);
-        const view = new DataView(result.buffer);
-        result[0] = 0x06; // Array type marker
-        view.setUint32(1, arr.length, true); // little-endian
-        let offset = 5;
-        for (const item of serializedItems){
-            result.set(item, offset);
-            offset += item.length;
-        }
-        return result;
-    }
-    /**
+   */
+  static serializeArray(arr) {
+    const serializedItems = arr.map(item => this.serialize(item));
+    const totalLength = serializedItems.reduce((sum, item) => sum + item.length, 0);
+
+    const result = new Uint8Array(totalLength + 5);
+    const view = new DataView(result.buffer);
+
+    result[0] = 0x06; // Array type marker
+    view.setUint32(1, arr.length, true); // little-endian
+
+    let offset = 5;
+    for (const item of serializedItems) {
+      result.set(item, offset);
+      offset += item.length;
+    }
+
+    return result;
+  }
+
+  /**
    * Object serialization with key sorting for deterministic output
-   */ static serializeObject(obj) {
-        const keys = Object.keys(obj).sort(); // Deterministic key order
-        const serializedPairs = [];
-        for (const key of keys){
-            const serializedKey = this.serializeString(key);
-            const serializedValue = this.serialize(obj[key]);
-            serializedPairs.push(serializedKey, serializedValue);
-        }
-        const totalLength = serializedPairs.reduce((sum, item)=>sum + item.length, 0);
-        const result = new Uint8Array(totalLength + 5);
-        const view = new DataView(result.buffer);
-        result[0] = 0x07; // Object type marker
-        view.setUint32(1, keys.length, true); // Number of key-value pairs
-        let offset = 5;
-        for (const item of serializedPairs){
-            result.set(item, offset);
-            offset += item.length;
-        }
-        return result;
-    }
-    /**
+   */
+  static serializeObject(obj) {
+    const keys = Object.keys(obj).sort(); // Deterministic key order
+    const serializedPairs = [];
+
+    for (const key of keys) {
+      const serializedKey = this.serializeString(key);
+      const serializedValue = this.serialize(obj[key]);
+      serializedPairs.push(serializedKey, serializedValue);
+    }
+
+    const totalLength = serializedPairs.reduce((sum, item) => sum + item.length, 0);
+    const result = new Uint8Array(totalLength + 5);
+    const view = new DataView(result.buffer);
+
+    result[0] = 0x07; // Object type marker
+    view.setUint32(1, keys.length, true); // Number of key-value pairs
+
+    let offset = 5;
+    for (const item of serializedPairs) {
+      result.set(item, offset);
+      offset += item.length;
+    }
+
+    return result;
+  }
+
+  /**
    * Deserialize Uint8Array back to JavaScript value
-   */ static deserialize(bytes) {
-        if (bytes.length === 0) return undefined;
-        const type = bytes[0];
-        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        switch(type){
-            case 0x01:
-                return this.deserializeString(bytes, view);
-            case 0x02:
-                return this.deserializeNumber(view);
-            case 0x03:
-                return this.deserializeBoolean(bytes);
-            case 0x04:
-                return null;
-            case 0x05:
-                return undefined;
-            case 0x06:
-                return this.deserializeArray(bytes, view);
-            case 0x07:
-                return this.deserializeObject(bytes, view);
-            default:
-                throw new Error(`Unknown type marker: ${type}`);
-        }
-    }
-    static deserializeString(bytes, view) {
-        if (!this._textDecoder) {
-            this._textDecoder = new TextDecoder();
-        }
-        const length = view.getUint32(1, true);
-        const stringBytes = bytes.slice(5, 5 + length);
-        return this._textDecoder.decode(stringBytes);
-    }
-    static deserializeNumber(view) {
-        return view.getFloat64(1, true);
-    }
-    static deserializeBoolean(bytes) {
-        return bytes[1] === 1;
-    }
-    static deserializeArray(bytes, view) {
-        const length = view.getUint32(1, true);
-        const result = new Array(length);
-        let offset = 5;
-        for(let i = 0; i < length; i++){
-            const itemType = bytes[offset];
-            const itemEnd = this.findItemEnd(bytes, offset);
-            const itemBytes = bytes.slice(offset, itemEnd);
-            result[i] = this.deserialize(itemBytes);
-            offset = itemEnd;
-        }
-        return result;
-    }
-    static deserializeObject(bytes, view) {
-        const pairCount = view.getUint32(1, true);
-        const result = {};
-        let offset = 5;
-        for(let i = 0; i < pairCount; i++){
-            // Deserialize key
-            const keyEnd = this.findItemEnd(bytes, offset);
-            const keyBytes = bytes.slice(offset, keyEnd);
-            const key = this.deserialize(keyBytes);
-            offset = keyEnd;
-            // Deserialize value
-            const valueEnd = this.findItemEnd(bytes, offset);
-            const valueBytes = bytes.slice(offset, valueEnd);
-            const value = this.deserialize(valueBytes);
-            offset = valueEnd;
-            result[key] = value;
-        }
-        return result;
-    }
-    static findItemEnd(bytes, start) {
-        const type = bytes[start];
-        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        switch(type){
-            case 0x01:
-                const strLength = view.getUint32(start + 1, true);
-                return start + 5 + strLength;
-            case 0x02:
-                return start + 9;
-            case 0x03:
-                return start + 2;
-            case 0x04:
-            case 0x05:
-                return start + 1;
-            case 0x06:
-            case 0x07:
-                // Complex types require recursive parsing
-                return this.findComplexItemEnd(bytes, start);
-            default:
-                throw new Error(`Unknown type marker: ${type}`);
-        }
-    }
-    static findComplexItemEnd(bytes, start) {
-        // Simplified implementation - in practice would need full recursive parsing
-        // This is a placeholder that should be implemented based on the specific format
-        throw new Error('Complex type end finding not implemented');
-    }
-}
+   */
+  static deserialize(bytes) {
+    if (bytes.length === 0) return undefined;
+
+    const type = bytes[0];
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+    switch (type) {
+      case 0x01: return this.deserializeString(bytes, view);
+      case 0x02: return this.deserializeNumber(view);
+      case 0x03: return this.deserializeBoolean(bytes);
+      case 0x04: return null;
+      case 0x05: return undefined;
+      case 0x06: return this.deserializeArray(bytes, view);
+      case 0x07: return this.deserializeObject(bytes, view);
+      default: throw new Error(`Unknown type marker: ${type}`);
+    }
+  }
+
+  static deserializeString(bytes, view) {
+    if (!this._textDecoder) {
+      this._textDecoder = new TextDecoder();
+    }
+
+    const length = view.getUint32(1, true);
+    const stringBytes = bytes.slice(5, 5 + length);
+    return this._textDecoder.decode(stringBytes);
+  }
+
+  static deserializeNumber(view) {
+    return view.getFloat64(1, true);
+  }
+
+  static deserializeBoolean(bytes) {
+    return bytes[1] === 1;
+  }
+
+  static deserializeArray(bytes, view) {
+    const length = view.getUint32(1, true);
+    const result = new Array(length);
+    let offset = 5;
+
+    for (let i = 0; i < length; i++) {
+      const itemType = bytes[offset];
+      const itemEnd = this.findItemEnd(bytes, offset);
+      const itemBytes = bytes.slice(offset, itemEnd);
+      result[i] = this.deserialize(itemBytes);
+      offset = itemEnd;
+    }
+
+    return result;
+  }
+
+  static deserializeObject(bytes, view) {
+    const pairCount = view.getUint32(1, true);
+    const result = {};
+    let offset = 5;
+
+    for (let i = 0; i < pairCount; i++) {
+      // Deserialize key
+      const keyEnd = this.findItemEnd(bytes, offset);
+      const keyBytes = bytes.slice(offset, keyEnd);
+      const key = this.deserialize(keyBytes);
+      offset = keyEnd;
+
+      // Deserialize value
+      const valueEnd = this.findItemEnd(bytes, offset);
+      const valueBytes = bytes.slice(offset, valueEnd);
+      const value = this.deserialize(valueBytes);
+      offset = valueEnd;
+
+      result[key] = value;
+    }
+
+    return result;
+  }
+
+  static findItemEnd(bytes, start) {
+    const type = bytes[start];
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+    switch (type) {
+      case 0x01: // String
+        const strLength = view.getUint32(start + 1, true);
+        return start + 5 + strLength;
+      case 0x02: // Number
+        return start + 9;
+      case 0x03: // Boolean
+        return start + 2;
+      case 0x04: // Null
+      case 0x05: // Undefined
+        return start + 1;
+      case 0x06: // Array
+      case 0x07: // Object
+        // Complex types require recursive parsing
+        return this.findComplexItemEnd(bytes, start);
+      default:
+        throw new Error(`Unknown type marker: ${type}`);
+    }
+  }
+
+  static findComplexItemEnd(bytes, start) {
+    // Simplified implementation - in practice would need full recursive parsing
+    // This is a placeholder that should be implemented based on the specific format
+    throw new Error('Complex type end finding not implemented');
+  }
+}
+
 /**
  * Namespace-aware key serialization
- */ export class NamespaceKeySerializer {
-    /**
+ */
+export class NamespaceKeySerializer {
+  /**
    * Serialize key with namespace information
-   */ static serializeNamespacedKey(namespace, key) {
-        const namespaceBytes = FastSerializer.serialize(namespace);
-        const keyBytes = FastSerializer.serialize(key);
-        const result = new Uint8Array(namespaceBytes.length + keyBytes.length + 8);
-        const view = new DataView(result.buffer);
-        // Header: namespace length + key length
-        view.setUint32(0, namespaceBytes.length, true);
-        view.setUint32(4, keyBytes.length, true);
-        // Data: namespace + key
-        result.set(namespaceBytes, 8);
-        result.set(keyBytes, 8 + namespaceBytes.length);
-        return result;
-    }
-    /**
+   */
+  static serializeNamespacedKey(namespace, key) {
+    const namespaceBytes = FastSerializer.serialize(namespace);
+    const keyBytes = FastSerializer.serialize(key);
+
+    const result = new Uint8Array(namespaceBytes.length + keyBytes.length + 8);
+    const view = new DataView(result.buffer);
+
+    // Header: namespace length + key length
+    view.setUint32(0, namespaceBytes.length, true);
+    view.setUint32(4, keyBytes.length, true);
+
+    // Data: namespace + key
+    result.set(namespaceBytes, 8);
+    result.set(keyBytes, 8 + namespaceBytes.length);
+
+    return result;
+  }
+
+  /**
    * Generate composite hash for namespaced key
-   */ static hashNamespacedKey(namespace, key, seed = 0x12345678) {
-        const namespaceHash = HighPerformanceHash.adaptiveHash(namespace, seed);
-        const keyHash = HighPerformanceHash.adaptiveHash(key, namespaceHash);
-        // Combine hashes using multiplication and XOR
-        return Math.imul(namespaceHash, 0x9E3779B1) ^ keyHash;
-    }
-    /**
+   */
+  static hashNamespacedKey(namespace, key, seed = 0x12345678) {
+    const namespaceHash = HighPerformanceHash.adaptiveHash(namespace, seed);
+    const keyHash = HighPerformanceHash.adaptiveHash(key, namespaceHash);
+
+    // Combine hashes using multiplication and XOR
+    return Math.imul(namespaceHash, 0x9E3779B1) ^ keyHash;
+  }
+
+  /**
    * Fast namespace ID lookup with caching
-   */ static resolveNamespace(namespaceName, namespaceMap) {
-        let namespaceId = namespaceMap.get(namespaceName);
-        if (namespaceId === undefined) {
-            namespaceId = HighPerformanceHash.fnv1a32(namespaceName);
-            namespaceMap.set(namespaceName, namespaceId);
-        }
-        return namespaceId;
-    }
-}
+   */
+  static resolveNamespace(namespaceName, namespaceMap) {
+    let namespaceId = namespaceMap.get(namespaceName);
+
+    if (namespaceId === undefined) {
+      namespaceId = HighPerformanceHash.fnv1a32(namespaceName);
+      namespaceMap.set(namespaceName, namespaceId);
+    }
+
+    return namespaceId;
+  }
+}
+
 /**
  * Performance benchmarking for serialization and hashing
- */ export class SerializationBenchmark {
-    /**
+ */
+export class SerializationBenchmark {
+  constructor() {
+    this.results = new Map();
+  }
+
+  /**
    * Benchmark hash function performance
-   */ benchmarkHashFunctions(testData, iterations = 100000) {
-        const functions = [
-            'fnv1a32',
-            'xxhash32',
-            'murmurHash3_32',
-            'cityHash32',
-            'adaptiveHash'
-        ];
-        const results = {};
-        for (const funcName of functions){
-            const start = performance.now() * 1000000; // nanoseconds
-            for(let i = 0; i < iterations; i++){
-                HighPerformanceHash[funcName](testData);
-            }
-            const end = performance.now() * 1000000;
-            const avgTime = (end - start) / iterations;
-            results[funcName] = {
-                totalTime: end - start,
-                avgTimePerOp: avgTime,
-                operationsPerSecond: 1000000000 / avgTime
-            };
-        }
-        return results;
-    }
-    /**
+   */
+  benchmarkHashFunctions(testData, iterations = 100000) {
+    const functions = [
+      'fnv1a32',
+      'xxhash32',
+      'murmurHash3_32',
+      'cityHash32',
+      'adaptiveHash'
+    ];
+
+    const results = {};
+
+    for (const funcName of functions) {
+      const start = performance.now() * 1000000; // nanoseconds
+
+      for (let i = 0; i < iterations; i++) {
+        HighPerformanceHash[funcName](testData);
+      }
+
+      const end = performance.now() * 1000000;
+      const avgTime = (end - start) / iterations;
+
+      results[funcName] = {
+        totalTime: end - start,
+        avgTimePerOp: avgTime,
+        operationsPerSecond: 1000000000 / avgTime
+      };
+    }
+
+    return results;
+  }
+
+  /**
    * Benchmark serialization performance
-   */ benchmarkSerialization(testData, iterations = 50000) {
-        const results = {};
-        // Serialization benchmark
-        const start = performance.now() * 1000000;
-        for(let i = 0; i < iterations; i++){
-            FastSerializer.serialize(testData);
-        }
-        const end = performance.now() * 1000000;
-        results.serialization = {
-            totalTime: end - start,
-            avgTimePerOp: (end - start) / iterations,
-            operationsPerSecond: 1000000000 / ((end - start) / iterations)
-        };
-        // Round-trip benchmark
-        const serialized = FastSerializer.serialize(testData);
-        const roundTripStart = performance.now() * 1000000;
-        for(let i = 0; i < iterations; i++){
-            const data = FastSerializer.serialize(testData);
-            FastSerializer.deserialize(data);
-        }
-        const roundTripEnd = performance.now() * 1000000;
-        results.roundTrip = {
-            totalTime: roundTripEnd - roundTripStart,
-            avgTimePerOp: (roundTripEnd - roundTripStart) / iterations,
-            operationsPerSecond: 1000000000 / ((roundTripEnd - roundTripStart) / iterations),
-            serializedSize: serialized.length
-        };
-        return results;
-    }
-    /**
+   */
+  benchmarkSerialization(testData, iterations = 50000) {
+    const results = {};
+
+    // Serialization benchmark
+    const start = performance.now() * 1000000;
+
+    for (let i = 0; i < iterations; i++) {
+      FastSerializer.serialize(testData);
+    }
+
+    const end = performance.now() * 1000000;
+
+    results.serialization = {
+      totalTime: end - start,
+      avgTimePerOp: (end - start) / iterations,
+      operationsPerSecond: 1000000000 / ((end - start) / iterations)
+    };
+
+    // Round-trip benchmark
+    const serialized = FastSerializer.serialize(testData);
+    const roundTripStart = performance.now() * 1000000;
+
+    for (let i = 0; i < iterations; i++) {
+      const data = FastSerializer.serialize(testData);
+      FastSerializer.deserialize(data);
+    }
+
+    const roundTripEnd = performance.now() * 1000000;
+
+    results.roundTrip = {
+      totalTime: roundTripEnd - roundTripStart,
+      avgTimePerOp: (roundTripEnd - roundTripStart) / iterations,
+      operationsPerSecond: 1000000000 / ((roundTripEnd - roundTripStart) / iterations),
+      serializedSize: serialized.length
+    };
+
+    return results;
+  }
+
+  /**
    * Hash distribution quality test
-   */ testHashDistribution(hashFunction, keyGenerator, bucketCount = 10000, keyCount = 100000) {
-        const buckets = new Array(bucketCount).fill(0);
-        for(let i = 0; i < keyCount; i++){
-            const key = keyGenerator(i);
-            const hash = HighPerformanceHash[hashFunction](key);
-            const bucketIndex = hash % bucketCount;
-            buckets[bucketIndex]++;
-        }
-        // Calculate distribution metrics
-        const expectedPerBucket = keyCount / bucketCount;
-        let sumSquaredDiffs = 0;
-        let minBucket = buckets[0];
-        let maxBucket = buckets[0];
-        for (const count of buckets){
-            const diff = count - expectedPerBucket;
-            sumSquaredDiffs += diff * diff;
-            minBucket = Math.min(minBucket, count);
-            maxBucket = Math.max(maxBucket, count);
-        }
-        const variance = sumSquaredDiffs / bucketCount;
-        const stdDev = Math.sqrt(variance);
-        const coefficient = stdDev / expectedPerBucket;
-        return {
-            minBucket,
-            maxBucket,
-            expectedPerBucket,
-            variance,
-            stdDev,
-            coefficientOfVariation: coefficient,
-            quality: coefficient < 0.1 ? 'Excellent' : coefficient < 0.2 ? 'Good' : coefficient < 0.3 ? 'Fair' : 'Poor'
-        };
-    }
-    /**
+   */
+  testHashDistribution(hashFunction, keyGenerator, bucketCount = 10000, keyCount = 100000) {
+    const buckets = new Array(bucketCount).fill(0);
+
+    for (let i = 0; i < keyCount; i++) {
+      const key = keyGenerator(i);
+      const hash = HighPerformanceHash[hashFunction](key);
+      const bucketIndex = hash % bucketCount;
+      buckets[bucketIndex]++;
+    }
+
+    // Calculate distribution metrics
+    const expectedPerBucket = keyCount / bucketCount;
+    let sumSquaredDiffs = 0;
+    let minBucket = buckets[0];
+    let maxBucket = buckets[0];
+
+    for (const count of buckets) {
+      const diff = count - expectedPerBucket;
+      sumSquaredDiffs += diff * diff;
+      minBucket = Math.min(minBucket, count);
+      maxBucket = Math.max(maxBucket, count);
+    }
+
+    const variance = sumSquaredDiffs / bucketCount;
+    const stdDev = Math.sqrt(variance);
+    const coefficient = stdDev / expectedPerBucket;
+
+    return {
+      minBucket,
+      maxBucket,
+      expectedPerBucket,
+      variance,
+      stdDev,
+      coefficientOfVariation: coefficient,
+      quality: coefficient < 0.1 ? 'Excellent' :
+               coefficient < 0.2 ? 'Good' :
+               coefficient < 0.3 ? 'Fair' : 'Poor'
+    };
+  }
+
+  /**
    * Generate comprehensive performance report
-   */ generatePerformanceReport(testCases) {
-        const report = {
-            timestamp: Date.now(),
-            hashFunctions: {},
-            serialization: {},
-            distribution: {}
-        };
-        for (const testCase of testCases){
-            // Hash function benchmarks
-            report.hashFunctions[testCase.name] = this.benchmarkHashFunctions(testCase.data, testCase.iterations);
-            // Serialization benchmarks
-            report.serialization[testCase.name] = this.benchmarkSerialization(testCase.data, testCase.iterations);
-            // Distribution quality tests
-            report.distribution[testCase.name] = {};
-            const functions = [
-                'fnv1a32',
-                'xxhash32',
-                'murmurHash3_32'
-            ];
-            for (const func of functions){
-                report.distribution[testCase.name][func] = this.testHashDistribution(func, testCase.keyGenerator);
-            }
-        }
-        return report;
-    }
-    constructor(){
-        this.results = new Map();
-    }
-}
-// Export commonly used combinations
-export const DefaultHashFunction = HighPerformanceHash.xxhash32;
-export const FastHash = HighPerformanceHash.fnv1a32;
-export const QualityHash = HighPerformanceHash.murmurHash3_32;
+   */
+  generatePerformanceReport(testCases) {
+    const report = {
+      timestamp: Date.now(),
+      hashFunctions: {},
+      serialization: {},
+      distribution: {}
+    };
+
+    for (const testCase of testCases) {
+      // Hash function benchmarks
+      report.hashFunctions[testCase.name] = this.benchmarkHashFunctions(
+        testCase.data, testCase.iterations
+      );
+
+      // Serialization benchmarks
+      report.serialization[testCase.name] = this.benchmarkSerialization(
+        testCase.data, testCase.iterations
+      );
+
+      // Distribution quality tests
+      report.distribution[testCase.name] = {};
+      const functions = ['fnv1a32', 'xxhash32', 'murmurHash3_32'];
+      for (const func of functions) {
+        report.distribution[testCase.name][func] = this.testHashDistribution(
+          func, testCase.keyGenerator
+        );
+      }
+    }
+
+    return report;
+  }
+}
+
+// Export commonly used combinations
+export const DefaultHashFunction = HighPerformanceHash.xxhash32;
+export const FastHash = HighPerformanceHash.fnv1a32;
+export const QualityHash = HighPerformanceHash.murmurHash3_32;