claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/memory/lock-free-structures.js

@@ -9,812 +9,626 @@
  * - Write operations: <500ns
  * - Zero lock contention
  * - Linear scalability with CPU cores
- */
-
-/**
+ */ /**
  * Atomic operations wrapper with performance optimizations
- */
-export class AtomicOperations {
-  /**
+ */ export class AtomicOperations {
+    /**
    * Compare-and-swap with retry logic and backoff
-   */
-  static compareAndSwap32(buffer, offset, expected, value) {
-    const view = new Uint32Array(buffer);
-    const index = offset >> 2;
-    return Atomics.compareExchange(view, index, expected, value);
-  }
-
-  /**
+   */ static compareAndSwap32(buffer, offset, expected, value) {
+        const view = new Uint32Array(buffer);
+        const index = offset >> 2;
+        return Atomics.compareExchange(view, index, expected, value);
+    }
+    /**
    * Compare-and-swap for 64-bit values (using two 32-bit operations)
-   */
-  static compareAndSwap64(buffer, offset, expectedLow, expectedHigh, valueLow, valueHigh) {
-    const view = new Uint32Array(buffer);
-    const lowIndex = offset >> 2;
-    const highIndex = lowIndex + 1;
-
-    // Atomic 64-bit CAS requires platform-specific implementation
-    // This is a simplified version for demonstration
-    while (true) {
-      const currentLow = Atomics.load(view, lowIndex);
-      const currentHigh = Atomics.load(view, highIndex);
-
-      if (currentLow === expectedLow && currentHigh === expectedHigh) {
-        const successLow = Atomics.compareExchange(view, lowIndex, expectedLow, valueLow);
-        if (successLow === expectedLow) {
-          const successHigh = Atomics.compareExchange(view, highIndex, expectedHigh, valueHigh);
-          if (successHigh === expectedHigh) {
-            return true;
-          }
-          // Rollback low if high failed
-          Atomics.compareExchange(view, lowIndex, valueLow, expectedLow);
-        }
-      }
-
-      // Exponential backoff
-      this.backoff();
-      return false;
-    }
-  }
-
-  /**
+   */ static compareAndSwap64(buffer, offset, expectedLow, expectedHigh, valueLow, valueHigh) {
+        const view = new Uint32Array(buffer);
+        const lowIndex = offset >> 2;
+        const highIndex = lowIndex + 1;
+        // Atomic 64-bit CAS requires platform-specific implementation
+        // This is a simplified version for demonstration
+        while(true){
+            const currentLow = Atomics.load(view, lowIndex);
+            const currentHigh = Atomics.load(view, highIndex);
+            if (currentLow === expectedLow && currentHigh === expectedHigh) {
+                const successLow = Atomics.compareExchange(view, lowIndex, expectedLow, valueLow);
+                if (successLow === expectedLow) {
+                    const successHigh = Atomics.compareExchange(view, highIndex, expectedHigh, valueHigh);
+                    if (successHigh === expectedHigh) {
+                        return true;
+                    }
+                    // Rollback low if high failed
+                    Atomics.compareExchange(view, lowIndex, valueLow, expectedLow);
+                }
+            }
+            // Exponential backoff
+            this.backoff();
+            return false;
+        }
+    }
+    /**
    * Atomic increment with overflow protection
-   */
-  static atomicIncrement(buffer, offset) {
-    const view = new Uint32Array(buffer);
-    return Atomics.add(view, offset >> 2, 1);
-  }
-
-  /**
+   */ static atomicIncrement(buffer, offset) {
+        const view = new Uint32Array(buffer);
+        return Atomics.add(view, offset >> 2, 1);
+    }
+    /**
    * Atomic decrement with underflow protection
-   */
-  static atomicDecrement(buffer, offset) {
-    const view = new Uint32Array(buffer);
-    return Atomics.sub(view, offset >> 2, 1);
-  }
-
-  /**
+   */ static atomicDecrement(buffer, offset) {
+        const view = new Uint32Array(buffer);
+        return Atomics.sub(view, offset >> 2, 1);
+    }
+    /**
    * Load with acquire memory ordering
-   */
-  static loadAcquire(buffer, offset) {
-    const view = new Uint32Array(buffer);
-    return Atomics.load(view, offset >> 2);
-  }
-
-  /**
+   */ static loadAcquire(buffer, offset) {
+        const view = new Uint32Array(buffer);
+        return Atomics.load(view, offset >> 2);
+    }
+    /**
    * Store with release memory ordering
-   */
-  static storeRelease(buffer, offset, value) {
-    const view = new Uint32Array(buffer);
-    return Atomics.store(view, offset >> 2, value);
-  }
-
-  /**
+   */ static storeRelease(buffer, offset, value) {
+        const view = new Uint32Array(buffer);
+        return Atomics.store(view, offset >> 2, value);
+    }
+    /**
    * Exponential backoff for contention management
-   */
-  static backoff(attempt = 1) {
-    const maxBackoff = Math.min(64, Math.pow(2, attempt));
-    for (let i = 0; i < maxBackoff; i++) {
-      // CPU-friendly spin without yielding
-    }
-  }
-
-  /**
+   */ static backoff(attempt = 1) {
+        const maxBackoff = Math.min(64, Math.pow(2, attempt));
+        for(let i = 0; i < maxBackoff; i++){
+        // CPU-friendly spin without yielding
+        }
+    }
+    /**
    * Memory fence for ordering guarantees
-   */
-  static memoryFence() {
-    // Use Atomics.notify/wait for memory synchronization
-    const dummy = new Int32Array(new SharedArrayBuffer(4));
-    Atomics.store(dummy, 0, 0);
-  }
-}
-
+   */ static memoryFence() {
+        // Use Atomics.notify/wait for memory synchronization
+        const dummy = new Int32Array(new SharedArrayBuffer(4));
+        Atomics.store(dummy, 0, 0);
+    }
+}
 /**
  * Lock-free hash table with linear probing and optimistic concurrency
- */
-export class LockFreeHashTable {
-  constructor(sharedBuffer, bucketCount = 16384, bucketsOffset = 4096) {
-    this.buffer = sharedBuffer;
-    this.bucketCount = bucketCount;
-    this.bucketSize = 32; // bytes per bucket
-    this.bucketsOffset = bucketsOffset;
-    this.loadFactor = 0.75; // Resize threshold
-
-    this.initializeBuckets();
-  }
-
-  /**
+ */ export class LockFreeHashTable {
+    /**
    * Initialize bucket structure in shared memory
-   */
-  initializeBuckets() {
-    const view = new Uint32Array(this.buffer);
-    const bucketView = view.subarray(this.bucketsOffset >> 2);
-
-    for (let i = 0; i < this.bucketCount; i++) {
-      const bucketBase = i * (this.bucketSize >> 2);
-      bucketView[bucketBase] = 0;     // head = null
-      bucketView[bucketBase + 1] = 0; // count = 0
-      bucketView[bucketBase + 2] = 0; // lock version = 0
-      // Reserved space for future use
-    }
-  }
-
-  /**
+   */ initializeBuckets() {
+        const view = new Uint32Array(this.buffer);
+        const bucketView = view.subarray(this.bucketsOffset >> 2);
+        for(let i = 0; i < this.bucketCount; i++){
+            const bucketBase = i * (this.bucketSize >> 2);
+            bucketView[bucketBase] = 0; // head = null
+            bucketView[bucketBase + 1] = 0; // count = 0
+            bucketView[bucketBase + 2] = 0; // lock version = 0
+        // Reserved space for future use
+        }
+    }
+    /**
    * Lock-free insertion with optimistic concurrency control
-   */
-  insert(keyHash, entryOffset) {
-    const bucketIndex = keyHash % this.bucketCount;
-    const bucketOffset = this.bucketsOffset + (bucketIndex * this.bucketSize);
-
-    let attempts = 0;
-    const maxAttempts = 16;
-
-    while (attempts < maxAttempts) {
-      // Read current state
-      const currentHead = AtomicOperations.loadAcquire(this.buffer, bucketOffset);
-      const lockVersion = AtomicOperations.loadAcquire(this.buffer, bucketOffset + 8);
-
-      // Set next pointer of new entry to current head
-      AtomicOperations.storeRelease(this.buffer, entryOffset, currentHead);
-
-      // Attempt atomic update of bucket head
-      const success = AtomicOperations.compareAndSwap32(
-        this.buffer, bucketOffset, currentHead, entryOffset
-      );
-
-      if (success === currentHead) {
-        // Verify no concurrent modification (ABA problem prevention)
-        const newLockVersion = AtomicOperations.loadAcquire(this.buffer, bucketOffset + 8);
-        if (newLockVersion === lockVersion) {
-          // Update count atomically
-          AtomicOperations.atomicIncrement(this.buffer, bucketOffset + 4);
-          return true;
-        }
-      }
-
-      // Exponential backoff before retry
-      AtomicOperations.backoff(attempts);
-      attempts++;
-    }
-
-    return false; // Failed after max attempts
-  }
-
-  /**
+   */ insert(keyHash, entryOffset) {
+        const bucketIndex = keyHash % this.bucketCount;
+        const bucketOffset = this.bucketsOffset + bucketIndex * this.bucketSize;
+        let attempts = 0;
+        const maxAttempts = 16;
+        while(attempts < maxAttempts){
+            // Read current state
+            const currentHead = AtomicOperations.loadAcquire(this.buffer, bucketOffset);
+            const lockVersion = AtomicOperations.loadAcquire(this.buffer, bucketOffset + 8);
+            // Set next pointer of new entry to current head
+            AtomicOperations.storeRelease(this.buffer, entryOffset, currentHead);
+            // Attempt atomic update of bucket head
+            const success = AtomicOperations.compareAndSwap32(this.buffer, bucketOffset, currentHead, entryOffset);
+            if (success === currentHead) {
+                // Verify no concurrent modification (ABA problem prevention)
+                const newLockVersion = AtomicOperations.loadAcquire(this.buffer, bucketOffset + 8);
+                if (newLockVersion === lockVersion) {
+                    // Update count atomically
+                    AtomicOperations.atomicIncrement(this.buffer, bucketOffset + 4);
+                    return true;
+                }
+            }
+            // Exponential backoff before retry
+            AtomicOperations.backoff(attempts);
+            attempts++;
+        }
+        return false; // Failed after max attempts
+    }
+    /**
    * Lock-free lookup with minimal memory barriers
-   */
-  lookup(keyHash, keyComparator) {
-    const bucketIndex = keyHash % this.bucketCount;
-    const bucketOffset = this.bucketsOffset + (bucketIndex * this.bucketSize);
-
-    let entryOffset = AtomicOperations.loadAcquire(this.buffer, bucketOffset);
-
-    while (entryOffset !== 0) {
-      const entry = this.getEntryView(entryOffset);
-
-      // Fast hash comparison first
-      const entryHash = AtomicOperations.loadAcquire(this.buffer, entryOffset + 4);
-      if (entryHash === keyHash && keyComparator(entry)) {
-        return entryOffset;
-      }
-
-      // Follow chain
-      entryOffset = AtomicOperations.loadAcquire(this.buffer, entryOffset);
-    }
-
-    return 0; // Not found
-  }
-
-  /**
+   */ lookup(keyHash, keyComparator) {
+        const bucketIndex = keyHash % this.bucketCount;
+        const bucketOffset = this.bucketsOffset + bucketIndex * this.bucketSize;
+        let entryOffset = AtomicOperations.loadAcquire(this.buffer, bucketOffset);
+        while(entryOffset !== 0){
+            const entry = this.getEntryView(entryOffset);
+            // Fast hash comparison first
+            const entryHash = AtomicOperations.loadAcquire(this.buffer, entryOffset + 4);
+            if (entryHash === keyHash && keyComparator(entry)) {
+                return entryOffset;
+            }
+            // Follow chain
+            entryOffset = AtomicOperations.loadAcquire(this.buffer, entryOffset);
+        }
+        return 0; // Not found
+    }
+    /**
    * Lock-free removal with lazy deletion
-   */
-  remove(keyHash, keyComparator) {
-    const bucketIndex = keyHash % this.bucketCount;
-    const bucketOffset = this.bucketsOffset + (bucketIndex * this.bucketSize);
-
-    while (true) {
-      let prevOffset = bucketOffset;
-      let currentOffset = AtomicOperations.loadAcquire(this.buffer, bucketOffset);
-
-      while (currentOffset !== 0) {
-        const entry = this.getEntryView(currentOffset);
-        const entryHash = AtomicOperations.loadAcquire(this.buffer, currentOffset + 4);
-
-        if (entryHash === keyHash && keyComparator(entry)) {
-          // Mark as deleted (lazy deletion)
-          const flags = AtomicOperations.loadAcquire(this.buffer, currentOffset + 24);
-          const newFlags = flags | 0x80000000; // Set deleted bit
-
-          const success = AtomicOperations.compareAndSwap32(
-            this.buffer, currentOffset + 24, flags, newFlags
-          );
-
-          if (success === flags) {
-            // Decrement bucket count
-            AtomicOperations.atomicDecrement(this.buffer, bucketOffset + 4);
-            return true;
-          }
-        }
-
-        prevOffset = currentOffset;
-        currentOffset = AtomicOperations.loadAcquire(this.buffer, currentOffset);
-      }
-
-      return false; // Not found
-    }
-  }
-
-  /**
+   */ remove(keyHash, keyComparator) {
+        const bucketIndex = keyHash % this.bucketCount;
+        const bucketOffset = this.bucketsOffset + bucketIndex * this.bucketSize;
+        while(true){
+            let prevOffset = bucketOffset;
+            let currentOffset = AtomicOperations.loadAcquire(this.buffer, bucketOffset);
+            while(currentOffset !== 0){
+                const entry = this.getEntryView(currentOffset);
+                const entryHash = AtomicOperations.loadAcquire(this.buffer, currentOffset + 4);
+                if (entryHash === keyHash && keyComparator(entry)) {
+                    // Mark as deleted (lazy deletion)
+                    const flags = AtomicOperations.loadAcquire(this.buffer, currentOffset + 24);
+                    const newFlags = flags | 0x80000000; // Set deleted bit
+                    const success = AtomicOperations.compareAndSwap32(this.buffer, currentOffset + 24, flags, newFlags);
+                    if (success === flags) {
+                        // Decrement bucket count
+                        AtomicOperations.atomicDecrement(this.buffer, bucketOffset + 4);
+                        return true;
+                    }
+                }
+                prevOffset = currentOffset;
+                currentOffset = AtomicOperations.loadAcquire(this.buffer, currentOffset);
+            }
+            return false; // Not found
+        }
+    }
+    /**
    * Get entry view for fast access
-   */
-  getEntryView(offset) {
-    return {
-      offset,
-      next: () => AtomicOperations.loadAcquire(this.buffer, offset),
-      keyHash: () => AtomicOperations.loadAcquire(this.buffer, offset + 4),
-      keyLength: () => new Uint16Array(this.buffer, offset + 8, 1)[0],
-      valueLength: () => new Uint16Array(this.buffer, offset + 10, 1)[0],
-      namespace: () => AtomicOperations.loadAcquire(this.buffer, offset + 12),
-      timestamp: () => AtomicOperations.loadAcquire(this.buffer, offset + 16),
-      flags: () => AtomicOperations.loadAcquire(this.buffer, offset + 24)
-    };
-  }
-
-  /**
+   */ getEntryView(offset) {
+        return {
+            offset,
+            next: ()=>AtomicOperations.loadAcquire(this.buffer, offset),
+            keyHash: ()=>AtomicOperations.loadAcquire(this.buffer, offset + 4),
+            keyLength: ()=>new Uint16Array(this.buffer, offset + 8, 1)[0],
+            valueLength: ()=>new Uint16Array(this.buffer, offset + 10, 1)[0],
+            namespace: ()=>AtomicOperations.loadAcquire(this.buffer, offset + 12),
+            timestamp: ()=>AtomicOperations.loadAcquire(this.buffer, offset + 16),
+            flags: ()=>AtomicOperations.loadAcquire(this.buffer, offset + 24)
+        };
+    }
+    /**
    * Get bucket statistics for load balancing
-   */
-  getBucketStats() {
-    const stats = {
-      totalEntries: 0,
-      maxChainLength: 0,
-      emptyBuckets: 0,
-      averageChainLength: 0
-    };
-
-    for (let i = 0; i < this.bucketCount; i++) {
-      const bucketOffset = this.bucketsOffset + (i * this.bucketSize);
-      const count = AtomicOperations.loadAcquire(this.buffer, bucketOffset + 4);
-
-      stats.totalEntries += count;
-      stats.maxChainLength = Math.max(stats.maxChainLength, count);
-      if (count === 0) stats.emptyBuckets++;
-    }
-
-    stats.averageChainLength = stats.totalEntries / (this.bucketCount - stats.emptyBuckets);
-    return stats;
-  }
-}
-
+   */ getBucketStats() {
+        const stats = {
+            totalEntries: 0,
+            maxChainLength: 0,
+            emptyBuckets: 0,
+            averageChainLength: 0
+        };
+        for(let i = 0; i < this.bucketCount; i++){
+            const bucketOffset = this.bucketsOffset + i * this.bucketSize;
+            const count = AtomicOperations.loadAcquire(this.buffer, bucketOffset + 4);
+            stats.totalEntries += count;
+            stats.maxChainLength = Math.max(stats.maxChainLength, count);
+            if (count === 0) stats.emptyBuckets++;
+        }
+        stats.averageChainLength = stats.totalEntries / (this.bucketCount - stats.emptyBuckets);
+        return stats;
+    }
+    constructor(sharedBuffer, bucketCount = 16384, bucketsOffset = 4096){
+        this.buffer = sharedBuffer;
+        this.bucketCount = bucketCount;
+        this.bucketSize = 32; // bytes per bucket
+        this.bucketsOffset = bucketsOffset;
+        this.loadFactor = 0.75; // Resize threshold
+        this.initializeBuckets();
+    }
+}
 /**
  * Lock-free memory pool with segregated free lists
- */
-export class LockFreeMemoryPool {
-  constructor(sharedBuffer, poolOffset, poolSize) {
-    this.buffer = sharedBuffer;
-    this.poolOffset = poolOffset;
-    this.poolSize = poolSize;
-    this.chunkSize = 64; // Minimum allocation unit (cache line aligned)
-    this.sizeBuckets = 16; // Number of different size classes
-
-    this.initializeFreeLists();
-  }
-
-  /**
+ */ export class LockFreeMemoryPool {
+    /**
    * Initialize segregated free lists for different allocation sizes
-   */
-  initializeFreeList() {
-    const headerSize = this.sizeBuckets * 8; // 8 bytes per size class (head pointer + count)
-    let currentOffset = this.poolOffset + headerSize;
-
-    // Initialize free lists for different size classes
-    for (let sizeClass = 0; sizeClass < this.sizeBuckets; sizeClass++) {
-      const chunkSize = this.chunkSize * (1 << sizeClass); // Power of 2 sizes
-      const headerOffset = this.poolOffset + (sizeClass * 8);
-
-      // Initialize first chunk as head of free list
-      AtomicOperations.storeRelease(this.buffer, headerOffset, currentOffset);
-      AtomicOperations.storeRelease(this.buffer, headerOffset + 4, 0); // count
-
-      // Chain all chunks of this size class
-      let chunkOffset = currentOffset;
-      const chunksInClass = Math.floor(this.poolSize / (this.sizeBuckets * chunkSize));
-
-      for (let i = 0; i < chunksInClass - 1; i++) {
-        const nextChunk = chunkOffset + chunkSize;
-        AtomicOperations.storeRelease(this.buffer, chunkOffset, nextChunk);
-        chunkOffset = nextChunk;
-      }
-
-      // Last chunk points to null
-      AtomicOperations.storeRelease(this.buffer, chunkOffset, 0);
-      currentOffset = chunkOffset + chunkSize;
-    }
-  }
-
-  /**
+   */ initializeFreeList() {
+        const headerSize = this.sizeBuckets * 8; // 8 bytes per size class (head pointer + count)
+        let currentOffset = this.poolOffset + headerSize;
+        // Initialize free lists for different size classes
+        for(let sizeClass = 0; sizeClass < this.sizeBuckets; sizeClass++){
+            const chunkSize = this.chunkSize * (1 << sizeClass); // Power of 2 sizes
+            const headerOffset = this.poolOffset + sizeClass * 8;
+            // Initialize first chunk as head of free list
+            AtomicOperations.storeRelease(this.buffer, headerOffset, currentOffset);
+            AtomicOperations.storeRelease(this.buffer, headerOffset + 4, 0); // count
+            // Chain all chunks of this size class
+            let chunkOffset = currentOffset;
+            const chunksInClass = Math.floor(this.poolSize / (this.sizeBuckets * chunkSize));
+            for(let i = 0; i < chunksInClass - 1; i++){
+                const nextChunk = chunkOffset + chunkSize;
+                AtomicOperations.storeRelease(this.buffer, chunkOffset, nextChunk);
+                chunkOffset = nextChunk;
+            }
+            // Last chunk points to null
+            AtomicOperations.storeRelease(this.buffer, chunkOffset, 0);
+            currentOffset = chunkOffset + chunkSize;
+        }
+    }
+    /**
    * Lock-free allocation using compare-and-swap
-   */
-  allocate(requestedSize) {
-    const alignedSize = this.alignSize(requestedSize);
-    const sizeClass = this.getSizeClass(alignedSize);
-
-    if (sizeClass >= this.sizeBuckets) {
-      return this.allocateLarge(alignedSize);
-    }
-
-    const freeListOffset = this.poolOffset + (sizeClass * 8);
-    let attempts = 0;
-    const maxAttempts = 16;
-
-    while (attempts < maxAttempts) {
-      const currentHead = AtomicOperations.loadAcquire(this.buffer, freeListOffset);
-
-      if (currentHead === 0) {
-        // No free chunks in this size class, try larger size class
-        return this.allocateFromLargerClass(sizeClass + 1, alignedSize);
-      }
-
-      // Read next pointer before attempting CAS
-      const nextChunk = AtomicOperations.loadAcquire(this.buffer, currentHead);
-
-      // Attempt to update free list head
-      const success = AtomicOperations.compareAndSwap32(
-        this.buffer, freeListOffset, currentHead, nextChunk
-      );
-
-      if (success === currentHead) {
-        // Update allocation count
-        AtomicOperations.atomicDecrement(this.buffer, freeListOffset + 4);
-
-        // Initialize allocated chunk header
-        this.initializeAllocatedChunk(currentHead, alignedSize, sizeClass);
-        return currentHead;
-      }
-
-      AtomicOperations.backoff(attempts);
-      attempts++;
-    }
-
-    return 0; // Allocation failed
-  }
-
-  /**
+   */ allocate(requestedSize) {
+        const alignedSize = this.alignSize(requestedSize);
+        const sizeClass = this.getSizeClass(alignedSize);
+        if (sizeClass >= this.sizeBuckets) {
+            return this.allocateLarge(alignedSize);
+        }
+        const freeListOffset = this.poolOffset + sizeClass * 8;
+        let attempts = 0;
+        const maxAttempts = 16;
+        while(attempts < maxAttempts){
+            const currentHead = AtomicOperations.loadAcquire(this.buffer, freeListOffset);
+            if (currentHead === 0) {
+                // No free chunks in this size class, try larger size class
+                return this.allocateFromLargerClass(sizeClass + 1, alignedSize);
+            }
+            // Read next pointer before attempting CAS
+            const nextChunk = AtomicOperations.loadAcquire(this.buffer, currentHead);
+            // Attempt to update free list head
+            const success = AtomicOperations.compareAndSwap32(this.buffer, freeListOffset, currentHead, nextChunk);
+            if (success === currentHead) {
+                // Update allocation count
+                AtomicOperations.atomicDecrement(this.buffer, freeListOffset + 4);
+                // Initialize allocated chunk header
+                this.initializeAllocatedChunk(currentHead, alignedSize, sizeClass);
+                return currentHead;
+            }
+            AtomicOperations.backoff(attempts);
+            attempts++;
+        }
+        return 0; // Allocation failed
+    }
+    /**
    * Lock-free deallocation returning chunk to appropriate free list
-   */
-  deallocate(chunkOffset) {
-    if (chunkOffset === 0) return;
-
-    // Read chunk header to determine size class
-    const sizeClass = this.getChunkSizeClass(chunkOffset);
-    const freeListOffset = this.poolOffset + (sizeClass * 8);
-
-    let attempts = 0;
-    const maxAttempts = 16;
-
-    while (attempts < maxAttempts) {
-      const currentHead = AtomicOperations.loadAcquire(this.buffer, freeListOffset);
-
-      // Set next pointer of chunk being freed
-      AtomicOperations.storeRelease(this.buffer, chunkOffset, currentHead);
-
-      // Attempt to update free list head
-      const success = AtomicOperations.compareAndSwap32(
-        this.buffer, freeListOffset, currentHead, chunkOffset
-      );
-
-      if (success === currentHead) {
-        // Update free count
-        AtomicOperations.atomicIncrement(this.buffer, freeListOffset + 4);
-
-        // Clear chunk header for security
-        this.clearChunkHeader(chunkOffset);
-        return;
-      }
-
-      AtomicOperations.backoff(attempts);
-      attempts++;
-    }
-  }
-
-  /**
+   */ deallocate(chunkOffset) {
+        if (chunkOffset === 0) return;
+        // Read chunk header to determine size class
+        const sizeClass = this.getChunkSizeClass(chunkOffset);
+        const freeListOffset = this.poolOffset + sizeClass * 8;
+        let attempts = 0;
+        const maxAttempts = 16;
+        while(attempts < maxAttempts){
+            const currentHead = AtomicOperations.loadAcquire(this.buffer, freeListOffset);
+            // Set next pointer of chunk being freed
+            AtomicOperations.storeRelease(this.buffer, chunkOffset, currentHead);
+            // Attempt to update free list head
+            const success = AtomicOperations.compareAndSwap32(this.buffer, freeListOffset, currentHead, chunkOffset);
+            if (success === currentHead) {
+                // Update free count
+                AtomicOperations.atomicIncrement(this.buffer, freeListOffset + 4);
+                // Clear chunk header for security
+                this.clearChunkHeader(chunkOffset);
+                return;
+            }
+            AtomicOperations.backoff(attempts);
+            attempts++;
+        }
+    }
+    /**
    * Align size to chunk boundaries
-   */
-  alignSize(size) {
-    return Math.ceil(size / this.chunkSize) * this.chunkSize;
-  }
-
-  /**
+   */ alignSize(size) {
+        return Math.ceil(size / this.chunkSize) * this.chunkSize;
+    }
+    /**
    * Determine size class for allocation size
-   */
-  getSizeClass(alignedSize) {
-    const chunks = alignedSize / this.chunkSize;
-    return Math.floor(Math.log2(chunks));
-  }
-
-  /**
+   */ getSizeClass(alignedSize) {
+        const chunks = alignedSize / this.chunkSize;
+        return Math.floor(Math.log2(chunks));
+    }
+    /**
    * Allocate from larger size class when smaller classes are exhausted
-   */
-  allocateFromLargerClass(sizeClass, requestedSize) {
-    if (sizeClass >= this.sizeBuckets) {
-      return 0; // No larger classes available
-    }
-
-    const chunk = this.allocate(this.chunkSize * (1 << sizeClass));
-    if (chunk === 0) {
-      return this.allocateFromLargerClass(sizeClass + 1, requestedSize);
-    }
-
-    // Split chunk if it's significantly larger than requested
-    const chunkSize = this.chunkSize * (1 << sizeClass);
-    if (chunkSize > requestedSize * 2) {
-      this.splitChunk(chunk, requestedSize, chunkSize);
-    }
-
-    return chunk;
-  }
-
-  /**
+   */ allocateFromLargerClass(sizeClass, requestedSize) {
+        if (sizeClass >= this.sizeBuckets) {
+            return 0; // No larger classes available
+        }
+        const chunk = this.allocate(this.chunkSize * (1 << sizeClass));
+        if (chunk === 0) {
+            return this.allocateFromLargerClass(sizeClass + 1, requestedSize);
+        }
+        // Split chunk if it's significantly larger than requested
+        const chunkSize = this.chunkSize * (1 << sizeClass);
+        if (chunkSize > requestedSize * 2) {
+            this.splitChunk(chunk, requestedSize, chunkSize);
+        }
+        return chunk;
+    }
+    /**
    * Split large chunk into smaller pieces
-   */
-  splitChunk(chunkOffset, requestedSize, chunkSize) {
-    const remainderOffset = chunkOffset + requestedSize;
-    const remainderSize = chunkSize - requestedSize;
-
-    if (remainderSize >= this.chunkSize) {
-      // Return remainder to appropriate free list
-      const remainderSizeClass = this.getSizeClass(remainderSize);
-      this.initializeAllocatedChunk(remainderOffset, remainderSize, remainderSizeClass);
-      this.deallocate(remainderOffset);
-    }
-  }
-
-  /**
+   */ splitChunk(chunkOffset, requestedSize, chunkSize) {
+        const remainderOffset = chunkOffset + requestedSize;
+        const remainderSize = chunkSize - requestedSize;
+        if (remainderSize >= this.chunkSize) {
+            // Return remainder to appropriate free list
+            const remainderSizeClass = this.getSizeClass(remainderSize);
+            this.initializeAllocatedChunk(remainderOffset, remainderSize, remainderSizeClass);
+            this.deallocate(remainderOffset);
+        }
+    }
+    /**
    * Initialize allocated chunk header with metadata
-   */
-  initializeAllocatedChunk(chunkOffset, size, sizeClass) {
-    // Chunk header format: [size: 4 bytes][sizeClass: 4 bytes][reserved: 8 bytes]
-    AtomicOperations.storeRelease(this.buffer, chunkOffset - 16, size);
-    AtomicOperations.storeRelease(this.buffer, chunkOffset - 12, sizeClass);
-    AtomicOperations.storeRelease(this.buffer, chunkOffset - 8, 0); // Reserved
-    AtomicOperations.storeRelease(this.buffer, chunkOffset - 4, 0); // Reserved
-  }
-
-  /**
+   */ initializeAllocatedChunk(chunkOffset, size, sizeClass) {
+        // Chunk header format: [size: 4 bytes][sizeClass: 4 bytes][reserved: 8 bytes]
+        AtomicOperations.storeRelease(this.buffer, chunkOffset - 16, size);
+        AtomicOperations.storeRelease(this.buffer, chunkOffset - 12, sizeClass);
+        AtomicOperations.storeRelease(this.buffer, chunkOffset - 8, 0); // Reserved
+        AtomicOperations.storeRelease(this.buffer, chunkOffset - 4, 0); // Reserved
+    }
+    /**
    * Get size class from chunk header
-   */
-  getChunkSizeClass(chunkOffset) {
-    return AtomicOperations.loadAcquire(this.buffer, chunkOffset - 12);
-  }
-
-  /**
+   */ getChunkSizeClass(chunkOffset) {
+        return AtomicOperations.loadAcquire(this.buffer, chunkOffset - 12);
+    }
+    /**
    * Clear chunk header for security
-   */
-  clearChunkHeader(chunkOffset) {
-    // Clear sensitive data
-    AtomicOperations.storeRelease(this.buffer, chunkOffset - 16, 0);
-    AtomicOperations.storeRelease(this.buffer, chunkOffset - 12, 0);
-  }
-
-  /**
+   */ clearChunkHeader(chunkOffset) {
+        // Clear sensitive data
+        AtomicOperations.storeRelease(this.buffer, chunkOffset - 16, 0);
+        AtomicOperations.storeRelease(this.buffer, chunkOffset - 12, 0);
+    }
+    /**
    * Get memory pool statistics
-   */
-  getPoolStats() {
-    const stats = {
-      totalSize: this.poolSize,
-      allocatedBytes: 0,
-      freeBytes: 0,
-      fragmentationRatio: 0,
-      sizeClassStats: []
-    };
-
-    for (let sizeClass = 0; sizeClass < this.sizeBuckets; sizeClass++) {
-      const freeListOffset = this.poolOffset + (sizeClass * 8);
-      const freeCount = AtomicOperations.loadAcquire(this.buffer, freeListOffset + 4);
-      const chunkSize = this.chunkSize * (1 << sizeClass);
-
-      stats.sizeClassStats[sizeClass] = {
-        chunkSize,
-        freeChunks: freeCount,
-        freeBytes: freeCount * chunkSize
-      };
-
-      stats.freeBytes += freeCount * chunkSize;
-    }
-
-    stats.allocatedBytes = stats.totalSize - stats.freeBytes;
-    stats.fragmentationRatio = stats.freeBytes / stats.totalSize;
-
-    return stats;
-  }
-}
-
+   */ getPoolStats() {
+        const stats = {
+            totalSize: this.poolSize,
+            allocatedBytes: 0,
+            freeBytes: 0,
+            fragmentationRatio: 0,
+            sizeClassStats: []
+        };
+        for(let sizeClass = 0; sizeClass < this.sizeBuckets; sizeClass++){
+            const freeListOffset = this.poolOffset + sizeClass * 8;
+            const freeCount = AtomicOperations.loadAcquire(this.buffer, freeListOffset + 4);
+            const chunkSize = this.chunkSize * (1 << sizeClass);
+            stats.sizeClassStats[sizeClass] = {
+                chunkSize,
+                freeChunks: freeCount,
+                freeBytes: freeCount * chunkSize
+            };
+            stats.freeBytes += freeCount * chunkSize;
+        }
+        stats.allocatedBytes = stats.totalSize - stats.freeBytes;
+        stats.fragmentationRatio = stats.freeBytes / stats.totalSize;
+        return stats;
+    }
+    constructor(sharedBuffer, poolOffset, poolSize){
+        this.buffer = sharedBuffer;
+        this.poolOffset = poolOffset;
+        this.poolSize = poolSize;
+        this.chunkSize = 64; // Minimum allocation unit (cache line aligned)
+        this.sizeBuckets = 16; // Number of different size classes
+        this.initializeFreeLists();
+    }
+}
 /**
  * Lock-free ring buffer for high-throughput message passing
- */
-export class LockFreeRingBuffer {
-  constructor(sharedBuffer, ringOffset, ringSize) {
-    this.buffer = sharedBuffer;
-    this.ringOffset = ringOffset;
-    this.ringSize = ringSize;
-    this.slotSize = 64; // Each message slot size
-    this.slotCount = Math.floor(ringSize / this.slotSize);
-
-    // Ring buffer control structure
-    this.headOffset = ringOffset - 16; // Producer position
-    this.tailOffset = ringOffset - 12; // Consumer position
-    this.countOffset = ringOffset - 8;  // Current count
-    this.flagsOffset = ringOffset - 4;  // Control flags
-
-    this.initialize();
-  }
-
-  /**
+ */ export class LockFreeRingBuffer {
+    /**
    * Initialize ring buffer control structure
-   */
-  initialize() {
-    AtomicOperations.storeRelease(this.buffer, this.headOffset, 0);
-    AtomicOperations.storeRelease(this.buffer, this.tailOffset, 0);
-    AtomicOperations.storeRelease(this.buffer, this.countOffset, 0);
-    AtomicOperations.storeRelease(this.buffer, this.flagsOffset, 0);
-  }
-
-  /**
+   */ initialize() {
+        AtomicOperations.storeRelease(this.buffer, this.headOffset, 0);
+        AtomicOperations.storeRelease(this.buffer, this.tailOffset, 0);
+        AtomicOperations.storeRelease(this.buffer, this.countOffset, 0);
+        AtomicOperations.storeRelease(this.buffer, this.flagsOffset, 0);
+    }
+    /**
    * Lock-free enqueue operation
-   */
-  enqueue(messageData) {
-    if (messageData.length > this.slotSize - 8) {
-      return false; // Message too large
-    }
-
-    let attempts = 0;
-    const maxAttempts = 100;
-
-    while (attempts < maxAttempts) {
-      const currentHead = AtomicOperations.loadAcquire(this.buffer, this.headOffset);
-      const currentTail = AtomicOperations.loadAcquire(this.buffer, this.tailOffset);
-      const currentCount = AtomicOperations.loadAcquire(this.buffer, this.countOffset);
-
-      // Check if buffer is full
-      if (currentCount >= this.slotCount) {
-        return false; // Buffer full
-      }
-
-      const newHead = (currentHead + 1) % this.slotCount;
-      const slotOffset = this.ringOffset + (currentHead * this.slotSize);
-
-      // Reserve slot by advancing head
-      const success = AtomicOperations.compareAndSwap32(
-        this.buffer, this.headOffset, currentHead, newHead
-      );
-
-      if (success === currentHead) {
-        // Write message to reserved slot
-        this.writeMessageToSlot(slotOffset, messageData);
-
-        // Update count atomically
-        AtomicOperations.atomicIncrement(this.buffer, this.countOffset);
-        return true;
-      }
-
-      AtomicOperations.backoff(attempts);
-      attempts++;
-    }
-
-    return false; // Failed after max attempts
-  }
-
-  /**
+   */ enqueue(messageData) {
+        if (messageData.length > this.slotSize - 8) {
+            return false; // Message too large
+        }
+        let attempts = 0;
+        const maxAttempts = 100;
+        while(attempts < maxAttempts){
+            const currentHead = AtomicOperations.loadAcquire(this.buffer, this.headOffset);
+            const currentTail = AtomicOperations.loadAcquire(this.buffer, this.tailOffset);
+            const currentCount = AtomicOperations.loadAcquire(this.buffer, this.countOffset);
+            // Check if buffer is full
+            if (currentCount >= this.slotCount) {
+                return false; // Buffer full
+            }
+            const newHead = (currentHead + 1) % this.slotCount;
+            const slotOffset = this.ringOffset + currentHead * this.slotSize;
+            // Reserve slot by advancing head
+            const success = AtomicOperations.compareAndSwap32(this.buffer, this.headOffset, currentHead, newHead);
+            if (success === currentHead) {
+                // Write message to reserved slot
+                this.writeMessageToSlot(slotOffset, messageData);
+                // Update count atomically
+                AtomicOperations.atomicIncrement(this.buffer, this.countOffset);
+                return true;
+            }
+            AtomicOperations.backoff(attempts);
+            attempts++;
+        }
+        return false; // Failed after max attempts
+    }
+    /**
    * Lock-free dequeue operation
-   */
-  dequeue() {
-    let attempts = 0;
-    const maxAttempts = 100;
-
-    while (attempts < maxAttempts) {
-      const currentTail = AtomicOperations.loadAcquire(this.buffer, this.tailOffset);
-      const currentHead = AtomicOperations.loadAcquire(this.buffer, this.headOffset);
-      const currentCount = AtomicOperations.loadAcquire(this.buffer, this.countOffset);
-
-      // Check if buffer is empty
-      if (currentCount === 0) {
-        return null; // Buffer empty
-      }
-
-      const newTail = (currentTail + 1) % this.slotCount;
-      const slotOffset = this.ringOffset + (currentTail * this.slotSize);
-
-      // Reserve slot by advancing tail
-      const success = AtomicOperations.compareAndSwap32(
-        this.buffer, this.tailOffset, currentTail, newTail
-      );
-
-      if (success === currentTail) {
-        // Read message from reserved slot
-        const messageData = this.readMessageFromSlot(slotOffset);
-
-        // Update count atomically
-        AtomicOperations.atomicDecrement(this.buffer, this.countOffset);
-        return messageData;
-      }
-
-      AtomicOperations.backoff(attempts);
-      attempts++;
-    }
-
-    return null; // Failed after max attempts
-  }
-
-  /**
+   */ dequeue() {
+        let attempts = 0;
+        const maxAttempts = 100;
+        while(attempts < maxAttempts){
+            const currentTail = AtomicOperations.loadAcquire(this.buffer, this.tailOffset);
+            const currentHead = AtomicOperations.loadAcquire(this.buffer, this.headOffset);
+            const currentCount = AtomicOperations.loadAcquire(this.buffer, this.countOffset);
+            // Check if buffer is empty
+            if (currentCount === 0) {
+                return null; // Buffer empty
+            }
+            const newTail = (currentTail + 1) % this.slotCount;
+            const slotOffset = this.ringOffset + currentTail * this.slotSize;
+            // Reserve slot by advancing tail
+            const success = AtomicOperations.compareAndSwap32(this.buffer, this.tailOffset, currentTail, newTail);
+            if (success === currentTail) {
+                // Read message from reserved slot
+                const messageData = this.readMessageFromSlot(slotOffset);
+                // Update count atomically
+                AtomicOperations.atomicDecrement(this.buffer, this.countOffset);
+                return messageData;
+            }
+            AtomicOperations.backoff(attempts);
+            attempts++;
+        }
+        return null; // Failed after max attempts
+    }
+    /**
    * Write message data to ring buffer slot
-   */
-  writeMessageToSlot(slotOffset, messageData) {
-    // Slot format: [length: 4 bytes][timestamp: 4 bytes][data: variable]
-    AtomicOperations.storeRelease(this.buffer, slotOffset, messageData.length);
-    AtomicOperations.storeRelease(this.buffer, slotOffset + 4,
-      Math.floor(performance.now() * 1000000) & 0xFFFFFFFF);
-
-    // Copy message data
-    const dataView = new Uint8Array(this.buffer, slotOffset + 8, messageData.length);
-    dataView.set(messageData);
-  }
-
-  /**
+   */ writeMessageToSlot(slotOffset, messageData) {
+        // Slot format: [length: 4 bytes][timestamp: 4 bytes][data: variable]
+        AtomicOperations.storeRelease(this.buffer, slotOffset, messageData.length);
+        AtomicOperations.storeRelease(this.buffer, slotOffset + 4, Math.floor(performance.now() * 1000000) & 0xFFFFFFFF);
+        // Copy message data
+        const dataView = new Uint8Array(this.buffer, slotOffset + 8, messageData.length);
+        dataView.set(messageData);
+    }
+    /**
    * Read message data from ring buffer slot
-   */
-  readMessageFromSlot(slotOffset) {
-    const length = AtomicOperations.loadAcquire(this.buffer, slotOffset);
-    const timestamp = AtomicOperations.loadAcquire(this.buffer, slotOffset + 4);
-
-    const messageData = new Uint8Array(length);
-    const dataView = new Uint8Array(this.buffer, slotOffset + 8, length);
-    messageData.set(dataView);
-
-    return {
-      data: messageData,
-      timestamp,
-      length
-    };
-  }
-
-  /**
+   */ readMessageFromSlot(slotOffset) {
+        const length = AtomicOperations.loadAcquire(this.buffer, slotOffset);
+        const timestamp = AtomicOperations.loadAcquire(this.buffer, slotOffset + 4);
+        const messageData = new Uint8Array(length);
+        const dataView = new Uint8Array(this.buffer, slotOffset + 8, length);
+        messageData.set(dataView);
+        return {
+            data: messageData,
+            timestamp,
+            length
+        };
+    }
+    /**
    * Get ring buffer statistics
-   */
-  getStats() {
-    return {
-      size: this.slotCount,
-      count: AtomicOperations.loadAcquire(this.buffer, this.countOffset),
-      head: AtomicOperations.loadAcquire(this.buffer, this.headOffset),
-      tail: AtomicOperations.loadAcquire(this.buffer, this.tailOffset),
-      utilization: AtomicOperations.loadAcquire(this.buffer, this.countOffset) / this.slotCount
-    };
-  }
-}
-
+   */ getStats() {
+        return {
+            size: this.slotCount,
+            count: AtomicOperations.loadAcquire(this.buffer, this.countOffset),
+            head: AtomicOperations.loadAcquire(this.buffer, this.headOffset),
+            tail: AtomicOperations.loadAcquire(this.buffer, this.tailOffset),
+            utilization: AtomicOperations.loadAcquire(this.buffer, this.countOffset) / this.slotCount
+        };
+    }
+    constructor(sharedBuffer, ringOffset, ringSize){
+        this.buffer = sharedBuffer;
+        this.ringOffset = ringOffset;
+        this.ringSize = ringSize;
+        this.slotSize = 64; // Each message slot size
+        this.slotCount = Math.floor(ringSize / this.slotSize);
+        // Ring buffer control structure
+        this.headOffset = ringOffset - 16; // Producer position
+        this.tailOffset = ringOffset - 12; // Consumer position
+        this.countOffset = ringOffset - 8; // Current count
+        this.flagsOffset = ringOffset - 4; // Control flags
+        this.initialize();
+    }
+}
 /**
  * Performance benchmarking utilities for lock-free structures
- */
-export class LockFreePerformanceBenchmark {
-  constructor() {
-    this.samples = new Array(100000);
-    this.sampleIndex = 0;
-    this.operationCounts = new Map();
-  }
-
-  /**
+ */ export class LockFreePerformanceBenchmark {
+    /**
    * Measure operation with nanosecond precision
-   */
-  measureOperation(operationName, operation) {
-    const start = performance.now() * 1000000; // Convert to nanoseconds
-    const result = operation();
-    const end = performance.now() * 1000000;
-
-    const duration = end - start;
-    this.recordSample(operationName, duration);
-
-    return { result, duration };
-  }
-
-  /**
+   */ measureOperation(operationName, operation) {
+        const start = performance.now() * 1000000; // Convert to nanoseconds
+        const result = operation();
+        const end = performance.now() * 1000000;
+        const duration = end - start;
+        this.recordSample(operationName, duration);
+        return {
+            result,
+            duration
+        };
+    }
+    /**
    * Concurrent benchmark with multiple threads
-   */
-  async concurrentBenchmark(operationName, operation, threadCount = 4, operationsPerThread = 10000) {
-    const workers = [];
-    const results = [];
-
-    for (let i = 0; i < threadCount; i++) {
-      const worker = new Promise((resolve) => {
-        const threadResults = [];
-        const startTime = performance.now() * 1000000;
-
-        for (let j = 0; j < operationsPerThread; j++) {
-          const { duration } = this.measureOperation(operationName, operation);
-          threadResults.push(duration);
-        }
-
-        const endTime = performance.now() * 1000000;
-        resolve({
-          threadId: i,
-          results: threadResults,
-          totalTime: endTime - startTime,
-          throughput: operationsPerThread / ((endTime - startTime) / 1000000000)
-        });
-      });
-
-      workers.push(worker);
-    }
-
-    const threadResults = await Promise.all(workers);
-    return this.analyzeConcurrentResults(threadResults);
-  }
-
-  /**
+   */ async concurrentBenchmark(operationName, operation, threadCount = 4, operationsPerThread = 10000) {
+        const workers = [];
+        const results = [];
+        for(let i = 0; i < threadCount; i++){
+            const worker = new Promise((resolve)=>{
+                const threadResults = [];
+                const startTime = performance.now() * 1000000;
+                for(let j = 0; j < operationsPerThread; j++){
+                    const { duration } = this.measureOperation(operationName, operation);
+                    threadResults.push(duration);
+                }
+                const endTime = performance.now() * 1000000;
+                resolve({
+                    threadId: i,
+                    results: threadResults,
+                    totalTime: endTime - startTime,
+                    throughput: operationsPerThread / ((endTime - startTime) / 1000000000)
+                });
+            });
+            workers.push(worker);
+        }
+        const threadResults = await Promise.all(workers);
+        return this.analyzeConcurrentResults(threadResults);
+    }
+    /**
    * Record performance sample
-   */
-  recordSample(operationName, duration) {
-    if (!this.operationCounts.has(operationName)) {
-      this.operationCounts.set(operationName, []);
-    }
-
-    const samples = this.operationCounts.get(operationName);
-    samples.push(duration);
-
-    if (samples.length > 10000) {
-      samples.shift(); // Keep only recent samples
-    }
-  }
-
-  /**
+   */ recordSample(operationName, duration) {
+        if (!this.operationCounts.has(operationName)) {
+            this.operationCounts.set(operationName, []);
+        }
+        const samples = this.operationCounts.get(operationName);
+        samples.push(duration);
+        if (samples.length > 10000) {
+            samples.shift(); // Keep only recent samples
+        }
+    }
+    /**
    * Analyze concurrent benchmark results
-   */
-  analyzeConcurrentResults(threadResults) {
-    const allDurations = threadResults.flatMap(r => r.results);
-    allDurations.sort((a, b) => a - b);
-
-    const totalThroughput = threadResults.reduce((sum, r) => sum + r.throughput, 0);
-
-    return {
-      totalOperations: allDurations.length,
-      totalThroughput,
-      avgThroughputPerThread: totalThroughput / threadResults.length,
-      latencyStats: {
-        min: allDurations[0],
-        max: allDurations[allDurations.length - 1],
-        median: allDurations[Math.floor(allDurations.length / 2)],
-        p95: allDurations[Math.floor(allDurations.length * 0.95)],
-        p99: allDurations[Math.floor(allDurations.length * 0.99)],
-        p999: allDurations[Math.floor(allDurations.length * 0.999)],
-        mean: allDurations.reduce((a, b) => a + b, 0) / allDurations.length
-      },
-      threadResults
-    };
-  }
-
-  /**
+   */ analyzeConcurrentResults(threadResults) {
+        const allDurations = threadResults.flatMap((r)=>r.results);
+        allDurations.sort((a, b)=>a - b);
+        const totalThroughput = threadResults.reduce((sum, r)=>sum + r.throughput, 0);
+        return {
+            totalOperations: allDurations.length,
+            totalThroughput,
+            avgThroughputPerThread: totalThroughput / threadResults.length,
+            latencyStats: {
+                min: allDurations[0],
+                max: allDurations[allDurations.length - 1],
+                median: allDurations[Math.floor(allDurations.length / 2)],
+                p95: allDurations[Math.floor(allDurations.length * 0.95)],
+                p99: allDurations[Math.floor(allDurations.length * 0.99)],
+                p999: allDurations[Math.floor(allDurations.length * 0.999)],
+                mean: allDurations.reduce((a, b)=>a + b, 0) / allDurations.length
+            },
+            threadResults
+        };
+    }
+    /**
    * Generate performance report
-   */
-  generateReport() {
-    const report = {
-      timestamp: Date.now(),
-      operations: {}
-    };
-
-    for (const [operationName, samples] of this.operationCounts) {
-      const sortedSamples = [...samples].sort((a, b) => a - b);
-
-      report.operations[operationName] = {
-        sampleCount: samples.length,
-        min: sortedSamples[0],
-        max: sortedSamples[sortedSamples.length - 1],
-        median: sortedSamples[Math.floor(sortedSamples.length / 2)],
-        p95: sortedSamples[Math.floor(sortedSamples.length * 0.95)],
-        p99: sortedSamples[Math.floor(sortedSamples.length * 0.99)],
-        mean: samples.reduce((a, b) => a + b, 0) / samples.length,
-        targetMet: {
-          read: sortedSamples[Math.floor(sortedSamples.length * 0.95)] < 100, // <100ns p95
-          write: sortedSamples[Math.floor(sortedSamples.length * 0.95)] < 500  // <500ns p95
-        }
-      };
-    }
-
-    return report;
-  }
-}
+   */ generateReport() {
+        const report = {
+            timestamp: Date.now(),
+            operations: {}
+        };
+        for (const [operationName, samples] of this.operationCounts){
+            const sortedSamples = [
+                ...samples
+            ].sort((a, b)=>a - b);
+            report.operations[operationName] = {
+                sampleCount: samples.length,
+                min: sortedSamples[0],
+                max: sortedSamples[sortedSamples.length - 1],
+                median: sortedSamples[Math.floor(sortedSamples.length / 2)],
+                p95: sortedSamples[Math.floor(sortedSamples.length * 0.95)],
+                p99: sortedSamples[Math.floor(sortedSamples.length * 0.99)],
+                mean: samples.reduce((a, b)=>a + b, 0) / samples.length,
+                targetMet: {
+                    read: sortedSamples[Math.floor(sortedSamples.length * 0.95)] < 100,
+                    write: sortedSamples[Math.floor(sortedSamples.length * 0.95)] < 500 // <500ns p95
+                }
+            };
+        }
+        return report;
+    }
+    constructor(){
+        this.samples = new Array(100000);
+        this.sampleIndex = 0;
+        this.operationCounts = new Map();
+    }
+}