claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/memory/ultra-fast-memory-store.js

@@ -9,655 +9,854 @@
  * - Write operations: <500 nanoseconds (P95)
  * - Concurrent throughput: >10M operations/second
  * - Memory efficiency: >90% utilization
- */ import { LockFreeHashTable, LockFreeMemoryPool, AtomicOperations } from "./lock-free-structures.js";
-import { AdvancedMemoryPressureManager } from "./memory-pressure-manager.js";
-import { HighPerformanceHash, FastSerializer } from "./high-performance-serialization.js";
-import { MemoryMappedPersistence, BackupStrategyManager } from "./memory-mapped-persistence.js";
+ */
+
+import {
+  LockFreeHashTable,
+  LockFreeMemoryPool,
+  LockFreeRingBuffer,
+  AtomicOperations
+} from './lock-free-structures.js';
+
+import {
+  AdvancedMemoryPressureManager,
+  MEMORY_PRESSURE_CONFIG
+} from './memory-pressure-manager.js';
+
+import {
+  HighPerformanceHash,
+  FastSerializer,
+  NamespaceKeySerializer
+} from './high-performance-serialization.js';
+
+import {
+  MemoryMappedPersistence,
+  BackupStrategyManager
+} from './memory-mapped-persistence.js';
+
 /**
  * Memory store configuration optimized for performance
- */ const ULTRA_FAST_CONFIG = {
-    // Memory layout
-    DEFAULT_SIZE: 64 * 1024 * 1024,
-    HEADER_SIZE: 1024,
-    BUCKET_COUNT: 16384,
-    REGION_SIZE: 4096,
-    // Performance tuning
-    CACHE_LINE_SIZE: 64,
-    MAX_KEY_SIZE: 256,
-    MAX_VALUE_SIZE: 64 * 1024,
-    THREAD_CACHE_SIZE: 16,
-    // Concurrency settings
-    MAX_CONCURRENT_OPERATIONS: 1000,
-    BACKOFF_MAX_ATTEMPTS: 16,
-    SPIN_LOCK_ITERATIONS: 100,
-    // Memory management
-    MEMORY_POOL_RATIO: 0.7,
-    METADATA_RATIO: 0.2,
-    RESERVE_RATIO: 0.1,
-    // Performance monitoring
-    ENABLE_METRICS: true,
-    SAMPLING_RATE: 0.01,
-    METRIC_HISTORY_SIZE: 10000 // Number of samples to keep
-};
+ */
+const ULTRA_FAST_CONFIG = {
+  // Memory layout
+  DEFAULT_SIZE: 64 * 1024 * 1024,    // 64MB default
+  HEADER_SIZE: 1024,                 // 1KB header
+  BUCKET_COUNT: 16384,               // Hash table buckets
+  REGION_SIZE: 4096,                 // 4KB memory regions
+
+  // Performance tuning
+  CACHE_LINE_SIZE: 64,               // CPU cache line alignment
+  MAX_KEY_SIZE: 256,                 // Maximum key size in bytes
+  MAX_VALUE_SIZE: 64 * 1024,         // Maximum value size (64KB)
+  THREAD_CACHE_SIZE: 16,             // Thread-local cache size
+
+  // Concurrency settings
+  MAX_CONCURRENT_OPERATIONS: 1000,   // Maximum concurrent operations
+  BACKOFF_MAX_ATTEMPTS: 16,          // CAS retry attempts
+  SPIN_LOCK_ITERATIONS: 100,         // Spin lock iterations
+
+  // Memory management
+  MEMORY_POOL_RATIO: 0.7,            // 70% for data pool
+  METADATA_RATIO: 0.2,               // 20% for metadata
+  RESERVE_RATIO: 0.1,                // 10% reserve
+
+  // Performance monitoring
+  ENABLE_METRICS: true,              // Enable performance counters
+  SAMPLING_RATE: 0.01,               // 1% sampling for detailed metrics
+  METRIC_HISTORY_SIZE: 10000         // Number of samples to keep
+};
+
 /**
  * SharedArrayBuffer memory layout
- */ const MEMORY_LAYOUT = {
-    // Header (1KB) - cache line aligned
-    HEADER: {
-        offset: 0,
-        size: 1024
-    },
-    // Hash table buckets
-    HASH_TABLE: {
-        offset: 1024,
-        size: 16384 * 32 // 16K buckets * 32 bytes each
-    },
-    // Memory pool for entries
-    MEMORY_POOL: {
-        offset: 1024 + 16384 * 32,
-        size: null // Calculated based on remaining space
-    },
-    // Performance counters
-    COUNTERS: {
-        offset: null,
-        size: 1024
-    }
-};
+ */
+const MEMORY_LAYOUT = {
+  // Header (1KB) - cache line aligned
+  HEADER: {
+    offset: 0,
+    size: 1024
+  },
+
+  // Hash table buckets
+  HASH_TABLE: {
+    offset: 1024,
+    size: 16384 * 32  // 16K buckets * 32 bytes each
+  },
+
+  // Memory pool for entries
+  MEMORY_POOL: {
+    offset: 1024 + (16384 * 32),
+    size: null  // Calculated based on remaining space
+  },
+
+  // Performance counters
+  COUNTERS: {
+    offset: null, // Calculated
+    size: 1024
+  }
+};
+
 /**
  * Entry layout in memory (cache-aligned)
- */ const ENTRY_LAYOUT = {
-    next: 0,
-    keyHash: 4,
-    keyLength: 8,
-    valueLength: 10,
-    namespace: 12,
-    timestamp: 16,
-    flags: 24,
-    checksum: 28,
-    keyData: 32,
-    valueData: null // Variable - Value data (follows key)
-};
+ */
+const ENTRY_LAYOUT = {
+  next: 0,           // uint32 - Next entry in chain (4 bytes)
+  keyHash: 4,        // uint32 - Full key hash (4 bytes)
+  keyLength: 8,      // uint16 - Key length (2 bytes)
+  valueLength: 10,   // uint16 - Value length (2 bytes)
+  namespace: 12,     // uint32 - Namespace ID (4 bytes)
+  timestamp: 16,     // uint64 - Access timestamp (8 bytes)
+  flags: 24,         // uint32 - Entry flags (4 bytes)
+  checksum: 28,      // uint32 - Entry checksum (4 bytes)
+  keyData: 32,       // Variable - Key data (aligned to 8 bytes)
+  valueData: null    // Variable - Value data (follows key)
+};
+
 /**
  * Ultra-fast memory store implementation
- */ export class UltraFastMemoryStore {
-    /**
+ */
+export class UltraFastMemoryStore {
+  constructor(config = ULTRA_FAST_CONFIG) {
+    this.config = { ...ULTRA_FAST_CONFIG, ...config };
+
+    // Initialize SharedArrayBuffer
+    this.sharedBuffer = new SharedArrayBuffer(this.config.DEFAULT_SIZE);
+    this.bufferSize = this.config.DEFAULT_SIZE;
+
+    // Calculate memory layout offsets
+    this.calculateMemoryLayout();
+
+    // Initialize core components
+    this.initializeComponents();
+
+    // Performance monitoring
+    this.performanceCounters = new Map();
+    this.operationSampler = new Map();
+
+    // State tracking
+    this.isInitialized = false;
+    this.startTime = performance.now();
+
+    console.log(`UltraFastMemoryStore initialized: ${this.bufferSize} bytes`);
+  }
+
+  /**
    * Calculate memory layout based on buffer size
-   */ calculateMemoryLayout() {
-        let offset = MEMORY_LAYOUT.HEADER.offset + MEMORY_LAYOUT.HEADER.size;
-        // Hash table
-        MEMORY_LAYOUT.HASH_TABLE.offset = offset;
-        offset += MEMORY_LAYOUT.HASH_TABLE.size;
-        // Memory pool (majority of space)
-        MEMORY_LAYOUT.MEMORY_POOL.offset = offset;
-        MEMORY_LAYOUT.MEMORY_POOL.size = this.bufferSize - offset - 1024; // Reserve 1KB for counters
-        // Performance counters at the end
-        MEMORY_LAYOUT.COUNTERS.offset = this.bufferSize - 1024;
-        MEMORY_LAYOUT.COUNTERS.size = 1024;
-    }
-    /**
+   */
+  calculateMemoryLayout() {
+    let offset = MEMORY_LAYOUT.HEADER.offset + MEMORY_LAYOUT.HEADER.size;
+
+    // Hash table
+    MEMORY_LAYOUT.HASH_TABLE.offset = offset;
+    offset += MEMORY_LAYOUT.HASH_TABLE.size;
+
+    // Memory pool (majority of space)
+    MEMORY_LAYOUT.MEMORY_POOL.offset = offset;
+    MEMORY_LAYOUT.MEMORY_POOL.size = this.bufferSize - offset - 1024; // Reserve 1KB for counters
+
+    // Performance counters at the end
+    MEMORY_LAYOUT.COUNTERS.offset = this.bufferSize - 1024;
+    MEMORY_LAYOUT.COUNTERS.size = 1024;
+  }
+
+  /**
    * Initialize all components
-   */ initializeComponents() {
-        // Initialize header
-        this.initializeHeader();
-        // Hash table for fast key lookup
-        this.hashTable = new LockFreeHashTable(this.sharedBuffer, this.config.BUCKET_COUNT, MEMORY_LAYOUT.HASH_TABLE.offset);
-        // Memory pool for entry allocation
-        this.memoryPool = new LockFreeMemoryPool(this.sharedBuffer, MEMORY_LAYOUT.MEMORY_POOL.offset, MEMORY_LAYOUT.MEMORY_POOL.size);
-        // Namespace management
-        this.namespaceManager = new NamespaceManager(this.sharedBuffer);
-        // Memory pressure management
-        this.memoryPressureManager = new AdvancedMemoryPressureManager(this);
-        // Persistence layer
-        this.persistence = null; // Initialized on demand
-        // Performance monitoring
-        this.initializePerformanceMonitoring();
-        this.isInitialized = true;
-    }
-    /**
+   */
+  initializeComponents() {
+    // Initialize header
+    this.initializeHeader();
+
+    // Hash table for fast key lookup
+    this.hashTable = new LockFreeHashTable(
+      this.sharedBuffer,
+      this.config.BUCKET_COUNT,
+      MEMORY_LAYOUT.HASH_TABLE.offset
+    );
+
+    // Memory pool for entry allocation
+    this.memoryPool = new LockFreeMemoryPool(
+      this.sharedBuffer,
+      MEMORY_LAYOUT.MEMORY_POOL.offset,
+      MEMORY_LAYOUT.MEMORY_POOL.size
+    );
+
+    // Namespace management
+    this.namespaceManager = new NamespaceManager(this.sharedBuffer);
+
+    // Memory pressure management
+    this.memoryPressureManager = new AdvancedMemoryPressureManager(this);
+
+    // Persistence layer
+    this.persistence = null; // Initialized on demand
+
+    // Performance monitoring
+    this.initializePerformanceMonitoring();
+
+    this.isInitialized = true;
+  }
+
+  /**
    * Initialize SharedArrayBuffer header
-   */ initializeHeader() {
-        const headerView = new DataView(this.sharedBuffer, 0, MEMORY_LAYOUT.HEADER.size);
-        // Magic number and version
-        headerView.setUint32(0, 0x464C4F57, true); // 'FLOW' magic
-        headerView.setUint32(4, 1, true); // Version 1
-        // Buffer information
-        headerView.setBigUint64(8, BigInt(this.bufferSize), true);
-        headerView.setUint32(16, this.config.BUCKET_COUNT, true);
-        headerView.setUint32(20, 0, true); // Entry count (atomic)
-        headerView.setUint32(24, 0, true); // Max entries
-        headerView.setUint32(28, 0, true); // Free head (atomic)
-        // Statistics counters
-        headerView.setBigUint64(32, BigInt(0), true); // Read counter
-        headerView.setBigUint64(40, BigInt(0), true); // Write counter
-        headerView.setBigUint64(48, BigInt(Date.now()), true); // Creation time
-    }
-    /**
+   */
+  initializeHeader() {
+    const headerView = new DataView(this.sharedBuffer, 0, MEMORY_LAYOUT.HEADER.size);
+
+    // Magic number and version
+    headerView.setUint32(0, 0x464C4F57, true);  // 'FLOW' magic
+    headerView.setUint32(4, 1, true);            // Version 1
+
+    // Buffer information
+    headerView.setBigUint64(8, BigInt(this.bufferSize), true);
+    headerView.setUint32(16, this.config.BUCKET_COUNT, true);
+    headerView.setUint32(20, 0, true);           // Entry count (atomic)
+    headerView.setUint32(24, 0, true);           // Max entries
+    headerView.setUint32(28, 0, true);           // Free head (atomic)
+
+    // Statistics counters
+    headerView.setBigUint64(32, BigInt(0), true);  // Read counter
+    headerView.setBigUint64(40, BigInt(0), true);  // Write counter
+    headerView.setBigUint64(48, BigInt(Date.now()), true); // Creation time
+  }
+
+  /**
    * Initialize performance monitoring
-   */ initializePerformanceMonitoring() {
-        if (!this.config.ENABLE_METRICS) return;
-        // Performance counters in shared memory
-        this.counterOffset = MEMORY_LAYOUT.COUNTERS.offset;
-        const counterView = new Uint32Array(this.sharedBuffer, this.counterOffset, MEMORY_LAYOUT.COUNTERS.size / 4);
-        // Initialize counters to zero
-        counterView.fill(0);
-        // Performance sampling
-        this.sampler = {
-            readSamples: [],
-            writeSamples: [],
-            maxSamples: this.config.METRIC_HISTORY_SIZE,
-            sampleRate: this.config.SAMPLING_RATE
-        };
-    }
-    /**
+   */
+  initializePerformanceMonitoring() {
+    if (!this.config.ENABLE_METRICS) return;
+
+    // Performance counters in shared memory
+    this.counterOffset = MEMORY_LAYOUT.COUNTERS.offset;
+    const counterView = new Uint32Array(
+      this.sharedBuffer,
+      this.counterOffset,
+      MEMORY_LAYOUT.COUNTERS.size / 4
+    );
+
+    // Initialize counters to zero
+    counterView.fill(0);
+
+    // Performance sampling
+    this.sampler = {
+      readSamples: [],
+      writeSamples: [],
+      maxSamples: this.config.METRIC_HISTORY_SIZE,
+      sampleRate: this.config.SAMPLING_RATE
+    };
+  }
+
+  /**
    * High-performance GET operation - Target: <100ns
-   */ get(namespace, key) {
-        const startTime = this.config.ENABLE_METRICS ? performance.now() * 1000000 : 0;
-        try {
-            // Resolve namespace (cached operation)
-            const namespaceId = this.namespaceManager.resolveNamespace(namespace);
-            // Calculate hash
-            const keyHash = HighPerformanceHash.xxhash32(key);
-            const namespacedHash = HighPerformanceHash.mixHash(namespaceId ^ keyHash);
-            // Find entry in hash table
-            const entryOffset = this.hashTable.lookup(namespacedHash, (entry)=>{
-                return this.compareKey(entry, namespaceId, key);
-            });
-            if (entryOffset === 0) {
-                // Key not found
-                this.incrementCounter('cacheMisses');
-                return null;
-            }
-            // Extract value from entry
-            const value = this.extractValue(entryOffset);
-            // Update access metadata (for eviction algorithms)
-            this.updateEntryAccess(entryOffset);
-            // Update statistics
-            this.incrementCounter('readOperations');
-            this.incrementCounter('cacheHits');
-            // Record performance sample
-            if (this.config.ENABLE_METRICS && this.shouldSample()) {
-                const duration = performance.now() * 1000000 - startTime;
-                this.recordPerformanceSample('read', duration);
-            }
-            return value;
-        } catch (error) {
-            this.incrementCounter('errors');
-            throw error;
-        }
-    }
-    /**
+   */
+  get(namespace, key) {
+    const startTime = this.config.ENABLE_METRICS ? performance.now() * 1000000 : 0;
+
+    try {
+      // Resolve namespace (cached operation)
+      const namespaceId = this.namespaceManager.resolveNamespace(namespace);
+
+      // Calculate hash
+      const keyHash = HighPerformanceHash.xxhash32(key);
+      const namespacedHash = HighPerformanceHash.mixHash(namespaceId ^ keyHash);
+
+      // Find entry in hash table
+      const entryOffset = this.hashTable.lookup(namespacedHash, (entry) => {
+        return this.compareKey(entry, namespaceId, key);
+      });
+
+      if (entryOffset === 0) {
+        // Key not found
+        this.incrementCounter('cacheMisses');
+        return null;
+      }
+
+      // Extract value from entry
+      const value = this.extractValue(entryOffset);
+
+      // Update access metadata (for eviction algorithms)
+      this.updateEntryAccess(entryOffset);
+
+      // Update statistics
+      this.incrementCounter('readOperations');
+      this.incrementCounter('cacheHits');
+
+      // Record performance sample
+      if (this.config.ENABLE_METRICS && this.shouldSample()) {
+        const duration = performance.now() * 1000000 - startTime;
+        this.recordPerformanceSample('read', duration);
+      }
+
+      return value;
+
+    } catch (error) {
+      this.incrementCounter('errors');
+      throw error;
+    }
+  }
+
+  /**
    * High-performance SET operation - Target: <500ns
-   */ async set(namespace, key, value) {
-        const startTime = this.config.ENABLE_METRICS ? performance.now() * 1000000 : 0;
-        try {
-            // Input validation
-            if (key.length > this.config.MAX_KEY_SIZE) {
-                throw new Error(`Key too large: ${key.length} > ${this.config.MAX_KEY_SIZE}`);
-            }
-            const serializedValue = FastSerializer.serialize(value);
-            if (serializedValue.length > this.config.MAX_VALUE_SIZE) {
-                throw new Error(`Value too large: ${serializedValue.length} > ${this.config.MAX_VALUE_SIZE}`);
-            }
-            // Resolve namespace
-            const namespaceId = this.namespaceManager.resolveNamespace(namespace);
-            // Calculate hash
-            const keyHash = HighPerformanceHash.xxhash32(key);
-            const namespacedHash = HighPerformanceHash.mixHash(namespaceId ^ keyHash);
-            // Check for existing entry
-            const existingOffset = this.hashTable.lookup(namespacedHash, (entry)=>{
-                return this.compareKey(entry, namespaceId, key);
-            });
-            if (existingOffset !== 0) {
-                // Update existing entry
-                const success = this.updateEntry(existingOffset, serializedValue);
-                if (success) {
-                    this.incrementCounter('writeOperations');
-                    this.recordWritePerformance(startTime);
-                    return true;
-                }
-            }
-            // Create new entry
-            const entrySize = this.calculateEntrySize(key, serializedValue);
-            const entryOffset = this.memoryPool.allocate(entrySize);
-            if (entryOffset === 0) {
-                // Memory pressure - trigger eviction
-                const evicted = await this.memoryPressureManager.checkMemoryPressure();
-                if (!evicted) {
-                    throw new Error('Cannot allocate memory: pool exhausted');
-                }
-                // Retry allocation after eviction
-                const retryOffset = this.memoryPool.allocate(entrySize);
-                if (retryOffset === 0) {
-                    throw new Error('Cannot allocate memory after eviction');
-                }
-                return this.createNewEntry(retryOffset, namespaceId, keyHash, namespacedHash, key, serializedValue, startTime);
-            }
-            return this.createNewEntry(entryOffset, namespaceId, keyHash, namespacedHash, key, serializedValue, startTime);
-        } catch (error) {
-            this.incrementCounter('errors');
-            throw error;
-        }
-    }
-    /**
+   */
+  async set(namespace, key, value) {
+    const startTime = this.config.ENABLE_METRICS ? performance.now() * 1000000 : 0;
+
+    try {
+      // Input validation
+      if (key.length > this.config.MAX_KEY_SIZE) {
+        throw new Error(`Key too large: ${key.length} > ${this.config.MAX_KEY_SIZE}`);
+      }
+
+      const serializedValue = FastSerializer.serialize(value);
+      if (serializedValue.length > this.config.MAX_VALUE_SIZE) {
+        throw new Error(`Value too large: ${serializedValue.length} > ${this.config.MAX_VALUE_SIZE}`);
+      }
+
+      // Resolve namespace
+      const namespaceId = this.namespaceManager.resolveNamespace(namespace);
+
+      // Calculate hash
+      const keyHash = HighPerformanceHash.xxhash32(key);
+      const namespacedHash = HighPerformanceHash.mixHash(namespaceId ^ keyHash);
+
+      // Check for existing entry
+      const existingOffset = this.hashTable.lookup(namespacedHash, (entry) => {
+        return this.compareKey(entry, namespaceId, key);
+      });
+
+      if (existingOffset !== 0) {
+        // Update existing entry
+        const success = this.updateEntry(existingOffset, serializedValue);
+        if (success) {
+          this.incrementCounter('writeOperations');
+          this.recordWritePerformance(startTime);
+          return true;
+        }
+      }
+
+      // Create new entry
+      const entrySize = this.calculateEntrySize(key, serializedValue);
+      const entryOffset = this.memoryPool.allocate(entrySize);
+
+      if (entryOffset === 0) {
+        // Memory pressure - trigger eviction
+        const evicted = await this.memoryPressureManager.checkMemoryPressure();
+        if (!evicted) {
+          throw new Error('Cannot allocate memory: pool exhausted');
+        }
+
+        // Retry allocation after eviction
+        const retryOffset = this.memoryPool.allocate(entrySize);
+        if (retryOffset === 0) {
+          throw new Error('Cannot allocate memory after eviction');
+        }
+        return this.createNewEntry(retryOffset, namespaceId, keyHash, namespacedHash, key, serializedValue, startTime);
+      }
+
+      return this.createNewEntry(entryOffset, namespaceId, keyHash, namespacedHash, key, serializedValue, startTime);
+
+    } catch (error) {
+      this.incrementCounter('errors');
+      throw error;
+    }
+  }
+
+  /**
    * Create new entry in memory
-   */ createNewEntry(entryOffset, namespaceId, keyHash, namespacedHash, key, serializedValue, startTime) {
-        // Initialize entry structure
-        this.initializeEntry(entryOffset, namespaceId, keyHash, key, serializedValue);
-        // Insert into hash table
-        const inserted = this.hashTable.insert(namespacedHash, entryOffset);
-        if (!inserted) {
-            // Insertion failed - deallocate and throw
-            this.memoryPool.deallocate(entryOffset);
-            throw new Error('Failed to insert entry into hash table');
-        }
-        // Update statistics
-        this.incrementCounter('writeOperations');
-        AtomicOperations.atomicIncrement(this.sharedBuffer, 20); // Entry count
-        // Mark region as dirty for backup
-        if (this.persistence) {
-            this.persistence.markRegionDirty(entryOffset);
-        }
-        // Record performance
-        this.recordWritePerformance(startTime);
-        return true;
-    }
-    /**
+   */
+  createNewEntry(entryOffset, namespaceId, keyHash, namespacedHash, key, serializedValue, startTime) {
+    // Initialize entry structure
+    this.initializeEntry(entryOffset, namespaceId, keyHash, key, serializedValue);
+
+    // Insert into hash table
+    const inserted = this.hashTable.insert(namespacedHash, entryOffset);
+    if (!inserted) {
+      // Insertion failed - deallocate and throw
+      this.memoryPool.deallocate(entryOffset);
+      throw new Error('Failed to insert entry into hash table');
+    }
+
+    // Update statistics
+    this.incrementCounter('writeOperations');
+    AtomicOperations.atomicIncrement(this.sharedBuffer, 20); // Entry count
+
+    // Mark region as dirty for backup
+    if (this.persistence) {
+      this.persistence.markRegionDirty(entryOffset);
+    }
+
+    // Record performance
+    this.recordWritePerformance(startTime);
+
+    return true;
+  }
+
+  /**
    * Initialize entry structure in memory
-   */ initializeEntry(entryOffset, namespaceId, keyHash, key, serializedValue) {
-        const now = performance.now() * 1000000; // nanoseconds
-        // Entry header
-        AtomicOperations.storeRelease(this.sharedBuffer, entryOffset + ENTRY_LAYOUT.next, 0);
-        AtomicOperations.storeRelease(this.sharedBuffer, entryOffset + ENTRY_LAYOUT.keyHash, keyHash);
-        const entryView = new DataView(this.sharedBuffer, entryOffset, 64);
-        entryView.setUint16(ENTRY_LAYOUT.keyLength, key.length, true);
-        entryView.setUint16(ENTRY_LAYOUT.valueLength, serializedValue.length, true);
-        entryView.setUint32(ENTRY_LAYOUT.namespace, namespaceId, true);
-        entryView.setBigUint64(ENTRY_LAYOUT.timestamp, BigInt(now), true);
-        entryView.setUint32(ENTRY_LAYOUT.flags, 0, true);
-        // Key data
-        const keyBytes = new TextEncoder().encode(key);
-        const keyView = new Uint8Array(this.sharedBuffer, entryOffset + ENTRY_LAYOUT.keyData, keyBytes.length);
-        keyView.set(keyBytes);
-        // Value data (after key, aligned to 8 bytes)
-        const valueOffset = entryOffset + ENTRY_LAYOUT.keyData + this.alignTo8(key.length);
-        const valueView = new Uint8Array(this.sharedBuffer, valueOffset, serializedValue.length);
-        valueView.set(serializedValue);
-        // Calculate and store checksum
-        const checksum = this.calculateEntryChecksum(entryOffset);
-        entryView.setUint32(ENTRY_LAYOUT.checksum, checksum, true);
-    }
-    /**
+   */
+  initializeEntry(entryOffset, namespaceId, keyHash, key, serializedValue) {
+    const now = performance.now() * 1000000; // nanoseconds
+
+    // Entry header
+    AtomicOperations.storeRelease(this.sharedBuffer, entryOffset + ENTRY_LAYOUT.next, 0);
+    AtomicOperations.storeRelease(this.sharedBuffer, entryOffset + ENTRY_LAYOUT.keyHash, keyHash);
+
+    const entryView = new DataView(this.sharedBuffer, entryOffset, 64);
+    entryView.setUint16(ENTRY_LAYOUT.keyLength, key.length, true);
+    entryView.setUint16(ENTRY_LAYOUT.valueLength, serializedValue.length, true);
+    entryView.setUint32(ENTRY_LAYOUT.namespace, namespaceId, true);
+    entryView.setBigUint64(ENTRY_LAYOUT.timestamp, BigInt(now), true);
+    entryView.setUint32(ENTRY_LAYOUT.flags, 0, true);
+
+    // Key data
+    const keyBytes = new TextEncoder().encode(key);
+    const keyView = new Uint8Array(this.sharedBuffer, entryOffset + ENTRY_LAYOUT.keyData, keyBytes.length);
+    keyView.set(keyBytes);
+
+    // Value data (after key, aligned to 8 bytes)
+    const valueOffset = entryOffset + ENTRY_LAYOUT.keyData + this.alignTo8(key.length);
+    const valueView = new Uint8Array(this.sharedBuffer, valueOffset, serializedValue.length);
+    valueView.set(serializedValue);
+
+    // Calculate and store checksum
+    const checksum = this.calculateEntryChecksum(entryOffset);
+    entryView.setUint32(ENTRY_LAYOUT.checksum, checksum, true);
+  }
+
+  /**
    * Compare key for hash table lookup
-   */ compareKey(entryView, namespaceId, key) {
-        // Fast namespace check first
-        const entryNamespace = entryView.namespace();
-        if (entryNamespace !== namespaceId) {
-            return false;
-        }
-        // Key length check
-        const entryKeyLength = entryView.keyLength();
-        if (entryKeyLength !== key.length) {
-            return false;
-        }
-        // Key data comparison
-        const entryKeyOffset = entryView.offset + ENTRY_LAYOUT.keyData;
-        const entryKeyView = new Uint8Array(this.sharedBuffer, entryKeyOffset, entryKeyLength);
-        const keyBytes = new TextEncoder().encode(key);
-        // Optimized byte-by-byte comparison
-        for(let i = 0; i < entryKeyLength; i++){
-            if (entryKeyView[i] !== keyBytes[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
+   */
+  compareKey(entryView, namespaceId, key) {
+    // Fast namespace check first
+    const entryNamespace = entryView.namespace();
+    if (entryNamespace !== namespaceId) {
+      return false;
+    }
+
+    // Key length check
+    const entryKeyLength = entryView.keyLength();
+    if (entryKeyLength !== key.length) {
+      return false;
+    }
+
+    // Key data comparison
+    const entryKeyOffset = entryView.offset + ENTRY_LAYOUT.keyData;
+    const entryKeyView = new Uint8Array(this.sharedBuffer, entryKeyOffset, entryKeyLength);
+    const keyBytes = new TextEncoder().encode(key);
+
+    // Optimized byte-by-byte comparison
+    for (let i = 0; i < entryKeyLength; i++) {
+      if (entryKeyView[i] !== keyBytes[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
    * Extract value from entry
-   */ extractValue(entryOffset) {
-        const entryView = new DataView(this.sharedBuffer, entryOffset, 64);
-        const keyLength = entryView.getUint16(ENTRY_LAYOUT.keyLength, true);
-        const valueLength = entryView.getUint16(ENTRY_LAYOUT.valueLength, true);
-        const valueOffset = entryOffset + ENTRY_LAYOUT.keyData + this.alignTo8(keyLength);
-        const valueBytes = new Uint8Array(this.sharedBuffer, valueOffset, valueLength);
-        return FastSerializer.deserialize(valueBytes);
-    }
-    /**
+   */
+  extractValue(entryOffset) {
+    const entryView = new DataView(this.sharedBuffer, entryOffset, 64);
+
+    const keyLength = entryView.getUint16(ENTRY_LAYOUT.keyLength, true);
+    const valueLength = entryView.getUint16(ENTRY_LAYOUT.valueLength, true);
+
+    const valueOffset = entryOffset + ENTRY_LAYOUT.keyData + this.alignTo8(keyLength);
+    const valueBytes = new Uint8Array(this.sharedBuffer, valueOffset, valueLength);
+
+    return FastSerializer.deserialize(valueBytes);
+  }
+
+  /**
    * Update entry access metadata
-   */ updateEntryAccess(entryOffset) {
-        const now = performance.now() * 1000000;
-        // Update timestamp atomically
-        const timestampOffset = entryOffset + ENTRY_LAYOUT.timestamp;
-        AtomicOperations.storeRelease(this.sharedBuffer, timestampOffset, now);
-        // Update memory pressure manager
-        this.memoryPressureManager.updateEntryAccess({
-            offset: entryOffset
-        });
-    }
-    /**
+   */
+  updateEntryAccess(entryOffset) {
+    const now = performance.now() * 1000000;
+
+    // Update timestamp atomically
+    const timestampOffset = entryOffset + ENTRY_LAYOUT.timestamp;
+    AtomicOperations.storeRelease(this.sharedBuffer, timestampOffset, now);
+
+    // Update memory pressure manager
+    this.memoryPressureManager.updateEntryAccess({ offset: entryOffset });
+  }
+
+  /**
    * Delete operation with lazy deletion
-   */ delete(namespace, key) {
-        const namespaceId = this.namespaceManager.resolveNamespace(namespace);
-        const keyHash = HighPerformanceHash.xxhash32(key);
-        const namespacedHash = HighPerformanceHash.mixHash(namespaceId ^ keyHash);
-        const entryOffset = this.hashTable.lookup(namespacedHash, (entry)=>{
-            return this.compareKey(entry, namespaceId, key);
-        });
-        if (entryOffset === 0) {
-            return false; // Key not found
-        }
-        // Mark entry as deleted (lazy deletion)
-        const flagsOffset = entryOffset + ENTRY_LAYOUT.flags;
-        const currentFlags = AtomicOperations.loadAcquire(this.sharedBuffer, flagsOffset);
-        const deletedFlags = currentFlags | 0x80000000; // Set deleted bit
-        const success = AtomicOperations.compareAndSwap32(this.sharedBuffer, flagsOffset, currentFlags, deletedFlags);
-        if (success === currentFlags) {
-            // Decrement entry count
-            AtomicOperations.atomicDecrement(this.sharedBuffer, 20);
-            this.incrementCounter('deletions');
-            return true;
-        }
-        return false;
-    }
-    /**
+   */
+  delete(namespace, key) {
+    const namespaceId = this.namespaceManager.resolveNamespace(namespace);
+    const keyHash = HighPerformanceHash.xxhash32(key);
+    const namespacedHash = HighPerformanceHash.mixHash(namespaceId ^ keyHash);
+
+    const entryOffset = this.hashTable.lookup(namespacedHash, (entry) => {
+      return this.compareKey(entry, namespaceId, key);
+    });
+
+    if (entryOffset === 0) {
+      return false; // Key not found
+    }
+
+    // Mark entry as deleted (lazy deletion)
+    const flagsOffset = entryOffset + ENTRY_LAYOUT.flags;
+    const currentFlags = AtomicOperations.loadAcquire(this.sharedBuffer, flagsOffset);
+    const deletedFlags = currentFlags | 0x80000000; // Set deleted bit
+
+    const success = AtomicOperations.compareAndSwap32(
+      this.sharedBuffer, flagsOffset, currentFlags, deletedFlags
+    );
+
+    if (success === currentFlags) {
+      // Decrement entry count
+      AtomicOperations.atomicDecrement(this.sharedBuffer, 20);
+      this.incrementCounter('deletions');
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
    * Batch operations for better performance
-   */ async setBatch(namespace, entries) {
-        const results = new Array(entries.length);
-        // Process in parallel where possible
-        const promises = entries.map(async (entry, index)=>{
-            try {
-                results[index] = await this.set(namespace, entry.key, entry.value);
-            } catch (error) {
-                results[index] = {
-                    error: error.message
-                };
-            }
-        });
-        await Promise.all(promises);
-        return results;
-    }
-    getBatch(namespace, keys) {
-        const results = new Map();
-        for (const key of keys){
-            try {
-                const value = this.get(namespace, key);
-                results.set(key, value);
-            } catch (error) {
-                results.set(key, {
-                    error: error.message
-                });
-            }
-        }
-        return results;
-    }
-    /**
+   */
+  async setBatch(namespace, entries) {
+    const results = new Array(entries.length);
+
+    // Process in parallel where possible
+    const promises = entries.map(async (entry, index) => {
+      try {
+        results[index] = await this.set(namespace, entry.key, entry.value);
+      } catch (error) {
+        results[index] = { error: error.message };
+      }
+    });
+
+    await Promise.all(promises);
+    return results;
+  }
+
+  getBatch(namespace, keys) {
+    const results = new Map();
+
+    for (const key of keys) {
+      try {
+        const value = this.get(namespace, key);
+        results.set(key, value);
+      } catch (error) {
+        results.set(key, { error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
    * Namespace operations
-   */ async clearNamespace(namespace) {
-        const namespaceId = this.namespaceManager.resolveNamespace(namespace);
-        let cleared = 0;
-        // Iterate through all entries and mark namespace entries as deleted
-        for(let bucketIndex = 0; bucketIndex < this.config.BUCKET_COUNT; bucketIndex++){
-            const bucketOffset = MEMORY_LAYOUT.HASH_TABLE.offset + bucketIndex * 32;
-            let entryOffset = AtomicOperations.loadAcquire(this.sharedBuffer, bucketOffset);
-            while(entryOffset !== 0){
-                const entryView = new DataView(this.sharedBuffer, entryOffset, 64);
-                const entryNamespace = entryView.getUint32(ENTRY_LAYOUT.namespace, true);
-                if (entryNamespace === namespaceId) {
-                    // Mark as deleted
-                    const flagsOffset = entryOffset + ENTRY_LAYOUT.flags;
-                    const currentFlags = entryView.getUint32(ENTRY_LAYOUT.flags, true);
-                    entryView.setUint32(ENTRY_LAYOUT.flags, currentFlags | 0x80000000, true);
-                    cleared++;
-                }
-                entryOffset = AtomicOperations.loadAcquire(this.sharedBuffer, entryOffset);
-            }
-        }
-        return cleared;
-    }
-    /**
+   */
+  async clearNamespace(namespace) {
+    const namespaceId = this.namespaceManager.resolveNamespace(namespace);
+    let cleared = 0;
+
+    // Iterate through all entries and mark namespace entries as deleted
+    for (let bucketIndex = 0; bucketIndex < this.config.BUCKET_COUNT; bucketIndex++) {
+      const bucketOffset = MEMORY_LAYOUT.HASH_TABLE.offset + (bucketIndex * 32);
+      let entryOffset = AtomicOperations.loadAcquire(this.sharedBuffer, bucketOffset);
+
+      while (entryOffset !== 0) {
+        const entryView = new DataView(this.sharedBuffer, entryOffset, 64);
+        const entryNamespace = entryView.getUint32(ENTRY_LAYOUT.namespace, true);
+
+        if (entryNamespace === namespaceId) {
+          // Mark as deleted
+          const flagsOffset = entryOffset + ENTRY_LAYOUT.flags;
+          const currentFlags = entryView.getUint32(ENTRY_LAYOUT.flags, true);
+          entryView.setUint32(ENTRY_LAYOUT.flags, currentFlags | 0x80000000, true);
+          cleared++;
+        }
+
+        entryOffset = AtomicOperations.loadAcquire(this.sharedBuffer, entryOffset);
+      }
+    }
+
+    return cleared;
+  }
+
+  /**
    * Iterator support for namespace
-   */ *iterateNamespace(namespace) {
-        const namespaceId = this.namespaceManager.resolveNamespace(namespace);
-        for(let bucketIndex = 0; bucketIndex < this.config.BUCKET_COUNT; bucketIndex++){
-            const bucketOffset = MEMORY_LAYOUT.HASH_TABLE.offset + bucketIndex * 32;
-            let entryOffset = AtomicOperations.loadAcquire(this.sharedBuffer, bucketOffset);
-            while(entryOffset !== 0){
-                const entryView = new DataView(this.sharedBuffer, entryOffset, 64);
-                const entryNamespace = entryView.getUint32(ENTRY_LAYOUT.namespace, true);
-                const flags = entryView.getUint32(ENTRY_LAYOUT.flags, true);
-                if (entryNamespace === namespaceId && !(flags & 0x80000000)) {
-                    // Extract key and value
-                    const keyLength = entryView.getUint16(ENTRY_LAYOUT.keyLength, true);
-                    const keyBytes = new Uint8Array(this.sharedBuffer, entryOffset + ENTRY_LAYOUT.keyData, keyLength);
-                    const key = new TextDecoder().decode(keyBytes);
-                    const value = this.extractValue(entryOffset);
-                    yield {
-                        key,
-                        value
-                    };
-                }
-                entryOffset = AtomicOperations.loadAcquire(this.sharedBuffer, entryOffset);
-            }
-        }
-    }
-    /**
+   */
+  *iterateNamespace(namespace) {
+    const namespaceId = this.namespaceManager.resolveNamespace(namespace);
+
+    for (let bucketIndex = 0; bucketIndex < this.config.BUCKET_COUNT; bucketIndex++) {
+      const bucketOffset = MEMORY_LAYOUT.HASH_TABLE.offset + (bucketIndex * 32);
+      let entryOffset = AtomicOperations.loadAcquire(this.sharedBuffer, bucketOffset);
+
+      while (entryOffset !== 0) {
+        const entryView = new DataView(this.sharedBuffer, entryOffset, 64);
+        const entryNamespace = entryView.getUint32(ENTRY_LAYOUT.namespace, true);
+        const flags = entryView.getUint32(ENTRY_LAYOUT.flags, true);
+
+        if (entryNamespace === namespaceId && !(flags & 0x80000000)) {
+          // Extract key and value
+          const keyLength = entryView.getUint16(ENTRY_LAYOUT.keyLength, true);
+          const keyBytes = new Uint8Array(this.sharedBuffer, entryOffset + ENTRY_LAYOUT.keyData, keyLength);
+          const key = new TextDecoder().decode(keyBytes);
+          const value = this.extractValue(entryOffset);
+
+          yield { key, value };
+        }
+
+        entryOffset = AtomicOperations.loadAcquire(this.sharedBuffer, entryOffset);
+      }
+    }
+  }
+
+  /**
    * Persistence operations
-   */ async enablePersistence(backupPath) {
-        this.persistence = new MemoryMappedPersistence(this.sharedBuffer, backupPath);
-        await this.persistence.initialize();
-        // Start background backup process
-        this.backupStrategy = new BackupStrategyManager(this.persistence);
-        console.log(`Persistence enabled: ${backupPath}`);
-        return this.persistence;
-    }
-    async backup(type = 'incremental') {
-        if (!this.persistence) {
-            throw new Error('Persistence not enabled');
-        }
-        if (type === 'full') {
-            return await this.persistence.fullBackup();
-        } else {
-            return await this.persistence.incrementalBackup();
-        }
-    }
-    async restore() {
-        if (!this.persistence) {
-            throw new Error('Persistence not enabled');
-        }
-        return await this.persistence.restoreFromBackup();
-    }
-    /**
+   */
+  async enablePersistence(backupPath) {
+    this.persistence = new MemoryMappedPersistence(this.sharedBuffer, backupPath);
+    await this.persistence.initialize();
+
+    // Start background backup process
+    this.backupStrategy = new BackupStrategyManager(this.persistence);
+
+    console.log(`Persistence enabled: ${backupPath}`);
+    return this.persistence;
+  }
+
+  async backup(type = 'incremental') {
+    if (!this.persistence) {
+      throw new Error('Persistence not enabled');
+    }
+
+    if (type === 'full') {
+      return await this.persistence.fullBackup();
+    } else {
+      return await this.persistence.incrementalBackup();
+    }
+  }
+
+  async restore() {
+    if (!this.persistence) {
+      throw new Error('Persistence not enabled');
+    }
+
+    return await this.persistence.restoreFromBackup();
+  }
+
+  /**
    * Performance and monitoring
-   */ incrementCounter(name) {
-        if (!this.config.ENABLE_METRICS) return;
-        const counterMap = {
-            'readOperations': 0,
-            'writeOperations': 4,
-            'cacheHits': 8,
-            'cacheMisses': 12,
-            'evictions': 16,
-            'deletions': 20,
-            'errors': 24
-        };
-        const offset = counterMap[name];
-        if (offset !== undefined) {
-            AtomicOperations.atomicIncrement(this.sharedBuffer, this.counterOffset + offset);
-        }
-    }
-    shouldSample() {
-        return Math.random() < this.config.SAMPLING_RATE;
-    }
-    recordPerformanceSample(operation, latency) {
-        const samples = this.sampler[`${operation}Samples`];
-        if (samples && samples.length < this.sampler.maxSamples) {
-            samples.push({
-                latency,
-                timestamp: performance.now()
-            });
-        }
-    }
-    recordWritePerformance(startTime) {
-        if (this.config.ENABLE_METRICS && this.shouldSample() && startTime > 0) {
-            const duration = performance.now() * 1000000 - startTime;
-            this.recordPerformanceSample('write', duration);
-        }
-    }
-    getPerformanceStats() {
-        if (!this.config.ENABLE_METRICS) {
-            return {
-                metricsDisabled: true
-            };
-        }
-        const counterView = new Uint32Array(this.sharedBuffer, this.counterOffset, MEMORY_LAYOUT.COUNTERS.size / 4);
-        const readOps = counterView[0];
-        const writeOps = counterView[1];
-        const cacheHits = counterView[2];
-        const cacheMisses = counterView[3];
-        return {
-            operations: {
-                reads: readOps,
-                writes: writeOps,
-                total: readOps + writeOps
-            },
-            cache: {
-                hits: cacheHits,
-                misses: cacheMisses,
-                hitRate: cacheHits / (cacheHits + cacheMisses) || 0
-            },
-            memory: this.getMemoryStats(),
-            performance: this.getLatencyStats()
-        };
-    }
-    getMemoryStats() {
-        const poolStats = this.memoryPool.getPoolStats();
-        const headerView = new DataView(this.sharedBuffer, 0, MEMORY_LAYOUT.HEADER.size);
-        const entryCount = headerView.getUint32(20, true);
-        return {
-            totalSize: this.bufferSize,
-            utilization: poolStats.allocatedBytes / poolStats.totalSize,
-            fragmentation: poolStats.fragmentationRatio,
-            entryCount,
-            avgEntrySize: entryCount > 0 ? poolStats.allocatedBytes / entryCount : 0
-        };
-    }
-    getLatencyStats() {
-        const calculatePercentiles = (samples)=>{
-            if (samples.length === 0) return {};
-            const latencies = samples.map((s)=>s.latency).sort((a, b)=>a - b);
-            return {
-                p50: latencies[Math.floor(latencies.length * 0.5)],
-                p95: latencies[Math.floor(latencies.length * 0.95)],
-                p99: latencies[Math.floor(latencies.length * 0.99)],
-                avg: latencies.reduce((a, b)=>a + b, 0) / latencies.length
-            };
-        };
-        return {
-            reads: calculatePercentiles(this.sampler.readSamples),
-            writes: calculatePercentiles(this.sampler.writeSamples)
-        };
-    }
-    /**
+   */
+  incrementCounter(name) {
+    if (!this.config.ENABLE_METRICS) return;
+
+    const counterMap = {
+      'readOperations': 0,
+      'writeOperations': 4,
+      'cacheHits': 8,
+      'cacheMisses': 12,
+      'evictions': 16,
+      'deletions': 20,
+      'errors': 24
+    };
+
+    const offset = counterMap[name];
+    if (offset !== undefined) {
+      AtomicOperations.atomicIncrement(this.sharedBuffer, this.counterOffset + offset);
+    }
+  }
+
+  shouldSample() {
+    return Math.random() < this.config.SAMPLING_RATE;
+  }
+
+  recordPerformanceSample(operation, latency) {
+    const samples = this.sampler[`${operation}Samples`];
+    if (samples && samples.length < this.sampler.maxSamples) {
+      samples.push({
+        latency,
+        timestamp: performance.now()
+      });
+    }
+  }
+
+  recordWritePerformance(startTime) {
+    if (this.config.ENABLE_METRICS && this.shouldSample() && startTime > 0) {
+      const duration = performance.now() * 1000000 - startTime;
+      this.recordPerformanceSample('write', duration);
+    }
+  }
+
+  getPerformanceStats() {
+    if (!this.config.ENABLE_METRICS) {
+      return { metricsDisabled: true };
+    }
+
+    const counterView = new Uint32Array(
+      this.sharedBuffer,
+      this.counterOffset,
+      MEMORY_LAYOUT.COUNTERS.size / 4
+    );
+
+    const readOps = counterView[0];
+    const writeOps = counterView[1];
+    const cacheHits = counterView[2];
+    const cacheMisses = counterView[3];
+
+    return {
+      operations: {
+        reads: readOps,
+        writes: writeOps,
+        total: readOps + writeOps
+      },
+      cache: {
+        hits: cacheHits,
+        misses: cacheMisses,
+        hitRate: cacheHits / (cacheHits + cacheMisses) || 0
+      },
+      memory: this.getMemoryStats(),
+      performance: this.getLatencyStats()
+    };
+  }
+
+  getMemoryStats() {
+    const poolStats = this.memoryPool.getPoolStats();
+    const headerView = new DataView(this.sharedBuffer, 0, MEMORY_LAYOUT.HEADER.size);
+    const entryCount = headerView.getUint32(20, true);
+
+    return {
+      totalSize: this.bufferSize,
+      utilization: poolStats.allocatedBytes / poolStats.totalSize,
+      fragmentation: poolStats.fragmentationRatio,
+      entryCount,
+      avgEntrySize: entryCount > 0 ? poolStats.allocatedBytes / entryCount : 0
+    };
+  }
+
+  getLatencyStats() {
+    const calculatePercentiles = (samples) => {
+      if (samples.length === 0) return {};
+
+      const latencies = samples.map(s => s.latency).sort((a, b) => a - b);
+      return {
+        p50: latencies[Math.floor(latencies.length * 0.5)],
+        p95: latencies[Math.floor(latencies.length * 0.95)],
+        p99: latencies[Math.floor(latencies.length * 0.99)],
+        avg: latencies.reduce((a, b) => a + b, 0) / latencies.length
+      };
+    };
+
+    return {
+      reads: calculatePercentiles(this.sampler.readSamples),
+      writes: calculatePercentiles(this.sampler.writeSamples)
+    };
+  }
+
+  /**
    * Health checks and diagnostics
-   */ healthCheck() {
-        const issues = [];
-        const warnings = [];
-        // Check performance targets
-        const stats = this.getPerformanceStats();
-        if (stats.performance.reads.p95 > 100000) {
-            issues.push('Read latency P95 exceeds target (100ns)');
-        }
-        if (stats.performance.writes.p95 > 500000) {
-            issues.push('Write latency P95 exceeds target (500ns)');
-        }
-        // Check memory utilization
-        if (stats.memory.utilization > 0.9) {
-            issues.push('Memory utilization above 90%');
-        } else if (stats.memory.utilization > 0.8) {
-            warnings.push('Memory utilization above 80%');
-        }
-        // Check cache hit rate
-        if (stats.cache.hitRate < 0.8) {
-            issues.push(`Cache hit rate below 80%: ${(stats.cache.hitRate * 100).toFixed(1)}%`);
-        } else if (stats.cache.hitRate < 0.9) {
-            warnings.push(`Cache hit rate below 90%: ${(stats.cache.hitRate * 100).toFixed(1)}%`);
-        }
-        return {
-            healthy: issues.length === 0,
-            issues,
-            warnings,
-            uptime: performance.now() - this.startTime,
-            stats
-        };
-    }
-    /**
+   */
+  healthCheck() {
+    const issues = [];
+    const warnings = [];
+
+    // Check performance targets
+    const stats = this.getPerformanceStats();
+    if (stats.performance.reads.p95 > 100000) { // >100ns
+      issues.push('Read latency P95 exceeds target (100ns)');
+    }
+    if (stats.performance.writes.p95 > 500000) { // >500ns
+      issues.push('Write latency P95 exceeds target (500ns)');
+    }
+
+    // Check memory utilization
+    if (stats.memory.utilization > 0.9) {
+      issues.push('Memory utilization above 90%');
+    } else if (stats.memory.utilization > 0.8) {
+      warnings.push('Memory utilization above 80%');
+    }
+
+    // Check cache hit rate
+    if (stats.cache.hitRate < 0.8) {
+      issues.push(`Cache hit rate below 80%: ${(stats.cache.hitRate * 100).toFixed(1)}%`);
+    } else if (stats.cache.hitRate < 0.9) {
+      warnings.push(`Cache hit rate below 90%: ${(stats.cache.hitRate * 100).toFixed(1)}%`);
+    }
+
+    return {
+      healthy: issues.length === 0,
+      issues,
+      warnings,
+      uptime: performance.now() - this.startTime,
+      stats
+    };
+  }
+
+  /**
    * Graceful shutdown
-   */ async shutdown() {
-        console.log('Shutting down UltraFastMemoryStore...');
-        // Stop memory pressure management
-        this.memoryPressureManager.stopBackgroundOperations();
-        // Final backup if persistence enabled
-        if (this.persistence) {
-            await this.persistence.shutdown();
-        }
-        console.log('UltraFastMemoryStore shutdown complete');
-    }
-    /**
+   */
+  async shutdown() {
+    console.log('Shutting down UltraFastMemoryStore...');
+
+    // Stop memory pressure management
+    this.memoryPressureManager.stopBackgroundOperations();
+
+    // Final backup if persistence enabled
+    if (this.persistence) {
+      await this.persistence.shutdown();
+    }
+
+    console.log('UltraFastMemoryStore shutdown complete');
+  }
+
+  /**
    * Utility methods
-   */ calculateEntrySize(key, serializedValue) {
-        const keySize = new TextEncoder().encode(key).length;
-        return 64 + this.alignTo8(keySize) + serializedValue.length; // Header + key + value
-    }
-    alignTo8(size) {
-        return Math.ceil(size / 8) * 8;
-    }
-    calculateEntryChecksum(entryOffset) {
-        // Simple XOR checksum for demonstration - use CRC32 in production
-        const entryView = new DataView(this.sharedBuffer, entryOffset, 28); // Exclude checksum field
-        let checksum = 0;
-        for(let i = 0; i < 28; i += 4){
-            checksum ^= entryView.getUint32(i, true);
-        }
-        return checksum;
-    }
-    constructor(config = ULTRA_FAST_CONFIG){
-        this.config = {
-            ...ULTRA_FAST_CONFIG,
-            ...config
-        };
-        // Initialize SharedArrayBuffer
-        this.sharedBuffer = new SharedArrayBuffer(this.config.DEFAULT_SIZE);
-        this.bufferSize = this.config.DEFAULT_SIZE;
-        // Calculate memory layout offsets
-        this.calculateMemoryLayout();
-        // Initialize core components
-        this.initializeComponents();
-        // Performance monitoring
-        this.performanceCounters = new Map();
-        this.operationSampler = new Map();
-        // State tracking
-        this.isInitialized = false;
-        this.startTime = performance.now();
-        console.log(`UltraFastMemoryStore initialized: ${this.bufferSize} bytes`);
-    }
-}
+   */
+  calculateEntrySize(key, serializedValue) {
+    const keySize = new TextEncoder().encode(key).length;
+    return 64 + this.alignTo8(keySize) + serializedValue.length; // Header + key + value
+  }
+
+  alignTo8(size) {
+    return Math.ceil(size / 8) * 8;
+  }
+
+  calculateEntryChecksum(entryOffset) {
+    // Simple XOR checksum for demonstration - use CRC32 in production
+    const entryView = new DataView(this.sharedBuffer, entryOffset, 28); // Exclude checksum field
+    let checksum = 0;
+
+    for (let i = 0; i < 28; i += 4) {
+      checksum ^= entryView.getUint32(i, true);
+    }
+
+    return checksum;
+  }
+}
+
 /**
  * Namespace manager for the memory store
- */ let NamespaceManager = class NamespaceManager {
-    resolveNamespace(namespaceName) {
-        // Check cache first
-        let namespaceId = this.namespaceCache.get(namespaceName);
-        if (namespaceId !== undefined) {
-            return namespaceId;
-        }
-        // Generate namespace ID from hash for consistency
-        namespaceId = HighPerformanceHash.fnv1a32(namespaceName) & 0x7FFFFFFF; // Ensure positive
-        this.namespaceCache.set(namespaceName, namespaceId);
-        return namespaceId;
-    }
-    constructor(sharedBuffer){
-        this.sharedBuffer = sharedBuffer;
-        this.namespaceCache = new Map(); // Local cache for performance
-        this.nextNamespaceId = 1;
-    }
-};
-// Export the main class and configuration
-export { ULTRA_FAST_CONFIG, MEMORY_LAYOUT, ENTRY_LAYOUT };
+ */
+class NamespaceManager {
+  constructor(sharedBuffer) {
+    this.sharedBuffer = sharedBuffer;
+    this.namespaceCache = new Map(); // Local cache for performance
+    this.nextNamespaceId = 1;
+  }
+
+  resolveNamespace(namespaceName) {
+    // Check cache first
+    let namespaceId = this.namespaceCache.get(namespaceName);
+    if (namespaceId !== undefined) {
+      return namespaceId;
+    }
+
+    // Generate namespace ID from hash for consistency
+    namespaceId = HighPerformanceHash.fnv1a32(namespaceName) & 0x7FFFFFFF; // Ensure positive
+    this.namespaceCache.set(namespaceName, namespaceId);
+
+    return namespaceId;
+  }
+}
+
+// Export the main class and configuration
+export { ULTRA_FAST_CONFIG, MEMORY_LAYOUT, ENTRY_LAYOUT };