claude-flow-novice 2.0.3 → 2.0.4

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

@@ -9,854 +9,655 @@
  * - Write operations: <500 nanoseconds (P95)
  * - Concurrent throughput: >10M operations/second
  * - Memory efficiency: >90% utilization
- */
-
-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';
-
+ */ 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";
 /**
  * Memory store configuration optimized for performance
- */
-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
-};
-
+ */ 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
+};
 /**
  * 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, // Calculated
-    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,
+        size: 1024
+    }
+};
 /**
  * Entry layout in memory (cache-aligned)
- */
-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)
-};
-
+ */ 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)
+};
 /**
  * Ultra-fast memory store implementation
- */
-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`);
-  }
-
-  /**
+ */ export class UltraFastMemoryStore {
+    /**
    * 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) { // >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
-    };
-  }
-
-  /**
+   */ 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
+        };
+    }
+    /**
    * 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;
-  }
-}
-
+   */ 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`);
+    }
+}
 /**
  * Namespace manager for the memory store
- */
-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 };
+ */ 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 };