sol-trade-sdk 0.1.0

package/dist/perf/index.js

@@ -0,0 +1,3742 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/perf/index.ts
+var perf_exports = {};
+__export(perf_exports, {
+  AlignedBuffer: () => AlignedBuffer,
+  AsyncSocket: () => AsyncSocket,
+  BranchOptimizer: () => BranchOptimizer,
+  BufferPool: () => BufferPool,
+  CACHE_LINE_SIZE: () => CACHE_LINE_SIZE,
+  CPUAffinity: () => CPUAffinity,
+  CacheOptimizer: () => CacheOptimizer,
+  ComputeBudgetOptimizer: () => ComputeBudgetOptimizer,
+  CryptoSIMD: () => CryptoSIMD,
+  DirectIOFile: () => DirectIOFile,
+  FastTimeProvider: () => FastTimeProvider,
+  FixedBufferView: () => FixedBufferView,
+  Float32x4: () => Float32x4,
+  FuncCache: () => FuncCache,
+  HardwareMonitor: () => HardwareMonitor,
+  IOBatchProcessor: () => IOBatchProcessor,
+  IOOperation: () => IOOperation,
+  InstructionBatcher: () => InstructionBatcher,
+  KernelBypassManager: () => KernelBypassManager,
+  LatencyMonitor: () => LatencyMonitor,
+  LatencyOptimizer: () => LatencyOptimizer,
+  LockFreeQueue: () => LockFreeQueue,
+  LoopOptimizer: () => LoopOptimizer,
+  MPMCQueue: () => MPMCQueue,
+  MemoryMappedFile: () => MemoryMappedFile,
+  MemoryOps: () => MemoryOps,
+  MemoryPool: () => MemoryPool,
+  NUMAOptimizer: () => NUMAOptimizer,
+  OptimizedMath: () => OptimizedMath,
+  PerformanceGovernor: () => PerformanceGovernor,
+  ProfileGuidedOptimizer: () => ProfileGuidedOptimizer,
+  RealtimeTuner: () => RealtimeTuner,
+  SIMDDetector: () => SIMDDetector,
+  SchedulerPolicy: () => SchedulerPolicy,
+  SpinLock: () => SpinLock,
+  SyscallBypassManager: () => SyscallBypassManager,
+  ThreadPriority: () => ThreadPriority,
+  ThreadPriorityLevel: () => ThreadPriorityLevel,
+  TransactionBuilder: () => TransactionBuilder,
+  TransactionOptimizer: () => TransactionOptimizer,
+  VectorizedMath: () => VectorizedMath,
+  ZeroCopyBuffer: () => ZeroCopyBuffer,
+  ZeroCopySerializer: () => ZeroCopySerializer,
+  busySpin: () => busySpin,
+  busyWait: () => busyWait,
+  calculateOptimalPrice: () => calculateOptimalPrice,
+  coldPath: () => coldPath,
+  copyBytes: () => copyBytes,
+  createBufferPool: () => createBufferPool,
+  createCPUAffinity: () => createCPUAffinity,
+  createCacheOptimizer: () => createCacheOptimizer,
+  createComputeBudgetOptimizer: () => createComputeBudgetOptimizer,
+  createCryptoSIMD: () => createCryptoSIMD,
+  createHardwareMonitor: () => createHardwareMonitor,
+  createInstructionBatcher: () => createInstructionBatcher,
+  createLatencyMonitor: () => createLatencyMonitor,
+  createLockFreeQueue: () => createLockFreeQueue,
+  createMPMCQueue: () => createMPMCQueue,
+  createMemoryPool: () => createMemoryPool,
+  createNUMAOptimizer: () => createNUMAOptimizer,
+  createPerformanceGovernor: () => createPerformanceGovernor,
+  createRealtimeTuner: () => createRealtimeTuner,
+  createSIMDDetector: () => createSIMDDetector,
+  createSerializer: () => createSerializer,
+  createSyscallBypassManager: () => createSyscallBypassManager,
+  createThreadPriority: () => createThreadPriority,
+  createTimer: () => createTimer,
+  createTransactionBuilder: () => createTransactionBuilder,
+  createTransactionOptimizer: () => createTransactionOptimizer,
+  createVectorizedMath: () => createVectorizedMath,
+  createView: () => createView,
+  createZeroCopyBuffer: () => createZeroCopyBuffer,
+  defaultAffinityConfig: () => defaultAffinityConfig,
+  defaultBufferPoolConfig: () => defaultBufferPoolConfig,
+  defaultIOUringConfig: () => defaultIOUringConfig,
+  defaultJITConfig: () => defaultJITConfig,
+  defaultNUMAConfig: () => defaultNUMAConfig,
+  defaultRealtimeConfig: () => defaultRealtimeConfig,
+  defaultSIMDConfig: () => defaultSIMDConfig,
+  defaultSyscallBypassConfig: () => defaultSyscallBypassConfig,
+  defaultTransactionConfig: () => defaultTransactionConfig,
+  defaultUltraLowLatencyConfig: () => defaultUltraLowLatencyConfig,
+  detectCPUFeatures: () => detectCPUFeatures,
+  estimateCompute: () => estimateCompute,
+  fastInvSqrt: () => fastInvSqrt,
+  fastNowMs: () => fastNowMs,
+  fastNowNs: () => fastNowNs,
+  fastNowUs: () => fastNowUs,
+  getGlobalTimeProvider: () => getGlobalTimeProvider,
+  getKernelBypassManager: () => getKernelBypassManager,
+  getOptimalSIMDWidth: () => getOptimalSIMDWidth,
+  getProfileOptimizer: () => getProfileOptimizer,
+  getSystemCPUInfo: () => getSystemCPUInfo,
+  getSystemMemoryInfo: () => getSystemMemoryInfo,
+  hotPath: () => hotPath,
+  isSIMDAvailable: () => isSIMDAvailable,
+  likely: () => likely,
+  measureTime: () => measureTime,
+  prefetch: () => prefetch,
+  prefetchArray: () => prefetchArray,
+  prefetchHint: () => prefetchHint,
+  profile: () => profile,
+  spinLock: () => spinLock,
+  unlikely: () => unlikely,
+  yieldToEventLoop: () => yieldToEventLoop
+});
+module.exports = __toCommonJS(perf_exports);
+
+// src/perf/compiler-optimization.ts
+function defaultJITConfig() {
+  return {
+    enabled: true,
+    cacheSize: 128,
+    optimizationLevel: "O3",
+    inlineThreshold: 1e3,
+    loopVectorize: true,
+    slpVectorize: true
+  };
+}
+var BranchOptimizer = class {
+  /**
+   * Hint that the condition is likely true
+   * Use this to guide branch prediction in hot paths
+   */
+  static likely(condition) {
+    return condition;
+  }
+  /**
+   * Hint that the condition is likely false
+   * Use this to guide branch prediction in error handling paths
+   */
+  static unlikely(condition) {
+    return condition;
+  }
+};
+function likely(condition) {
+  return condition;
+}
+function unlikely(condition) {
+  return condition;
+}
+var LoopOptimizer = class {
+  /**
+   * Hint that a loop should be unrolled
+   */
+  static unrollHint(factor) {
+    return factor;
+  }
+  /**
+   * Hint that a loop should be vectorized
+   */
+  static vectorizeHint() {
+  }
+  /**
+   * Hint that a loop should be parallelized
+   */
+  static parallelHint() {
+  }
+};
+var CACHE_LINE_SIZE = 64;
+var AlignedBuffer = class {
+  data;
+  offset;
+  constructor(size, align = CACHE_LINE_SIZE) {
+    const padded = size + align;
+    this.data = Buffer.alloc(padded);
+    this.offset = 0;
+  }
+  /**
+   * Get the aligned buffer
+   */
+  get buffer() {
+    return this.data.slice(this.offset);
+  }
+  /**
+   * Get the underlying buffer
+   */
+  get underlying() {
+    return this.data;
+  }
+};
+function prefetchHint(address) {
+}
+var ProfileGuidedOptimizer = class {
+  profileData = /* @__PURE__ */ new Map();
+  callCounts = /* @__PURE__ */ new Map();
+  /**
+   * Instrument a function for profiling
+   */
+  instrument(name, fn) {
+    const self = this;
+    return (function(...args) {
+      const count = (self.callCounts.get(name) || 0) + 1;
+      self.callCounts.set(name, count);
+      const start = performance.now();
+      const result = fn.apply(this, args);
+      const elapsed = performance.now() - start;
+      let profile2 = self.profileData.get(name);
+      if (!profile2) {
+        profile2 = {
+          calls: 0,
+          totalTime: 0,
+          minTime: Infinity,
+          maxTime: 0
+        };
+        self.profileData.set(name, profile2);
+      }
+      profile2.calls = count;
+      profile2.totalTime += elapsed;
+      if (elapsed < profile2.minTime) {
+        profile2.minTime = elapsed;
+      }
+      if (elapsed > profile2.maxTime) {
+        profile2.maxTime = elapsed;
+      }
+      return result;
+    });
+  }
+  /**
+   * Get the most frequently called functions
+   */
+  getHotFunctions(topN = 10) {
+    const results = [];
+    this.callCounts.forEach((count, name) => {
+      results.push({ name, count });
+    });
+    results.sort((a, b) => b.count - a.count);
+    return results.slice(0, topN);
+  }
+  /**
+   * Get functions with highest average execution time
+   */
+  getSlowFunctions(topN = 10) {
+    const results = [];
+    this.profileData.forEach((profile2, name) => {
+      if (profile2.calls > 0) {
+        results.push({
+          name,
+          avgTime: profile2.totalTime / profile2.calls
+        });
+      }
+    });
+    results.sort((a, b) => b.avgTime - a.avgTime);
+    return results.slice(0, topN);
+  }
+};
+var OptimizedMath = class {
+  /**
+   * Fast exponential approximation
+   */
+  static fastExp(x) {
+    if (x < -708) return 0;
+    if (x > 709) return Infinity;
+    return Math.exp(x);
+  }
+  /**
+   * Fast logarithm
+   */
+  static fastLog(x) {
+    return Math.log(x);
+  }
+  /**
+   * Fast square root
+   */
+  static fastSqrt(x) {
+    return Math.sqrt(x);
+  }
+  /**
+   * Fast inverse square root (Quake III algorithm)
+   */
+  static fastInvSqrt(x) {
+    if (x <= 0) return Infinity;
+    const threehalfs = 1.5;
+    const x2 = x * 0.5;
+    let y = x;
+    const buf = new ArrayBuffer(4);
+    const f32 = new Float32Array(buf);
+    const u32 = new Uint32Array(buf);
+    f32[0] = y;
+    u32[0] = 1597463007 - (u32[0] >> 1);
+    y = f32[0];
+    y = y * (threehalfs - x2 * y * y);
+    return y;
+  }
+  /**
+   * Fast power
+   */
+  static fastPow(base, exp) {
+    return Math.pow(base, exp);
+  }
+  /**
+   * Fast absolute value for integers
+   */
+  static fastAbs(x) {
+    return x < 0 ? -x : x;
+  }
+};
+function fastInvSqrt(x) {
+  return OptimizedMath.fastInvSqrt(x);
+}
+var FuncCache = class {
+  cache = /* @__PURE__ */ new Map();
+  hits = 0;
+  misses = 0;
+  maxSize;
+  constructor(maxSize = 128) {
+    this.maxSize = maxSize;
+  }
+  /**
+   * Get a cached value
+   */
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.hits++;
+      return value;
+    }
+    this.misses++;
+    return void 0;
+  }
+  /**
+   * Set a cached value
+   */
+  set(key, value) {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  /**
+   * Get cache statistics
+   */
+  stats() {
+    const total = this.hits + this.misses;
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0
+    };
+  }
+  /**
+   * Clear the cache
+   */
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+};
+var SpinLock = class {
+  locked = false;
+  /**
+   * Acquire the lock
+   */
+  async lock() {
+    while (this.locked) {
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+    this.locked = true;
+  }
+  /**
+   * Release the lock
+   */
+  unlock() {
+    this.locked = false;
+  }
+  /**
+   * Try to acquire the lock without blocking
+   */
+  tryLock() {
+    if (this.locked) {
+      return false;
+    }
+    this.locked = true;
+    return true;
+  }
+};
+function hotPath() {
+}
+function coldPath() {
+}
+var MemoryOps = class {
+  /**
+   * Copy memory with potential SIMD optimization
+   */
+  static memCopy(dst, src) {
+    const n = Math.min(dst.length, src.length);
+    dst.set(src.slice(0, n));
+    return n;
+  }
+  /**
+   * Set memory with potential SIMD optimization
+   */
+  static memSet(dst, value) {
+    dst.fill(value);
+  }
+  /**
+   * Zero memory
+   */
+  static memZero(dst) {
+    dst.fill(0);
+  }
+};
+function detectCPUFeatures() {
+  return {
+    hasSIMD: true,
+    // V8 has SIMD optimizations
+    hasAVX: false,
+    // Not detectable in JS
+    hasAVX2: false,
+    hasSSE: false,
+    hasSSE2: false,
+    hasSSE3: false,
+    hasSSE41: false,
+    hasSSE42: false,
+    hasFMA: false,
+    hasBMI: false,
+    hasBMI2: false,
+    hasPopcnt: false,
+    cacheLine: CACHE_LINE_SIZE,
+    numCPU: require("os").cpus().length
+  };
+}
+var globalProfileOptimizer = null;
+function getProfileOptimizer() {
+  if (!globalProfileOptimizer) {
+    globalProfileOptimizer = new ProfileGuidedOptimizer();
+  }
+  return globalProfileOptimizer;
+}
+function profile(target, propertyKey, descriptor) {
+  const original = descriptor.value;
+  const optimizer = getProfileOptimizer();
+  const name = `${target.constructor.name}.${propertyKey}`;
+  descriptor.value = optimizer.instrument(name, original);
+  return descriptor;
+}
+
+// src/perf/hardware.ts
+function defaultAffinityConfig() {
+  return {
+    enablePinning: false,
+    preferredCores: [],
+    avoidSMT: true,
+    numaNode: 0
+  };
+}
+function defaultNUMAConfig() {
+  return {
+    enableNUMA: false,
+    preferredNode: 0,
+    interleave: false
+  };
+}
+var CPUAffinity = class {
+  config;
+  pinnedCores = /* @__PURE__ */ new Set();
+  constructor(config = defaultAffinityConfig()) {
+    this.config = config;
+  }
+  /**
+   * Get CPU topology information
+   */
+  getTopology() {
+    const os = require("os");
+    const cpus = os.cpus();
+    const logicalCores = cpus.length;
+    const physicalCores = Math.ceil(logicalCores / 2);
+    return {
+      physicalCores,
+      logicalCores,
+      numaNodes: 1,
+      // Node.js doesn't expose NUMA info
+      cacheLevels: [
+        { level: 1, size: 32 * 1024, lineSize: 64, associativity: 8 },
+        { level: 2, size: 256 * 1024, lineSize: 64, associativity: 8 },
+        { level: 3, size: 8 * 1024 * 1024, lineSize: 64, associativity: 16 }
+      ]
+    };
+  }
+  /**
+   * Pin current execution context to a specific core
+   * Note: In Node.js, this is advisory only via worker threads
+   */
+  pinToCore(coreId) {
+    if (!this.config.enablePinning) {
+      return false;
+    }
+    this.pinnedCores.add(coreId);
+    return true;
+  }
+  /**
+   * Pin to multiple cores
+   */
+  pinToCores(coreIds) {
+    if (!this.config.enablePinning) {
+      return false;
+    }
+    for (const coreId of coreIds) {
+      this.pinnedCores.add(coreId);
+    }
+    return true;
+  }
+  /**
+   * Get recommended cores for pinning
+   */
+  getRecommendedCores(count = 1) {
+    const topology = this.getTopology();
+    const cores = [];
+    if (this.config.preferredCores.length > 0) {
+      for (let i = 0; i < count && i < this.config.preferredCores.length; i++) {
+        cores.push(this.config.preferredCores[i]);
+      }
+    } else {
+      const step = this.config.avoidSMT ? 2 : 1;
+      for (let i = 0; i < count * step && i < topology.physicalCores; i += step) {
+        cores.push(i);
+      }
+    }
+    return cores;
+  }
+  /**
+   * Check if a core is available
+   */
+  isCoreAvailable(coreId) {
+    const topology = this.getTopology();
+    return coreId >= 0 && coreId < topology.logicalCores;
+  }
+  /**
+   * Get current core (simulated)
+   */
+  getCurrentCore() {
+    return 0;
+  }
+  /**
+   * Get pinned cores
+   */
+  getPinnedCores() {
+    return Array.from(this.pinnedCores);
+  }
+  /**
+   * Unpin all cores
+   */
+  unpinAll() {
+    this.pinnedCores.clear();
+  }
+};
+var NUMAOptimizer = class {
+  config;
+  allocations = /* @__PURE__ */ new Map();
+  constructor(config = defaultNUMAConfig()) {
+    this.config = config;
+  }
+  /**
+   * Allocate memory with NUMA awareness
+   */
+  allocate(size, tag = "default") {
+    const buffer = new ArrayBuffer(size);
+    this.allocations.set(tag, {
+      buffer,
+      size,
+      node: this.config.preferredNode,
+      timestamp: Date.now()
+    });
+    return buffer;
+  }
+  /**
+   * Allocate typed array with NUMA awareness
+   */
+  allocateTypedArray(constructor, length, tag = "default") {
+    const bytesPerElement = constructor.BYTES_PER_ELEMENT;
+    const buffer = this.allocate(length * bytesPerElement, tag);
+    return new constructor(buffer);
+  }
+  /**
+   * Get allocation information
+   */
+  getAllocation(tag) {
+    return this.allocations.get(tag);
+  }
+  /**
+   * Get local memory node for current thread
+   */
+  getLocalNode() {
+    return this.config.preferredNode;
+  }
+  /**
+   * Get number of NUMA nodes
+   */
+  getNodeCount() {
+    return 1;
+  }
+  /**
+   * Check if NUMA is available
+   */
+  isNUMAAvailable() {
+    return false;
+  }
+  /**
+   * Migrate allocation to preferred node
+   * Note: No-op in JavaScript
+   */
+  migrateToNode(tag, node) {
+    const allocation = this.allocations.get(tag);
+    if (!allocation) {
+      return false;
+    }
+    allocation.node = node;
+    return true;
+  }
+  /**
+   * Free allocation tracking
+   */
+  free(tag) {
+    this.allocations.delete(tag);
+  }
+  /**
+   * Get all allocations
+   */
+  getAllAllocations() {
+    return new Map(this.allocations);
+  }
+};
+var CacheOptimizer = class {
+  cacheLineSize = 64;
+  l1Size = 32 * 1024;
+  l2Size = 256 * 1024;
+  l3Size = 8 * 1024 * 1024;
+  constructor() {
+  }
+  /**
+   * Set cache parameters
+   */
+  setCacheParams(params) {
+    if (params.cacheLineSize) this.cacheLineSize = params.cacheLineSize;
+    if (params.l1Size) this.l1Size = params.l1Size;
+    if (params.l2Size) this.l2Size = params.l2Size;
+    if (params.l3Size) this.l3Size = params.l3Size;
+  }
+  /**
+   * Align size to cache line boundary
+   */
+  alignToCacheLine(size) {
+    const mask = this.cacheLineSize - 1;
+    return size + mask & ~mask;
+  }
+  /**
+   * Check if address is cache line aligned
+   */
+  isCacheLineAligned(address) {
+    return (address & this.cacheLineSize - 1) === 0;
+  }
+  /**
+   * Calculate cache-friendly array stride
+   */
+  calculateStride(elementSize) {
+    return Math.max(elementSize, this.cacheLineSize);
+  }
+  /**
+   * Create cache-friendly layout for array of objects
+   */
+  createSoALayout(count, schema) {
+    const typeSizes = {
+      u8: 1,
+      u16: 2,
+      u32: 4,
+      u64: 8,
+      f32: 4,
+      f64: 8
+    };
+    const arrays = {};
+    const offsets = {};
+    let currentOffset = 0;
+    for (const [key, type] of Object.entries(schema)) {
+      const size = typeSizes[type];
+      if (size === void 0) {
+        throw new Error(`Unsupported struct field type: ${type}`);
+      }
+      const alignedOffset = this.alignToCacheLine(currentOffset);
+      offsets[key] = alignedOffset;
+      const totalSize = alignedOffset + count * size;
+      const buffer = new ArrayBuffer(totalSize);
+      switch (type) {
+        case "u8":
+          arrays[key] = new Uint8Array(buffer, alignedOffset, count);
+          break;
+        case "u16":
+          arrays[key] = new Uint16Array(buffer, alignedOffset, count);
+          break;
+        case "u32":
+          arrays[key] = new Uint32Array(buffer, alignedOffset, count);
+          break;
+        case "u64":
+          arrays[key] = new BigUint64Array(buffer, alignedOffset, count);
+          break;
+        case "f32":
+          arrays[key] = new Float32Array(buffer, alignedOffset, count);
+          break;
+        case "f64":
+          arrays[key] = new Float64Array(buffer, alignedOffset, count);
+          break;
+      }
+      currentOffset = alignedOffset + count * size;
+    }
+    return {
+      arrays,
+      offsets,
+      count,
+      get(index) {
+        const result = {};
+        for (const key of Object.keys(arrays)) {
+          result[key] = arrays[key][index];
+        }
+        return result;
+      },
+      set(index, value) {
+        for (const key of Object.keys(arrays)) {
+          arrays[key][index] = value[key];
+        }
+      }
+    };
+  }
+  /**
+   * Get cache line size
+   */
+  getCacheLineSize() {
+    return this.cacheLineSize;
+  }
+  /**
+   * Get L1 cache size
+   */
+  getL1Size() {
+    return this.l1Size;
+  }
+  /**
+   * Get L2 cache size
+   */
+  getL2Size() {
+    return this.l2Size;
+  }
+  /**
+   * Get L3 cache size
+   */
+  getL3Size() {
+    return this.l3Size;
+  }
+};
+var HardwareMonitor = class {
+  startTime = 0;
+  measurements = [];
+  /**
+   * Start monitoring
+   */
+  start() {
+    this.startTime = performance.now();
+  }
+  /**
+   * Take a measurement
+   */
+  measure(label) {
+    this.measurements.push({
+      label,
+      timestamp: performance.now() - this.startTime,
+      memory: this.getMemoryInfo()
+    });
+  }
+  /**
+   * Get memory information
+   */
+  getMemoryInfo() {
+    if (typeof process !== "undefined" && process.memoryUsage) {
+      const usage = process.memoryUsage();
+      return {
+        used: usage.heapUsed,
+        total: usage.heapTotal,
+        external: usage.external,
+        rss: usage.rss
+      };
+    }
+    if (typeof performance !== "undefined" && performance.memory) {
+      const mem = performance.memory;
+      return {
+        used: mem.usedJSHeapSize,
+        total: mem.totalJSHeapSize,
+        external: 0,
+        rss: 0
+      };
+    }
+    return { used: 0, total: 0, external: 0, rss: 0 };
+  }
+  /**
+   * Get all measurements
+   */
+  getMeasurements() {
+    return [...this.measurements];
+  }
+  /**
+   * Reset measurements
+   */
+  reset() {
+    this.measurements = [];
+    this.startTime = performance.now();
+  }
+};
+function createCPUAffinity(config) {
+  const fullConfig = { ...defaultAffinityConfig(), ...config };
+  return new CPUAffinity(fullConfig);
+}
+function createNUMAOptimizer(config) {
+  const fullConfig = { ...defaultNUMAConfig(), ...config };
+  return new NUMAOptimizer(fullConfig);
+}
+function createCacheOptimizer() {
+  return new CacheOptimizer();
+}
+function createHardwareMonitor() {
+  return new HardwareMonitor();
+}
+function getSystemCPUInfo() {
+  const os = require("os");
+  const cpus = os.cpus();
+  return {
+    cores: cpus.length,
+    model: cpus[0]?.model || "Unknown"
+  };
+}
+function getSystemMemoryInfo() {
+  const os = require("os");
+  return {
+    total: os.totalmem(),
+    free: os.freemem()
+  };
+}
+
+// src/perf/kernel-bypass.ts
+var IOOperation = /* @__PURE__ */ ((IOOperation2) => {
+  IOOperation2["READ"] = "READ";
+  IOOperation2["WRITE"] = "WRITE";
+  IOOperation2["FSYNC"] = "FSYNC";
+  IOOperation2["POLL"] = "POLL";
+  IOOperation2["TIMEOUT"] = "TIMEOUT";
+  return IOOperation2;
+})(IOOperation || {});
+function defaultIOUringConfig() {
+  return {
+    queueDepth: 256,
+    sqThreadIdle: 2e3,
+    sqThreadCpu: -1,
+    cqSize: 0,
+    flags: 0,
+    features: []
+  };
+}
+var KernelBypassManager = class {
+  config;
+  uringAvailable = false;
+  requestCounter = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  running = false;
+  processTimer = null;
+  constructor(config) {
+    this.config = config || defaultIOUringConfig();
+    this.checkUringAvailability();
+  }
+  /**
+   * Check if io_uring-like functionality is available
+   */
+  checkUringAvailability() {
+    if (process.platform !== "linux") {
+      return false;
+    }
+    this.uringAvailable = false;
+    return false;
+  }
+  /**
+   * Check if io_uring is available
+   */
+  isUringAvailable() {
+    return this.uringAvailable;
+  }
+  /**
+   * Start the I/O processing loop
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.processTimer = setInterval(() => {
+      this.processPendingRequests();
+    }, 0.1);
+    setImmediate(() => this.processLoop());
+  }
+  /**
+   * Stop the I/O processing loop
+   */
+  stop() {
+    this.running = false;
+    if (this.processTimer) {
+      clearInterval(this.processTimer);
+      this.processTimer = null;
+    }
+  }
+  /**
+   * Main processing loop
+   */
+  processLoop() {
+    if (!this.running) return;
+    this.processPendingRequests();
+    if (this.running) {
+      setImmediate(() => this.processLoop());
+    }
+  }
+  /**
+   * Process pending I/O requests
+   */
+  processPendingRequests() {
+    const toDelete = [];
+    this.pendingRequests.forEach((request, id) => {
+      switch (request.op) {
+        case "READ" /* READ */:
+          this.processRead(id, request);
+          break;
+        case "WRITE" /* WRITE */:
+          this.processWrite(id, request);
+          break;
+      }
+      toDelete.push(id);
+    });
+    toDelete.forEach((id) => this.pendingRequests.delete(id));
+  }
+  /**
+   * Process a read request
+   */
+  processRead(id, request) {
+    try {
+      const fs = require("fs");
+      const buffer = Buffer.alloc(request.size);
+      fs.read(request.fd, buffer, 0, request.size, request.offset, (err, bytesRead) => {
+        if (request.callback) {
+          request.callback(id, err ? null : buffer.slice(0, bytesRead), bytesRead);
+        }
+      });
+    } catch (error) {
+      if (request.callback) {
+        request.callback(id, null, 0);
+      }
+    }
+  }
+  /**
+   * Process a write request
+   */
+  processWrite(id, request) {
+    try {
+      const fs = require("fs");
+      fs.write(request.fd, request.buffer, 0, request.buffer.length, request.offset, (err, bytesWritten) => {
+        if (request.callback) {
+          request.callback(id, null, bytesWritten);
+        }
+      });
+    } catch (error) {
+      if (request.callback) {
+        request.callback(id, null, 0);
+      }
+    }
+  }
+  /**
+   * Submit an async read request
+   */
+  submitRead(fd, size, offset = 0, callback, userData) {
+    const id = ++this.requestCounter;
+    const request = {
+      op: "READ" /* READ */,
+      fd,
+      offset,
+      size,
+      callback,
+      userData
+    };
+    this.pendingRequests.set(id, request);
+    return id;
+  }
+  /**
+   * Submit an async write request
+   */
+  submitWrite(fd, buffer, offset = 0, callback, userData) {
+    const id = ++this.requestCounter;
+    const request = {
+      op: "WRITE" /* WRITE */,
+      fd,
+      buffer,
+      offset,
+      size: buffer.length,
+      callback,
+      userData
+    };
+    this.pendingRequests.set(id, request);
+    return id;
+  }
+};
+var DirectIOFile = class {
+  path;
+  fd = null;
+  directIO = false;
+  constructor(path) {
+    this.path = path;
+  }
+  /**
+   * Open file with direct I/O if available
+   */
+  async open() {
+    const fs = require("fs").promises;
+    try {
+      this.fd = await fs.open(this.path, "r+");
+      this.directIO = process.platform === "linux";
+      return true;
+    } catch (error) {
+      try {
+        this.fd = await fs.open(this.path, "w+");
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+  /**
+   * Close the file
+   */
+  async close() {
+    if (this.fd !== null) {
+      const fs = require("fs").promises;
+      await fs.close(this.fd);
+      this.fd = null;
+    }
+  }
+  /**
+   * Read from file
+   */
+  async read(size, offset = 0) {
+    if (this.fd === null) {
+      throw new Error("File not open");
+    }
+    if (this.directIO) {
+      return this.readDirect(size, offset);
+    }
+    const fs = require("fs").promises;
+    const buffer = Buffer.alloc(size);
+    await fs.read(this.fd, buffer, 0, size, offset);
+    return buffer;
+  }
+  /**
+   * Read using direct I/O with aligned buffer
+   */
+  async readDirect(size, offset) {
+    const align = 512;
+    const alignedOffset = Math.floor(offset / align) * align;
+    const offsetDiff = offset - alignedOffset;
+    const alignedSize = Math.ceil((size + offsetDiff + align - 1) / align) * align;
+    const buffer = Buffer.alloc(alignedSize);
+    const fs = require("fs").promises;
+    await fs.read(this.fd, buffer, 0, alignedSize, alignedOffset);
+    return buffer.slice(offsetDiff, offsetDiff + size);
+  }
+  /**
+   * Write to file
+   */
+  async write(data, offset = 0) {
+    if (this.fd === null) {
+      throw new Error("File not open");
+    }
+    const fs = require("fs").promises;
+    const { bytesWritten } = await fs.write(this.fd, data, 0, data.length, offset);
+    return bytesWritten;
+  }
+  /**
+   * Sync file to disk
+   */
+  async fsync() {
+    if (this.fd !== null) {
+      const fs = require("fs").promises;
+      await fs.fsync(this.fd);
+    }
+  }
+};
+var MemoryMappedFile = class {
+  path;
+  fd = null;
+  buffer = null;
+  constructor(path) {
+    this.path = path;
+  }
+  /**
+   * Open and memory-map the file
+   */
+  async open(size = 0) {
+    const fs = require("fs");
+    const fsPromises = fs.promises;
+    try {
+      const fileHandle = await fsPromises.open(this.path, "r+");
+      this.fd = fileHandle.fd;
+      const stats = await fileHandle.stat();
+      let fileSize = stats.size;
+      if (size > 0 && size > fileSize) {
+        await fileHandle.truncate(size);
+        fileSize = size;
+      }
+      if (fileSize === 0) {
+        fileSize = 4096;
+        await fileHandle.truncate(fileSize);
+      }
+      this.buffer = Buffer.alloc(fileSize);
+      await fileHandle.read(this.buffer, 0, fileSize, 0);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Close the memory-mapped file
+   */
+  async close() {
+    if (this.buffer) {
+      const fs = require("fs").promises;
+      if (this.fd !== null) {
+        await fs.write(this.fd, this.buffer, 0, this.buffer.length, 0);
+      }
+      this.buffer = null;
+    }
+    if (this.fd !== null) {
+      const fs = require("fs").promises;
+      await fs.close(this.fd);
+      this.fd = null;
+    }
+  }
+  /**
+   * Read from memory-mapped file
+   */
+  read(offset, size) {
+    if (!this.buffer) {
+      throw new Error("File not mapped");
+    }
+    return this.buffer.slice(offset, offset + size);
+  }
+  /**
+   * Write to memory-mapped file
+   */
+  write(offset, data) {
+    if (!this.buffer) {
+      throw new Error("File not mapped");
+    }
+    data.copy(this.buffer, offset);
+  }
+  /**
+   * Flush changes to disk
+   */
+  async flush() {
+    if (this.buffer && this.fd !== null) {
+      const fs = require("fs").promises;
+      await fs.write(this.fd, this.buffer, 0, this.buffer.length, 0);
+    }
+  }
+};
+var AsyncSocket = class {
+  socket = null;
+  /**
+   * Set the underlying socket
+   */
+  setSocket(socket) {
+    this.socket = socket;
+  }
+  /**
+   * Enable kernel bypass optimizations for this socket
+   */
+  enableKernelBypass() {
+    if (!this.socket) {
+      return false;
+    }
+    try {
+      this.socket.setNoDelay(true);
+      this.socket.setKeepAlive(true, 1e3);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Async receive with optimization
+   */
+  async recv(size) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error("Socket not set"));
+        return;
+      }
+      this.socket.once("data", (data) => {
+        resolve(data);
+      });
+      this.socket.once("error", reject);
+    });
+  }
+  /**
+   * Async send with optimization
+   */
+  async send(data) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error("Socket not set"));
+        return;
+      }
+      this.socket.write(data, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+};
+var IOBatchProcessor = class {
+  maxBatchSize;
+  readBatch = [];
+  writeBatch = [];
+  manager;
+  constructor(maxBatchSize = 32) {
+    this.maxBatchSize = maxBatchSize;
+    this.manager = new KernelBypassManager();
+  }
+  /**
+   * Add read to batch
+   */
+  addRead(fd, size, offset = 0, callback = () => {
+  }) {
+    this.readBatch.push({ fd, size, offset, callback });
+    if (this.readBatch.length >= this.maxBatchSize) {
+      this.flushReads();
+    }
+  }
+  /**
+   * Add write to batch
+   */
+  addWrite(fd, data, offset = 0, callback = () => {
+  }) {
+    this.writeBatch.push({ fd, data, offset, callback });
+    if (this.writeBatch.length >= this.maxBatchSize) {
+      this.flushWrites();
+    }
+  }
+  /**
+   * Flush all pending reads
+   */
+  flushReads() {
+    if (this.readBatch.length === 0) {
+      return [];
+    }
+    const requestIds = this.readBatch.map(
+      (req) => this.manager.submitRead(req.fd, req.size, req.offset, req.callback)
+    );
+    this.readBatch = [];
+    return requestIds;
+  }
+  /**
+   * Flush all pending writes
+   */
+  flushWrites() {
+    if (this.writeBatch.length === 0) {
+      return [];
+    }
+    const requestIds = this.writeBatch.map(
+      (req) => this.manager.submitWrite(req.fd, req.data, req.offset, req.callback)
+    );
+    this.writeBatch = [];
+    return requestIds;
+  }
+  /**
+   * Flush all pending operations
+   */
+  flushAll() {
+    return {
+      readIds: this.flushReads(),
+      writeIds: this.flushWrites()
+    };
+  }
+};
+var globalKBManager = null;
+function getKernelBypassManager(config) {
+  if (!globalKBManager) {
+    globalKBManager = new KernelBypassManager(config);
+  }
+  return globalKBManager;
+}
+
+// src/perf/protocol.ts
+var import_web3 = require("@solana/web3.js");
+function defaultTransactionConfig() {
+  return {
+    computeUnitLimit: 2e5,
+    computeUnitPrice: 1e5,
+    priorityFee: 1e5,
+    dynamicComputeBudget: true,
+    packInstructions: true,
+    maxTransactionSize: 1232,
+    // Solana transaction size limit
+    useAddressLookupTables: true
+  };
+}
+var TransactionBuilder = class {
+  instructions = [];
+  config;
+  computeEstimates = /* @__PURE__ */ new Map();
+  signers = [];
+  constructor(config = defaultTransactionConfig()) {
+    this.config = config;
+    this.initializeComputeEstimates();
+  }
+  /**
+   * Initialize default compute estimates for common instructions
+   */
+  initializeComputeEstimates() {
+    this.computeEstimates.set("transfer", 450);
+    this.computeEstimates.set("createAccount", 2500);
+    this.computeEstimates.set("createATA", 3500);
+    this.computeEstimates.set("closeAccount", 2500);
+    this.computeEstimates.set("syncNative", 500);
+    this.computeEstimates.set("setComputeUnitLimit", 100);
+    this.computeEstimates.set("setComputeUnitPrice", 100);
+    this.computeEstimates.set("pumpFunBuy", 45e3);
+    this.computeEstimates.set("pumpFunSell", 4e4);
+    this.computeEstimates.set("pumpSwapBuy", 5e4);
+    this.computeEstimates.set("pumpSwapSell", 45e3);
+    this.computeEstimates.set("raydiumSwap", 55e3);
+    this.computeEstimates.set("meteoraSwap", 6e4);
+  }
+  /**
+   * Add an instruction to the transaction
+   */
+  addInstruction(instruction, computeEstimate, priority = 0) {
+    this.instructions.push(instruction);
+    for (const key of instruction.keys) {
+      if (key.isSigner && !this.signers.some((s) => s.equals(key.pubkey))) {
+        this.signers.push(key.pubkey);
+      }
+    }
+    return this;
+  }
+  /**
+   * Add multiple instructions
+   */
+  addInstructions(instructions) {
+    for (const ix of instructions) {
+      this.addInstruction(ix);
+    }
+    return this;
+  }
+  /**
+   * Add compute budget instructions
+   */
+  addComputeBudget(units, price) {
+    this.instructions.unshift(
+      import_web3.ComputeBudgetProgram.setComputeUnitLimit({ units }),
+      import_web3.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: price })
+    );
+    return this;
+  }
+  /**
+   * Estimate total compute units
+   */
+  estimateCompute() {
+    let total = 0;
+    for (const ix of this.instructions) {
+      const estimate = this.computeEstimates.get(ix.programId.toBase58()) || 3e3;
+      total += estimate;
+    }
+    total += 200;
+    return total;
+  }
+  /**
+   * Build optimized transaction instructions
+   */
+  build() {
+    let optimizedInstructions = [...this.instructions];
+    const optimizations = [];
+    if (this.config.packInstructions) {
+      optimizedInstructions = this.packInstructions(optimizedInstructions);
+      optimizations.push("instruction_packing");
+    }
+    const computeEstimate = this.estimateCompute();
+    let computeLimit = this.config.computeUnitLimit;
+    if (this.config.dynamicComputeBudget) {
+      computeLimit = this.calculateOptimalComputeLimit(computeEstimate);
+      optimizations.push("dynamic_compute_budget");
+    }
+    const computePrice = this.calculateOptimalPrice();
+    const estimatedSize = this.estimateTransactionSize(optimizedInstructions);
+    optimizedInstructions = this.addComputeBudgetInstructions(
+      optimizedInstructions,
+      computeLimit,
+      computePrice
+    );
+    return {
+      instructions: optimizedInstructions,
+      computeLimit,
+      computePrice,
+      estimatedSize,
+      optimizations
+    };
+  }
+  /**
+   * Build and return only the instructions (without compute budget)
+   */
+  buildInstructions() {
+    return [...this.instructions];
+  }
+  /**
+   * Clear all instructions
+   */
+  clear() {
+    this.instructions = [];
+    this.signers = [];
+    return this;
+  }
+  /**
+   * Get current instruction count
+   */
+  getInstructionCount() {
+    return this.instructions.length;
+  }
+  /**
+   * Get current signer count
+   */
+  getSignerCount() {
+    return this.signers.length;
+  }
+  packInstructions(instructions) {
+    return instructions;
+  }
+  calculateOptimalComputeLimit(estimate) {
+    const withBuffer = Math.ceil(estimate * 1.2);
+    return Math.ceil(withBuffer / 1e4) * 1e4;
+  }
+  calculateOptimalPrice() {
+    return this.config.computeUnitPrice;
+  }
+  estimateTransactionSize(instructions) {
+    let size = 64;
+    size += 3;
+    size += 32 * (this.signers.length + 1);
+    for (const ix of instructions) {
+      size += 1;
+      size += 1;
+      size += ix.keys.length * 33;
+      size += 2;
+      size += ix.data.length;
+    }
+    return size;
+  }
+  addComputeBudgetInstructions(instructions, limit, price) {
+    return instructions;
+  }
+};
+var ComputeBudgetOptimizer = class {
+  baseConfig;
+  networkStats = {
+    averageComputePrice: 0,
+    congestionLevel: 0,
+    recentSuccessRate: 1
+  };
+  history = [];
+  maxHistorySize = 100;
+  constructor(config = defaultTransactionConfig()) {
+    this.baseConfig = config;
+  }
+  /**
+   * Update network statistics
+   */
+  updateNetworkStats(stats) {
+    this.networkStats = { ...this.networkStats, ...stats };
+  }
+  /**
+   * Get optimized compute budget for current conditions
+   */
+  getOptimizedBudget(priority = "normal") {
+    const multipliers = {
+      low: 0.5,
+      normal: 1,
+      high: 2,
+      critical: 5
+    };
+    const multiplier = multipliers[priority] ?? 1;
+    const congestionMultiplier = 1 + this.networkStats.congestionLevel;
+    const successMultiplier = this.networkStats.recentSuccessRate < 0.8 ? 1.5 : 1;
+    const computeLimit = this.baseConfig.computeUnitLimit;
+    const computePrice = Math.floor(
+      this.baseConfig.computeUnitPrice * multiplier * congestionMultiplier * successMultiplier
+    );
+    const priorityFee = Math.floor(
+      this.baseConfig.priorityFee * multiplier * congestionMultiplier * successMultiplier
+    );
+    return {
+      computeLimit,
+      computePrice,
+      priorityFee
+    };
+  }
+  /**
+   * Record transaction result for learning
+   */
+  recordResult(computeUsed, computeLimit, success, confirmationTimeMs) {
+    this.history.push({
+      computeUsed,
+      computeLimit,
+      success,
+      confirmationTimeMs,
+      timestamp: Date.now()
+    });
+    if (this.history.length > this.maxHistorySize) {
+      this.history.shift();
+    }
+    const recent = this.history.slice(-20);
+    const successes = recent.filter((h) => h.success).length;
+    this.networkStats.recentSuccessRate = successes / recent.length;
+  }
+  /**
+   * Get recommended compute limit based on history
+   */
+  getRecommendedComputeLimit() {
+    if (this.history.length === 0) {
+      return this.baseConfig.computeUnitLimit;
+    }
+    const computeUsed = this.history.map((h) => h.computeUsed).sort((a, b) => a - b);
+    const p95Index = Math.floor(computeUsed.length * 0.95);
+    const p95Compute = computeUsed[p95Index] ?? computeUsed[computeUsed.length - 1] ?? this.baseConfig.computeUnitLimit;
+    return Math.ceil(p95Compute * 1.2);
+  }
+  /**
+   * Get optimization statistics
+   */
+  getStats() {
+    if (this.history.length === 0) {
+      return {
+        totalComputeUsed: 0,
+        totalComputeLimit: 0,
+        averageComputePerInstruction: 0,
+        estimatedFee: 0,
+        efficiency: 0
+      };
+    }
+    const totalUsed = this.history.reduce((sum, h) => sum + h.computeUsed, 0);
+    const totalLimit = this.history.reduce((sum, h) => sum + h.computeLimit, 0);
+    return {
+      totalComputeUsed: totalUsed,
+      totalComputeLimit: totalLimit,
+      averageComputePerInstruction: totalUsed / this.history.length,
+      estimatedFee: this.calculateEstimatedFee(),
+      efficiency: totalLimit > 0 ? totalUsed / totalLimit : 0
+    };
+  }
+  /**
+   * Reset history
+   */
+  reset() {
+    this.history = [];
+    this.networkStats = {
+      averageComputePrice: 0,
+      congestionLevel: 0,
+      recentSuccessRate: 1
+    };
+  }
+  calculateEstimatedFee() {
+    const recent = this.history.slice(-10);
+    if (recent.length === 0) return 0;
+    const avgCompute = recent.reduce((sum, h) => sum + h.computeUsed, 0) / recent.length;
+    return avgCompute * this.baseConfig.computeUnitPrice;
+  }
+};
+var InstructionBatcher = class {
+  groups = [];
+  maxComputePerGroup = 12e5;
+  // 1.2M compute units
+  /**
+   * Add an instruction group
+   */
+  addGroup(group) {
+    this.groups.push(group);
+    return this;
+  }
+  /**
+   * Batch all groups into optimal transaction sets
+   */
+  batch() {
+    const batches = [];
+    let currentBatch = [];
+    let currentCompute = 0;
+    const sorted = [...this.groups].sort((a, b) => b.priority - a.priority);
+    for (const group of sorted) {
+      if (currentCompute + group.computeEstimate > this.maxComputePerGroup) {
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
+        }
+        currentBatch = [group];
+        currentCompute = group.computeEstimate;
+      } else {
+        currentBatch.push(group);
+        currentCompute += group.computeEstimate;
+      }
+    }
+    if (currentBatch.length > 0) {
+      batches.push(currentBatch);
+    }
+    return batches;
+  }
+  /**
+   * Set maximum compute per batch
+   */
+  setMaxComputePerGroup(compute) {
+    this.maxComputePerGroup = compute;
+    return this;
+  }
+  /**
+   * Clear all groups
+   */
+  clear() {
+    this.groups = [];
+    return this;
+  }
+};
+var TransactionOptimizer = class {
+  config;
+  budgetOptimizer;
+  constructor(config = defaultTransactionConfig()) {
+    this.config = config;
+    this.budgetOptimizer = new ComputeBudgetOptimizer(config);
+  }
+  /**
+   * Optimize a set of instructions
+   */
+  optimize(instructions, options = {}) {
+    const builder = new TransactionBuilder(this.config);
+    builder.addInstructions(instructions);
+    const result = builder.build();
+    if (options.priority) {
+      const budget = this.budgetOptimizer.getOptimizedBudget(options.priority);
+      result.computeLimit = budget.computeLimit;
+      result.computePrice = budget.computePrice;
+    }
+    return result;
+  }
+  /**
+   * Optimize for minimum latency
+   */
+  optimizeForLatency(instructions) {
+    return this.optimize(instructions, { priority: "critical" });
+  }
+  /**
+   * Optimize for minimum cost
+   */
+  optimizeForCost(instructions) {
+    return this.optimize(instructions, { priority: "low" });
+  }
+  /**
+   * Get the compute budget optimizer
+   */
+  getBudgetOptimizer() {
+    return this.budgetOptimizer;
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    this.budgetOptimizer = new ComputeBudgetOptimizer(this.config);
+  }
+};
+function createTransactionBuilder(config) {
+  const fullConfig = { ...defaultTransactionConfig(), ...config };
+  return new TransactionBuilder(fullConfig);
+}
+function createComputeBudgetOptimizer(config) {
+  const fullConfig = { ...defaultTransactionConfig(), ...config };
+  return new ComputeBudgetOptimizer(fullConfig);
+}
+function createInstructionBatcher() {
+  return new InstructionBatcher();
+}
+function createTransactionOptimizer(config) {
+  const fullConfig = { ...defaultTransactionConfig(), ...config };
+  return new TransactionOptimizer(fullConfig);
+}
+function estimateCompute(operation) {
+  const estimates = {
+    transfer: 450,
+    createAccount: 2500,
+    createATA: 3500,
+    closeAccount: 2500,
+    syncNative: 500,
+    pumpFunBuy: 45e3,
+    pumpFunSell: 4e4,
+    pumpSwapBuy: 5e4,
+    pumpSwapSell: 45e3,
+    raydiumSwap: 55e3,
+    meteoraSwap: 6e4
+  };
+  return estimates[operation] || 3e3;
+}
+function calculateOptimalPrice(targetLatencyMs, currentCongestion) {
+  const basePrice = 1e5;
+  const latencyMultiplier = Math.max(1, 100 / targetLatencyMs);
+  const congestionMultiplier = 1 + currentCongestion;
+  return Math.floor(basePrice * latencyMultiplier * congestionMultiplier);
+}
+
+// src/perf/realtime.ts
+var ThreadPriorityLevel = /* @__PURE__ */ ((ThreadPriorityLevel2) => {
+  ThreadPriorityLevel2[ThreadPriorityLevel2["Idle"] = 0] = "Idle";
+  ThreadPriorityLevel2[ThreadPriorityLevel2["Lowest"] = 1] = "Lowest";
+  ThreadPriorityLevel2[ThreadPriorityLevel2["Low"] = 2] = "Low";
+  ThreadPriorityLevel2[ThreadPriorityLevel2["Normal"] = 3] = "Normal";
+  ThreadPriorityLevel2[ThreadPriorityLevel2["High"] = 4] = "High";
+  ThreadPriorityLevel2[ThreadPriorityLevel2["Highest"] = 5] = "Highest";
+  ThreadPriorityLevel2[ThreadPriorityLevel2["Realtime"] = 6] = "Realtime";
+  return ThreadPriorityLevel2;
+})(ThreadPriorityLevel || {});
+var SchedulerPolicy = /* @__PURE__ */ ((SchedulerPolicy2) => {
+  SchedulerPolicy2["Normal"] = "normal";
+  SchedulerPolicy2["FIFO"] = "fifo";
+  SchedulerPolicy2["RoundRobin"] = "rr";
+  SchedulerPolicy2["Batch"] = "batch";
+  SchedulerPolicy2["Idle"] = "idle";
+  return SchedulerPolicy2;
+})(SchedulerPolicy || {});
+function defaultRealtimeConfig() {
+  return {
+    enableRealtime: false,
+    targetLatencyUs: 100,
+    // 100 microseconds
+    cpuCore: -1,
+    // No pinning
+    priority: 4 /* High */,
+    busyWait: false,
+    scheduler: "normal" /* Normal */,
+    lockMemory: false
+  };
+}
+var ThreadPriority = class {
+  currentPriority = 3 /* Normal */;
+  config;
+  constructor(config = defaultRealtimeConfig()) {
+    this.config = config;
+  }
+  /**
+   * Set thread priority
+   */
+  setPriority(priority) {
+    this.currentPriority = priority;
+    if (this.config.enableRealtime) {
+      console.log(`Thread priority set to: ${ThreadPriorityLevel[priority]}`);
+    }
+    return true;
+  }
+  /**
+   * Get current priority
+   */
+  getPriority() {
+    return this.currentPriority;
+  }
+  /**
+   * Increase priority by one level
+   */
+  increasePriority() {
+    if (this.currentPriority < 6 /* Realtime */) {
+      return this.setPriority(this.currentPriority + 1);
+    }
+    return false;
+  }
+  /**
+   * Decrease priority by one level
+   */
+  decreasePriority() {
+    if (this.currentPriority > 0 /* Idle */) {
+      return this.setPriority(this.currentPriority - 1);
+    }
+    return false;
+  }
+  /**
+   * Set realtime priority
+   */
+  setRealtime() {
+    return this.setPriority(6 /* Realtime */);
+  }
+  /**
+   * Set normal priority
+   */
+  setNormal() {
+    return this.setPriority(3 /* Normal */);
+  }
+  /**
+   * Check if running at realtime priority
+   */
+  isRealtime() {
+    return this.currentPriority === 6 /* Realtime */;
+  }
+};
+var RealtimeTuner = class {
+  config;
+  running = false;
+  tunerInterval = null;
+  latencies = [];
+  stats;
+  callbacks = [];
+  lastAdjustment = 0;
+  adjustmentCooldownMs = 1e3;
+  constructor(config = defaultRealtimeConfig()) {
+    this.config = config;
+    this.stats = {
+      adjustments: 0,
+      averageLatencyUs: 0,
+      minLatencyUs: Infinity,
+      maxLatencyUs: 0,
+      violations: 0,
+      lastAdjustmentTime: 0
+    };
+  }
+  /**
+   * Start the realtime tuner
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.applyConfiguration();
+    this.tunerInterval = setInterval(() => {
+      this.tune();
+    }, 100);
+    console.log("Realtime tuner started");
+  }
+  /**
+   * Stop the realtime tuner
+   */
+  stop() {
+    this.running = false;
+    if (this.tunerInterval) {
+      clearInterval(this.tunerInterval);
+      this.tunerInterval = null;
+    }
+    console.log("Realtime tuner stopped");
+  }
+  /**
+   * Record a latency measurement
+   */
+  recordLatency(latencyUs) {
+    this.latencies.push(latencyUs);
+    if (this.latencies.length > 1e3) {
+      this.latencies.shift();
+    }
+    if (latencyUs > this.config.targetLatencyUs) {
+      this.stats.violations++;
+    }
+    this.stats.minLatencyUs = Math.min(this.stats.minLatencyUs, latencyUs);
+    this.stats.maxLatencyUs = Math.max(this.stats.maxLatencyUs, latencyUs);
+  }
+  /**
+   * Get current tuning statistics
+   */
+  getStats() {
+    if (this.latencies.length > 0) {
+      this.stats.averageLatencyUs = this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length;
+    }
+    return { ...this.stats };
+  }
+  /**
+   * Register a callback for tuning events
+   */
+  onTune(callback) {
+    this.callbacks.push(callback);
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.latencies = [];
+    this.stats = {
+      adjustments: 0,
+      averageLatencyUs: 0,
+      minLatencyUs: Infinity,
+      maxLatencyUs: 0,
+      violations: 0,
+      lastAdjustmentTime: 0
+    };
+  }
+  applyConfiguration() {
+    const priority = new ThreadPriority(this.config);
+    priority.setPriority(this.config.priority);
+    console.log("Realtime configuration applied:", {
+      targetLatencyUs: this.config.targetLatencyUs,
+      cpuCore: this.config.cpuCore,
+      priority: ThreadPriorityLevel[this.config.priority],
+      busyWait: this.config.busyWait
+    });
+  }
+  tune() {
+    if (!this.running) return;
+    const now = Date.now();
+    if (now - this.lastAdjustment < this.adjustmentCooldownMs) {
+      return;
+    }
+    if (this.latencies.length === 0) return;
+    const avgLatency = this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length;
+    this.stats.averageLatencyUs = avgLatency;
+    const violationRate = this.stats.violations / this.latencies.length;
+    if (violationRate > 0.1) {
+      this.adjustForLowerLatency();
+      this.stats.adjustments++;
+      this.stats.lastAdjustmentTime = now;
+      this.lastAdjustment = now;
+    }
+    for (const callback of this.callbacks) {
+      try {
+        callback(this.getStats());
+      } catch (error) {
+        console.error("Tuning callback error:", error);
+      }
+    }
+  }
+  adjustForLowerLatency() {
+    console.log("Adjusting for lower latency...");
+  }
+};
+function busyWait(microseconds) {
+  const start = process.hrtime.bigint();
+  const target = start + BigInt(microseconds) * BigInt(1e3);
+  while (process.hrtime.bigint() < target) {
+  }
+}
+function spinLock(condition, timeoutUs) {
+  const start = process.hrtime.bigint();
+  const timeoutNs = BigInt(timeoutUs) * BigInt(1e3);
+  while (!condition()) {
+    if (process.hrtime.bigint() - start > timeoutNs) {
+      return false;
+    }
+  }
+  return true;
+}
+var LatencyMonitor = class {
+  measurements = [];
+  maxMeasurements;
+  histogram = /* @__PURE__ */ new Map();
+  bucketSize;
+  constructor(maxMeasurements = 1e4, bucketSize = 10) {
+    this.maxMeasurements = maxMeasurements;
+    this.bucketSize = bucketSize;
+  }
+  /**
+   * Record a latency measurement
+   */
+  record(latencyUs) {
+    this.measurements.push(latencyUs);
+    if (this.measurements.length > this.maxMeasurements) {
+      this.measurements.shift();
+    }
+    const bucket = Math.floor(latencyUs / this.bucketSize) * this.bucketSize;
+    const count = this.histogram.get(bucket) || 0;
+    this.histogram.set(bucket, count + 1);
+  }
+  /**
+   * Get percentile latency
+   */
+  getPercentile(percentile) {
+    if (this.measurements.length === 0) return 0;
+    const sorted = [...this.measurements].sort((a, b) => a - b);
+    const index = Math.floor(percentile / 100 * sorted.length);
+    return sorted[Math.min(index, sorted.length - 1)] ?? 0;
+  }
+  /**
+   * Get average latency
+   */
+  getAverage() {
+    if (this.measurements.length === 0) return 0;
+    return this.measurements.reduce((a, b) => a + b, 0) / this.measurements.length;
+  }
+  /**
+   * Get minimum latency
+   */
+  getMin() {
+    if (this.measurements.length === 0) return 0;
+    return Math.min(...this.measurements);
+  }
+  /**
+   * Get maximum latency
+   */
+  getMax() {
+    if (this.measurements.length === 0) return 0;
+    return Math.max(...this.measurements);
+  }
+  /**
+   * Get histogram
+   */
+  getHistogram() {
+    return new Map(this.histogram);
+  }
+  /**
+   * Reset all measurements
+   */
+  reset() {
+    this.measurements = [];
+    this.histogram.clear();
+  }
+  /**
+   * Get summary statistics
+   */
+  getSummary() {
+    return {
+      count: this.measurements.length,
+      min: this.getMin(),
+      max: this.getMax(),
+      avg: this.getAverage(),
+      p50: this.getPercentile(50),
+      p95: this.getPercentile(95),
+      p99: this.getPercentile(99),
+      p999: this.getPercentile(99.9)
+    };
+  }
+};
+var PerformanceGovernor = class {
+  targetThroughput = 0;
+  currentThroughput = 0;
+  adjustments = 0;
+  /**
+   * Set target throughput (operations per second)
+   */
+  setTargetThroughput(opsPerSecond) {
+    this.targetThroughput = opsPerSecond;
+  }
+  /**
+   * Report actual throughput
+   */
+  reportThroughput(opsPerSecond) {
+    this.currentThroughput = opsPerSecond;
+  }
+  /**
+   * Get recommended batch size
+   */
+  getRecommendedBatchSize() {
+    if (this.targetThroughput === 0) return 1;
+    const ratio = this.currentThroughput / this.targetThroughput;
+    if (ratio < 0.5) {
+      return 1;
+    } else if (ratio > 1.5) {
+      return 10;
+    }
+    return 5;
+  }
+  /**
+   * Get adjustment count
+   */
+  getAdjustments() {
+    return this.adjustments;
+  }
+};
+function createRealtimeTuner(config) {
+  const fullConfig = { ...defaultRealtimeConfig(), ...config };
+  return new RealtimeTuner(fullConfig);
+}
+function createThreadPriority(config) {
+  const fullConfig = { ...defaultRealtimeConfig(), ...config };
+  return new ThreadPriority(fullConfig);
+}
+function createLatencyMonitor(maxMeasurements, bucketSize) {
+  return new LatencyMonitor(maxMeasurements, bucketSize);
+}
+function createPerformanceGovernor() {
+  return new PerformanceGovernor();
+}
+function measureTime(fn) {
+  const start = process.hrtime.bigint();
+  const result = fn();
+  const elapsed = Number(process.hrtime.bigint() - start) / 1e3;
+  return { result, elapsedUs: elapsed };
+}
+function createTimer() {
+  let startTime = BigInt(0);
+  return {
+    start: () => {
+      startTime = process.hrtime.bigint();
+    },
+    elapsed: () => {
+      return Number(process.hrtime.bigint() - startTime) / 1e3;
+    },
+    reset: () => {
+      startTime = process.hrtime.bigint();
+    }
+  };
+}
+
+// src/perf/simd.ts
+function defaultSIMDConfig() {
+  return {
+    enableSIMD: true,
+    preferredWidth: 128,
+    enableWasmSIMD: true,
+    fallbackToScalar: true
+  };
+}
+var SIMDDetector = class {
+  capabilities = null;
+  /**
+   * Detect SIMD capabilities
+   */
+  detect() {
+    if (this.capabilities) {
+      return this.capabilities;
+    }
+    this.capabilities = {
+      sse: false,
+      sse2: false,
+      sse3: false,
+      ssse3: false,
+      sse41: false,
+      sse42: false,
+      avx: false,
+      avx2: false,
+      avx512: false,
+      neon: this.detectNEON(),
+      wasmSimd128: this.detectWasmSIMD128()
+    };
+    return this.capabilities;
+  }
+  /**
+   * Check if WebAssembly SIMD128 is available
+   */
+  detectWasmSIMD128() {
+    if (typeof WebAssembly === "undefined") {
+      return false;
+    }
+    try {
+      const simdTest = new Uint8Array([
+        0,
+        97,
+        115,
+        109,
+        // WASM magic
+        1,
+        0,
+        0,
+        0,
+        // version
+        1,
+        5,
+        1,
+        // type section
+        96,
+        0,
+        1,
+        123,
+        // func type with v128 return
+        3,
+        2,
+        1,
+        0,
+        // func section
+        10,
+        11,
+        1,
+        // code section
+        9,
+        0,
+        // func body
+        253,
+        15,
+        0,
+        0,
+        // v128.const
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        11
+        // end
+      ]);
+      WebAssembly.compile(simdTest);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Detect NEON support (ARM)
+   */
+  detectNEON() {
+    if (typeof process !== "undefined" && process.arch === "arm64") {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if specific capability is available
+   */
+  hasCapability(capability) {
+    const caps = this.detect();
+    return caps[capability];
+  }
+  /**
+   * Get optimal vector width
+   */
+  getOptimalWidth() {
+    const caps = this.detect();
+    if (caps.avx512) return 512;
+    if (caps.avx || caps.avx2) return 256;
+    if (caps.sse || caps.sse2 || caps.neon || caps.wasmSimd128) return 128;
+    return 64;
+  }
+  /**
+   * Check if any SIMD is available
+   */
+  hasAnySIMD() {
+    const caps = this.detect();
+    return Object.values(caps).some((v) => v);
+  }
+};
+var VectorizedMath = class {
+  config;
+  detector;
+  constructor(config = defaultSIMDConfig()) {
+    this.config = config;
+    this.detector = new SIMDDetector();
+  }
+  /**
+   * Vector addition: result = a + b
+   */
+  add(a, b, result) {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Float32Array(len);
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - len % 4;
+      for (let i = 0; i < simdLen; i += 4) {
+        out[i] = a[i] + b[i];
+        out[i + 1] = a[i + 1] + b[i + 1];
+        out[i + 2] = a[i + 2] + b[i + 2];
+        out[i + 3] = a[i + 3] + b[i + 3];
+      }
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] + b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] + b[i];
+      }
+    }
+    return out;
+  }
+  /**
+   * Vector subtraction: result = a - b
+   */
+  subtract(a, b, result) {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Float32Array(len);
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - len % 4;
+      for (let i = 0; i < simdLen; i += 4) {
+        out[i] = a[i] - b[i];
+        out[i + 1] = a[i + 1] - b[i + 1];
+        out[i + 2] = a[i + 2] - b[i + 2];
+        out[i + 3] = a[i + 3] - b[i + 3];
+      }
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] - b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] - b[i];
+      }
+    }
+    return out;
+  }
+  /**
+   * Vector multiplication: result = a * b
+   */
+  multiply(a, b, result) {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Float32Array(len);
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - len % 4;
+      for (let i = 0; i < simdLen; i += 4) {
+        out[i] = a[i] * b[i];
+        out[i + 1] = a[i + 1] * b[i + 1];
+        out[i + 2] = a[i + 2] * b[i + 2];
+        out[i + 3] = a[i + 3] * b[i + 3];
+      }
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] * b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] * b[i];
+      }
+    }
+    return out;
+  }
+  /**
+   * Vector division: result = a / b
+   */
+  divide(a, b, result) {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Float32Array(len);
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - len % 4;
+      for (let i = 0; i < simdLen; i += 4) {
+        out[i] = a[i] / b[i];
+        out[i + 1] = a[i + 1] / b[i + 1];
+        out[i + 2] = a[i + 2] / b[i + 2];
+        out[i + 3] = a[i + 3] / b[i + 3];
+      }
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] / b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] / b[i];
+      }
+    }
+    return out;
+  }
+  /**
+   * Vector dot product
+   */
+  dot(a, b) {
+    const len = Math.min(a.length, b.length);
+    let sum = 0;
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - len % 4;
+      let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+      for (let i = 0; i < simdLen; i += 4) {
+        sum0 += a[i] * b[i];
+        sum1 += a[i + 1] * b[i + 1];
+        sum2 += a[i + 2] * b[i + 2];
+        sum3 += a[i + 3] * b[i + 3];
+      }
+      sum = sum0 + sum1 + sum2 + sum3;
+      for (let i = simdLen; i < len; i++) {
+        sum += a[i] * b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        sum += a[i] * b[i];
+      }
+    }
+    return sum;
+  }
+  /**
+   * Vector sum
+   */
+  sum(a) {
+    let sum = 0;
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const len = a.length;
+      const simdLen = len - len % 4;
+      let sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0;
+      for (let i = 0; i < simdLen; i += 4) {
+        sum0 += a[i];
+        sum1 += a[i + 1];
+        sum2 += a[i + 2];
+        sum3 += a[i + 3];
+      }
+      sum = sum0 + sum1 + sum2 + sum3;
+      for (let i = simdLen; i < len; i++) {
+        sum += a[i];
+      }
+    } else {
+      for (let i = 0; i < a.length; i++) {
+        sum += a[i];
+      }
+    }
+    return sum;
+  }
+  /**
+   * Vector minimum
+   */
+  min(a) {
+    if (a.length === 0) return NaN;
+    let min = a[0];
+    for (let i = 1; i < a.length; i++) {
+      if (a[i] < min) min = a[i];
+    }
+    return min;
+  }
+  /**
+   * Vector maximum
+   */
+  max(a) {
+    if (a.length === 0) return NaN;
+    let max = a[0];
+    for (let i = 1; i < a.length; i++) {
+      if (a[i] > max) max = a[i];
+    }
+    return max;
+  }
+  /**
+   * Element-wise absolute value
+   */
+  abs(a, result) {
+    const out = result || new Float32Array(a.length);
+    for (let i = 0; i < a.length; i++) {
+      out[i] = Math.abs(a[i]);
+    }
+    return out;
+  }
+  /**
+   * Element-wise square root
+   */
+  sqrt(a, result) {
+    const out = result || new Float32Array(a.length);
+    for (let i = 0; i < a.length; i++) {
+      out[i] = Math.sqrt(a[i]);
+    }
+    return out;
+  }
+};
+var CryptoSIMD = class {
+  config;
+  detector;
+  constructor(config = defaultSIMDConfig()) {
+    this.config = config;
+    this.detector = new SIMDDetector();
+  }
+  /**
+   * XOR two byte arrays (SIMD-accelerated)
+   */
+  xor(a, b, result) {
+    const len = Math.min(a.length, b.length);
+    const out = result || new Uint8Array(len);
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - len % 16;
+      for (let i = 0; i < simdLen; i += 16) {
+        for (let j = 0; j < 16; j++) {
+          out[i + j] = a[i + j] ^ b[i + j];
+        }
+      }
+      for (let i = simdLen; i < len; i++) {
+        out[i] = a[i] ^ b[i];
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        out[i] = a[i] ^ b[i];
+      }
+    }
+    return out;
+  }
+  /**
+   * Compare two byte arrays for equality (SIMD-accelerated)
+   */
+  equals(a, b) {
+    if (a.length !== b.length) return false;
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const len = a.length;
+      const simdLen = len - len % 16;
+      for (let i = 0; i < simdLen; i += 16) {
+        for (let j = 0; j < 16; j++) {
+          if (a[i + j] !== b[i + j]) return false;
+        }
+      }
+      for (let i = simdLen; i < len; i++) {
+        if (a[i] !== b[i]) return false;
+      }
+    } else {
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Fill array with value (SIMD-accelerated)
+   */
+  fill(buffer, value) {
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const len = buffer.length;
+      const simdLen = len - len % 16;
+      for (let i = 0; i < simdLen; i += 16) {
+        for (let j = 0; j < 16; j++) {
+          buffer[i + j] = value;
+        }
+      }
+      for (let i = simdLen; i < len; i++) {
+        buffer[i] = value;
+      }
+    } else {
+      buffer.fill(value);
+    }
+  }
+  /**
+   * Copy bytes (SIMD-accelerated)
+   */
+  copy(src, dst, srcOffset = 0, dstOffset = 0, length) {
+    const len = length || Math.min(src.length - srcOffset, dst.length - dstOffset);
+    if (this.config.enableSIMD && this.detector.hasAnySIMD()) {
+      const simdLen = len - len % 16;
+      for (let i = 0; i < simdLen; i += 16) {
+        for (let j = 0; j < 16; j++) {
+          dst[dstOffset + i + j] = src[srcOffset + i + j];
+        }
+      }
+      for (let i = simdLen; i < len; i++) {
+        dst[dstOffset + i] = src[srcOffset + i];
+      }
+    } else {
+      dst.set(src.subarray(srcOffset, srcOffset + len), dstOffset);
+    }
+  }
+  /**
+   * Compute parity of byte array
+   */
+  parity(data) {
+    let parity = 0;
+    for (let i = 0; i < data.length; i++) {
+      parity ^= data[i];
+    }
+    return parity;
+  }
+  /**
+   * Rotate bytes left
+   */
+  rotateLeft(data, bits, result) {
+    const out = result || new Uint8Array(data.length);
+    const bytes = Math.floor(bits / 8);
+    const remainingBits = bits % 8;
+    if (remainingBits === 0) {
+      for (let i = 0; i < data.length; i++) {
+        out[i] = data[(i + bytes) % data.length];
+      }
+    } else {
+      for (let i = 0; i < data.length; i++) {
+        const srcIdx = (i + bytes) % data.length;
+        const nextIdx = (srcIdx + 1) % data.length;
+        out[i] = data[srcIdx] << remainingBits | data[nextIdx] >> 8 - remainingBits;
+      }
+    }
+    return out;
+  }
+};
+var Float32x4 = class _Float32x4 {
+  data;
+  constructor(x, y, z, w) {
+    this.data = new Float32Array(4);
+    if (x !== void 0) this.data[0] = x;
+    if (y !== void 0) this.data[1] = y;
+    if (z !== void 0) this.data[2] = z;
+    if (w !== void 0) this.data[3] = w;
+  }
+  static fromArray(arr, offset = 0) {
+    return new _Float32x4(arr[offset], arr[offset + 1], arr[offset + 2], arr[offset + 3]);
+  }
+  add(other) {
+    return new _Float32x4(
+      this.data[0] + other.data[0],
+      this.data[1] + other.data[1],
+      this.data[2] + other.data[2],
+      this.data[3] + other.data[3]
+    );
+  }
+  subtract(other) {
+    return new _Float32x4(
+      this.data[0] - other.data[0],
+      this.data[1] - other.data[1],
+      this.data[2] - other.data[2],
+      this.data[3] - other.data[3]
+    );
+  }
+  multiply(other) {
+    return new _Float32x4(
+      this.data[0] * other.data[0],
+      this.data[1] * other.data[1],
+      this.data[2] * other.data[2],
+      this.data[3] * other.data[3]
+    );
+  }
+  toArray() {
+    return this.data.slice();
+  }
+  get x() {
+    return this.data[0];
+  }
+  get y() {
+    return this.data[1];
+  }
+  get z() {
+    return this.data[2];
+  }
+  get w() {
+    return this.data[3];
+  }
+};
+function createSIMDDetector() {
+  return new SIMDDetector();
+}
+function createVectorizedMath(config) {
+  const fullConfig = { ...defaultSIMDConfig(), ...config };
+  return new VectorizedMath(fullConfig);
+}
+function createCryptoSIMD(config) {
+  const fullConfig = { ...defaultSIMDConfig(), ...config };
+  return new CryptoSIMD(fullConfig);
+}
+function isSIMDAvailable() {
+  return new SIMDDetector().hasAnySIMD();
+}
+function getOptimalSIMDWidth() {
+  return new SIMDDetector().getOptimalWidth();
+}
+
+// src/perf/syscall-bypass.ts
+function defaultSyscallBypassConfig() {
+  return {
+    enableFastTime: true,
+    timeCacheIntervalUs: 1e3,
+    // 1ms
+    enableBatching: true,
+    maxBatchSize: 64,
+    useVdsoTime: true
+  };
+}
+var FastTimeProvider = class {
+  cachedTimeNs = BigInt(0);
+  cachedTimeMs = 0;
+  lastUpdateNs = BigInt(0);
+  updateIntervalNs;
+  running = false;
+  updateTimer = null;
+  useHighRes;
+  constructor(updateIntervalUs = 1e3, useHighRes = true) {
+    this.updateIntervalNs = BigInt(updateIntervalUs * 1e3);
+    this.useHighRes = useHighRes;
+    this.updateTime();
+  }
+  /**
+   * Start the background time update loop
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    const intervalMs = Number(this.updateIntervalNs) / 1e6;
+    this.updateTimer = setInterval(() => {
+      this.updateTime();
+    }, Math.max(1, intervalMs));
+  }
+  /**
+   * Stop the background time update loop
+   */
+  stop() {
+    this.running = false;
+    if (this.updateTimer) {
+      clearInterval(this.updateTimer);
+      this.updateTimer = null;
+    }
+  }
+  /**
+   * Get cached time in nanoseconds (fast, no syscall)
+   */
+  nowNs() {
+    return this.cachedTimeNs;
+  }
+  /**
+   * Get cached time in microseconds (fast, no syscall)
+   */
+  nowUs() {
+    return this.cachedTimeNs / BigInt(1e3);
+  }
+  /**
+   * Get cached time in milliseconds (fast, no syscall)
+   */
+  nowMs() {
+    return this.cachedTimeMs;
+  }
+  /**
+   * Get precise time (may involve syscall)
+   */
+  preciseNowNs() {
+    if (this.useHighRes && typeof process !== "undefined" && process.hrtime) {
+      const [seconds, nanoseconds] = process.hrtime();
+      return BigInt(seconds) * BigInt(1e9) + BigInt(nanoseconds);
+    }
+    return BigInt(Date.now()) * BigInt(1e6);
+  }
+  /**
+   * Get precise time in microseconds
+   */
+  preciseNowUs() {
+    return this.preciseNowNs() / BigInt(1e3);
+  }
+  updateTime() {
+    this.cachedTimeNs = this.preciseNowNs();
+    this.cachedTimeMs = Date.now();
+    this.lastUpdateNs = this.cachedTimeNs;
+  }
+};
+var SyscallBypassManager = class {
+  config;
+  timeProvider;
+  syscallQueue = [];
+  batchTimer = null;
+  stats;
+  constructor(config = defaultSyscallBypassConfig()) {
+    this.config = config;
+    this.timeProvider = new FastTimeProvider(config.timeCacheIntervalUs);
+    this.stats = {
+      totalCalls: 0,
+      bypassedCalls: 0,
+      batchedCalls: 0,
+      timeSavedNs: BigInt(0)
+    };
+  }
+  /**
+   * Initialize the syscall bypass manager
+   */
+  initialize() {
+    if (this.config.enableFastTime) {
+      this.timeProvider.start();
+    }
+    if (this.config.enableBatching) {
+      this.startBatching();
+    }
+  }
+  /**
+   * Shutdown the syscall bypass manager
+   */
+  shutdown() {
+    this.timeProvider.stop();
+    if (this.batchTimer) {
+      clearInterval(this.batchTimer);
+      this.batchTimer = null;
+    }
+    this.flushBatch();
+  }
+  /**
+   * Get fast cached time in nanoseconds
+   */
+  fastTimeNs() {
+    this.stats.totalCalls++;
+    this.stats.bypassedCalls++;
+    return this.timeProvider.nowNs();
+  }
+  /**
+   * Get fast cached time in microseconds
+   */
+  fastTimeUs() {
+    return this.timeProvider.nowUs();
+  }
+  /**
+   * Get fast cached time in milliseconds
+   */
+  fastTimeMs() {
+    return this.timeProvider.nowMs();
+  }
+  /**
+   * Queue a syscall for batching
+   */
+  queueSyscall(syscall) {
+    if (!this.config.enableBatching) {
+      syscall();
+      return;
+    }
+    this.syscallQueue.push(syscall);
+    this.stats.batchedCalls++;
+    if (this.syscallQueue.length >= this.config.maxBatchSize) {
+      this.flushBatch();
+    }
+  }
+  /**
+   * Execute a function with syscall bypass timing
+   */
+  measure(fn) {
+    const start = this.timeProvider.preciseNowNs();
+    const result = fn();
+    const elapsed = this.timeProvider.preciseNowNs() - start;
+    return { result, elapsedNs: elapsed };
+  }
+  /**
+   * Get syscall bypass statistics
+   */
+  getStats() {
+    const bypassRate = this.stats.totalCalls > 0 ? this.stats.bypassedCalls / this.stats.totalCalls : 0;
+    return {
+      ...this.stats,
+      bypassRate
+    };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalCalls: 0,
+      bypassedCalls: 0,
+      batchedCalls: 0,
+      timeSavedNs: BigInt(0)
+    };
+  }
+  startBatching() {
+    this.batchTimer = setInterval(() => {
+      this.flushBatch();
+    }, 1);
+  }
+  flushBatch() {
+    while (this.syscallQueue.length > 0) {
+      const syscall = this.syscallQueue.shift();
+      if (syscall) {
+        try {
+          syscall();
+        } catch (error) {
+          console.error("Batched syscall error:", error);
+        }
+      }
+    }
+  }
+};
+function createSyscallBypassManager(config) {
+  const fullConfig = { ...defaultSyscallBypassConfig(), ...config };
+  return new SyscallBypassManager(fullConfig);
+}
+var globalTimeProvider = null;
+function getGlobalTimeProvider() {
+  if (!globalTimeProvider) {
+    globalTimeProvider = new FastTimeProvider();
+    globalTimeProvider.start();
+  }
+  return globalTimeProvider;
+}
+function fastNowNs() {
+  return getGlobalTimeProvider().nowNs();
+}
+function fastNowUs() {
+  return getGlobalTimeProvider().nowUs();
+}
+function fastNowMs() {
+  return getGlobalTimeProvider().nowMs();
+}
+
+// src/perf/ultra-low-latency.ts
+function defaultUltraLowLatencyConfig() {
+  return {
+    memoryPoolSize: 1024,
+    queueCapacity: 4096,
+    enableBusySpin: true,
+    spinCount: 1e3,
+    enablePrefetch: true,
+    numaAware: false
+  };
+}
+var MemoryPool = class {
+  pool = [];
+  factory;
+  resetFn;
+  maxSize;
+  leased = 0;
+  constructor(factory, resetFn, maxSize = 1024) {
+    this.factory = factory;
+    this.resetFn = resetFn;
+    this.maxSize = maxSize;
+    for (let i = 0; i < maxSize; i++) {
+      this.pool.push(factory());
+    }
+  }
+  /**
+   * Acquire an object from the pool
+   */
+  acquire() {
+    this.leased++;
+    if (this.pool.length > 0) {
+      return this.pool.pop();
+    }
+    return this.factory();
+  }
+  /**
+   * Release an object back to the pool
+   */
+  release(obj) {
+    if (this.leased <= 0) return;
+    this.leased--;
+    if (this.pool.length < this.maxSize) {
+      this.resetFn(obj);
+      this.pool.push(obj);
+    }
+  }
+  /**
+   * Execute a function with a pooled object
+   */
+  with(fn) {
+    const obj = this.acquire();
+    try {
+      return fn(obj);
+    } finally {
+      this.release(obj);
+    }
+  }
+  /**
+   * Get pool statistics
+   */
+  getStats() {
+    return {
+      available: this.pool.length,
+      inUse: this.leased,
+      total: this.pool.length + this.leased
+    };
+  }
+};
+var LockFreeQueue = class {
+  buffer;
+  capacity;
+  mask;
+  head = 0;
+  // Write position
+  tail = 0;
+  // Read position
+  config;
+  constructor(capacity = 4096, config) {
+    this.capacity = Math.pow(2, Math.ceil(Math.log2(capacity)));
+    this.mask = this.capacity - 1;
+    this.buffer = new Array(this.capacity).fill(void 0);
+    this.config = config || defaultUltraLowLatencyConfig();
+  }
+  /**
+   * Enqueue an item (producer only)
+   */
+  enqueue(item) {
+    const nextHead = this.head + 1 & this.mask;
+    if (nextHead === this.tail) {
+      return false;
+    }
+    this.buffer[this.head] = item;
+    this.head = nextHead;
+    return true;
+  }
+  /**
+   * Dequeue an item (consumer only)
+   */
+  dequeue() {
+    if (this.tail === this.head) {
+      return void 0;
+    }
+    const item = this.buffer[this.tail];
+    this.buffer[this.tail] = void 0;
+    this.tail = this.tail + 1 & this.mask;
+    return item;
+  }
+  /**
+   * Try dequeue with spinning
+   */
+  dequeueSpin(timeoutUs = 1e3) {
+    const startTime = performance.now();
+    const timeoutMs = timeoutUs / 1e3;
+    let spins = 0;
+    while (performance.now() - startTime < timeoutMs) {
+      const item = this.dequeue();
+      if (item !== void 0) {
+        return item;
+      }
+      if (this.config.enableBusySpin && spins < this.config.spinCount) {
+        spins++;
+        continue;
+      }
+      spins = 0;
+    }
+    return void 0;
+  }
+  /**
+   * Get current size
+   */
+  size() {
+    return this.head - this.tail & this.mask;
+  }
+  /**
+   * Check if empty
+   */
+  isEmpty() {
+    return this.head === this.tail;
+  }
+  /**
+   * Check if full
+   */
+  isFull() {
+    return (this.head + 1 & this.mask) === this.tail;
+  }
+  /**
+   * Clear the queue
+   */
+  clear() {
+    this.head = 0;
+    this.tail = 0;
+    this.buffer.fill(void 0);
+  }
+};
+var MPMCQueue = class {
+  buffer;
+  capacity;
+  mask;
+  enqueuePos = 0;
+  dequeuePos = 0;
+  constructor(capacity = 4096) {
+    this.capacity = Math.pow(2, Math.ceil(Math.log2(capacity)));
+    this.mask = this.capacity - 1;
+    this.buffer = new Array(this.capacity);
+    for (let i = 0; i < this.capacity; i++) {
+      this.buffer[i] = { item: void 0, sequence: i };
+    }
+  }
+  /**
+   * Enqueue an item (thread-safe)
+   */
+  enqueue(item) {
+    let pos = this.enqueuePos;
+    while (true) {
+      const slot = this.buffer[pos & this.mask];
+      const seq = slot.sequence;
+      const diff = seq - pos;
+      if (diff === 0) {
+        if (this.compareAndSwapEnqueuePos(pos, pos + 1)) {
+          slot.item = item;
+          slot.sequence = pos + 1;
+          return true;
+        }
+        pos = this.enqueuePos;
+      } else if (diff < 0) {
+        return false;
+      } else {
+        pos = this.enqueuePos;
+      }
+    }
+  }
+  /**
+   * Dequeue an item (thread-safe)
+   */
+  dequeue() {
+    let pos = this.dequeuePos;
+    while (true) {
+      const slot = this.buffer[pos & this.mask];
+      const seq = slot.sequence;
+      const diff = seq - (pos + 1);
+      if (diff === 0) {
+        if (this.compareAndSwapDequeuePos(pos, pos + 1)) {
+          const item = slot.item;
+          slot.item = void 0;
+          slot.sequence = pos + this.mask + 1;
+          return item;
+        }
+        pos = this.dequeuePos;
+      } else if (diff < 0) {
+        return void 0;
+      } else {
+        pos = this.dequeuePos;
+      }
+    }
+  }
+  compareAndSwapEnqueuePos(expected, value) {
+    if (this.enqueuePos === expected) {
+      this.enqueuePos = value;
+      return true;
+    }
+    return false;
+  }
+  compareAndSwapDequeuePos(expected, value) {
+    if (this.dequeuePos === expected) {
+      this.dequeuePos = value;
+      return true;
+    }
+    return false;
+  }
+};
+var LatencyOptimizer = class {
+  latencies = [];
+  maxSamples;
+  config;
+  optimizationCallbacks = [];
+  constructor(maxSamples = 1e4, config) {
+    this.maxSamples = maxSamples;
+    this.config = config || defaultUltraLowLatencyConfig();
+  }
+  /**
+   * Record a latency measurement
+   */
+  recordLatency(latencyUs) {
+    this.latencies.push(latencyUs);
+    if (this.latencies.length > this.maxSamples) {
+      this.latencies.shift();
+    }
+  }
+  /**
+   * Measure and record function execution time
+   */
+  measure(fn) {
+    const start = performance.now();
+    const result = fn();
+    const latencyUs = (performance.now() - start) * 1e3;
+    this.recordLatency(latencyUs);
+    return { result, latencyUs };
+  }
+  /**
+   * Get latency statistics
+   */
+  getStats() {
+    if (this.latencies.length === 0) {
+      return {
+        minLatencyUs: 0,
+        maxLatencyUs: 0,
+        avgLatencyUs: 0,
+        p50LatencyUs: 0,
+        p99LatencyUs: 0,
+        p999LatencyUs: 0,
+        totalOperations: 0
+      };
+    }
+    const sorted = [...this.latencies].sort((a, b) => a - b);
+    const n = sorted.length;
+    return {
+      minLatencyUs: sorted[0] ?? 0,
+      maxLatencyUs: sorted[n - 1] ?? 0,
+      avgLatencyUs: sorted.reduce((a, b) => a + b, 0) / n,
+      p50LatencyUs: sorted[Math.floor(n * 0.5)] ?? 0,
+      p99LatencyUs: sorted[Math.floor(n * 0.99)] ?? 0,
+      p999LatencyUs: sorted[Math.floor(n * 0.999)] ?? 0,
+      totalOperations: n
+    };
+  }
+  /**
+   * Register an optimization callback
+   */
+  onOptimization(callback) {
+    this.optimizationCallbacks.push(callback);
+  }
+  /**
+   * Trigger optimization
+   */
+  optimize() {
+    for (const callback of this.optimizationCallbacks) {
+      try {
+        callback();
+      } catch (error) {
+        console.error("Optimization callback error:", error);
+      }
+    }
+  }
+  /**
+   * Reset statistics
+   */
+  reset() {
+    this.latencies = [];
+  }
+};
+function prefetch(obj) {
+  if (obj && typeof obj === "object") {
+    const key = Object.keys(obj)[0];
+    const _ = key === void 0 ? void 0 : obj[key];
+  }
+}
+function prefetchArray(arr, index) {
+  const _ = arr[index];
+}
+function createMemoryPool(factory, resetFn, size) {
+  return new MemoryPool(factory, resetFn, size || defaultUltraLowLatencyConfig().memoryPoolSize);
+}
+function createLockFreeQueue(capacity) {
+  return new LockFreeQueue(capacity);
+}
+function createMPMCQueue(capacity) {
+  return new MPMCQueue(capacity);
+}
+function busySpin(iterations) {
+  for (let i = 0; i < iterations; i++) {
+    Math.random();
+  }
+}
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+// src/perf/zero-copy.ts
+function defaultBufferPoolConfig() {
+  return {
+    bufferSize: 4096,
+    poolSize: 128,
+    autoExpand: true,
+    maxPoolSize: 1024
+  };
+}
+var ZeroCopyBuffer = class _ZeroCopyBuffer {
+  buffer;
+  view;
+  uint8View;
+  offset = 0;
+  constructor(size = 4096) {
+    this.buffer = new ArrayBuffer(size);
+    this.view = new DataView(this.buffer);
+    this.uint8View = new Uint8Array(this.buffer);
+  }
+  /**
+   * Create from existing buffer (zero-copy)
+   */
+  static from(buffer) {
+    const zc = new _ZeroCopyBuffer(0);
+    zc.buffer = buffer;
+    zc.view = new DataView(buffer);
+    zc.uint8View = new Uint8Array(buffer);
+    return zc;
+  }
+  /**
+   * Create a view into this buffer without copying
+   */
+  slice(start, end) {
+    return new Uint8Array(this.buffer, start, end - start);
+  }
+  /**
+   * Get current write offset
+   */
+  getOffset() {
+    return this.offset;
+  }
+  /**
+   * Set write offset
+   */
+  setOffset(offset) {
+    this.offset = offset;
+  }
+  /**
+   * Get buffer capacity
+   */
+  capacity() {
+    return this.buffer.byteLength;
+  }
+  /**
+   * Write Uint8 at current offset
+   */
+  writeUint8(value) {
+    this.view.setUint8(this.offset, value);
+    this.offset += 1;
+  }
+  /**
+   * Write Uint16 at current offset (little-endian)
+   */
+  writeUint16(value) {
+    this.view.setUint16(this.offset, value, true);
+    this.offset += 2;
+  }
+  /**
+   * Write Uint32 at current offset (little-endian)
+   */
+  writeUint32(value) {
+    this.view.setUint32(this.offset, value, true);
+    this.offset += 4;
+  }
+  /**
+   * Write BigUint64 at current offset (little-endian)
+   */
+  writeUint64(value) {
+    this.view.setBigUint64(this.offset, value, true);
+    this.offset += 8;
+  }
+  /**
+   * Write bytes at current offset
+   */
+  writeBytes(bytes) {
+    this.uint8View.set(bytes, this.offset);
+    this.offset += bytes.length;
+  }
+  /**
+   * Read Uint8 at offset
+   */
+  readUint8(offset) {
+    return this.view.getUint8(offset);
+  }
+  /**
+   * Read Uint16 at offset (little-endian)
+   */
+  readUint16(offset) {
+    return this.view.getUint16(offset, true);
+  }
+  /**
+   * Read Uint32 at offset (little-endian)
+   */
+  readUint32(offset) {
+    return this.view.getUint32(offset, true);
+  }
+  /**
+   * Read BigUint64 at offset (little-endian)
+   */
+  readUint64(offset) {
+    return this.view.getBigUint64(offset, true);
+  }
+  /**
+   * Read bytes at offset
+   */
+  readBytes(offset, length) {
+    return new Uint8Array(this.buffer, offset, length);
+  }
+  /**
+   * Get the underlying ArrayBuffer
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+  /**
+   * Get as Uint8Array (full buffer)
+   */
+  asUint8Array() {
+    return this.uint8View;
+  }
+  /**
+   * Get used portion as Uint8Array (zero-copy view)
+   */
+  asUsedUint8Array() {
+    return new Uint8Array(this.buffer, 0, this.offset);
+  }
+  /**
+   * Reset offset to beginning
+   */
+  reset() {
+    this.offset = 0;
+  }
+  /**
+   * Ensure capacity (creates new buffer if needed, copies data)
+   */
+  ensureCapacity(minCapacity) {
+    if (this.buffer.byteLength >= minCapacity) {
+      return;
+    }
+    const newCapacity = Math.max(minCapacity, this.buffer.byteLength * 2);
+    const newBuffer = new ArrayBuffer(newCapacity);
+    const newUint8 = new Uint8Array(newBuffer);
+    newUint8.set(this.uint8View);
+    this.buffer = newBuffer;
+    this.view = new DataView(newBuffer);
+    this.uint8View = newUint8;
+  }
+};
+var BufferPool = class {
+  pool = [];
+  inUse = /* @__PURE__ */ new Set();
+  config;
+  constructor(config = defaultBufferPoolConfig()) {
+    this.config = config;
+    for (let i = 0; i < config.poolSize; i++) {
+      this.pool.push(new ArrayBuffer(config.bufferSize));
+    }
+  }
+  /**
+   * Acquire a buffer from the pool
+   */
+  acquire() {
+    if (this.pool.length > 0) {
+      const buffer = this.pool.pop();
+      this.inUse.add(buffer);
+      return buffer;
+    }
+    if (this.config.autoExpand && this.pool.length + this.inUse.size < this.config.maxPoolSize) {
+      const buffer = new ArrayBuffer(this.config.bufferSize);
+      this.inUse.add(buffer);
+      return buffer;
+    }
+    throw new Error("Buffer pool exhausted");
+  }
+  /**
+   * Acquire a ZeroCopyBuffer wrapper
+   */
+  acquireZeroCopyBuffer() {
+    const buffer = this.acquire();
+    return ZeroCopyBuffer.from(buffer);
+  }
+  /**
+   * Release a buffer back to the pool
+   */
+  release(buffer) {
+    if (!this.inUse.has(buffer)) {
+      return;
+    }
+    this.inUse.delete(buffer);
+    if (this.pool.length < this.config.maxPoolSize) {
+      this.pool.push(buffer);
+    }
+  }
+  /**
+   * Execute a function with a pooled buffer
+   */
+  with(fn) {
+    const buffer = this.acquire();
+    try {
+      return fn(buffer);
+    } finally {
+      this.release(buffer);
+    }
+  }
+  /**
+   * Get pool statistics
+   */
+  getStats() {
+    return {
+      available: this.pool.length,
+      inUse: this.inUse.size,
+      total: this.pool.length + this.inUse.size
+    };
+  }
+  /**
+   * Clear all buffers
+   */
+  clear() {
+    this.pool = [];
+    this.inUse.clear();
+  }
+};
+var ZeroCopySerializer = class {
+  buffer;
+  textEncoder;
+  textDecoder;
+  constructor(initialSize = 4096) {
+    this.buffer = new ZeroCopyBuffer(initialSize);
+    this.textEncoder = new TextEncoder();
+    this.textDecoder = new TextDecoder();
+  }
+  /**
+   * Serialize a string (length-prefixed)
+   */
+  writeString(value) {
+    const bytes = this.textEncoder.encode(value);
+    this.buffer.writeUint32(bytes.length);
+    this.buffer.writeBytes(bytes);
+  }
+  /**
+   * Serialize a PublicKey (32 bytes)
+   */
+  writePublicKey(bytes) {
+    if (bytes.length !== 32) {
+      throw new Error("PublicKey must be 32 bytes");
+    }
+    this.buffer.writeBytes(bytes);
+  }
+  /**
+   * Serialize a BigInt (8 bytes)
+   */
+  writeBigInt(value) {
+    this.buffer.writeUint64(value);
+  }
+  /**
+   * Serialize a number (4 bytes)
+   */
+  writeNumber(value) {
+    this.buffer.writeUint32(value);
+  }
+  /**
+   * Serialize a boolean (1 byte)
+   */
+  writeBoolean(value) {
+    this.buffer.writeUint8(value ? 1 : 0);
+  }
+  /**
+   * Serialize bytes with length prefix
+   */
+  writeByteArray(bytes) {
+    this.buffer.writeUint32(bytes.length);
+    this.buffer.writeBytes(bytes);
+  }
+  /**
+   * Deserialize a string
+   */
+  readString(offset) {
+    const length = this.buffer.readUint32(offset);
+    const bytes = this.buffer.readBytes(offset + 4, length);
+    const value = this.textDecoder.decode(bytes);
+    return { value, nextOffset: offset + 4 + length };
+  }
+  /**
+   * Deserialize a PublicKey
+   */
+  readPublicKey(offset) {
+    const value = this.buffer.readBytes(offset, 32);
+    return { value, nextOffset: offset + 32 };
+  }
+  /**
+   * Deserialize a BigInt
+   */
+  readBigInt(offset) {
+    const value = this.buffer.readUint64(offset);
+    return { value, nextOffset: offset + 8 };
+  }
+  /**
+   * Deserialize a number
+   */
+  readNumber(offset) {
+    const value = this.buffer.readUint32(offset);
+    return { value, nextOffset: offset + 4 };
+  }
+  /**
+   * Deserialize a boolean
+   */
+  readBoolean(offset) {
+    const value = this.buffer.readUint8(offset) !== 0;
+    return { value, nextOffset: offset + 1 };
+  }
+  /**
+   * Deserialize a byte array
+   */
+  readByteArray(offset) {
+    const length = this.buffer.readUint32(offset);
+    const value = this.buffer.readBytes(offset + 4, length);
+    return { value, nextOffset: offset + 4 + length };
+  }
+  /**
+   * Get serialized data as Uint8Array (zero-copy view)
+   */
+  getData() {
+    return this.buffer.asUsedUint8Array();
+  }
+  /**
+   * Reset for reuse
+   */
+  reset() {
+    this.buffer.reset();
+  }
+  /**
+   * Get current offset
+   */
+  getOffset() {
+    return this.buffer.getOffset();
+  }
+};
+var FixedBufferView = class {
+  buffer;
+  view;
+  uint8View;
+  baseOffset;
+  constructor(buffer, offset, size) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer, offset, size);
+    this.uint8View = new Uint8Array(buffer, offset, size);
+    this.baseOffset = offset;
+  }
+  /**
+   * Get Uint8 at relative offset
+   */
+  getUint8(offset) {
+    return this.view.getUint8(offset);
+  }
+  /**
+   * Set Uint8 at relative offset
+   */
+  setUint8(offset, value) {
+    this.view.setUint8(offset, value);
+  }
+  /**
+   * Get Uint32 at relative offset
+   */
+  getUint32(offset) {
+    return this.view.getUint32(offset, true);
+  }
+  /**
+   * Set Uint32 at relative offset
+   */
+  setUint32(offset, value) {
+    this.view.setUint32(offset, value, true);
+  }
+  /**
+   * Get BigUint64 at relative offset
+   */
+  getUint64(offset) {
+    return this.view.getBigUint64(offset, true);
+  }
+  /**
+   * Set BigUint64 at relative offset
+   */
+  setUint64(offset, value) {
+    this.view.setBigUint64(offset, value, true);
+  }
+  /**
+   * Get bytes at relative offset
+   */
+  getBytes(offset, length) {
+    return new Uint8Array(this.buffer, this.baseOffset + offset, length);
+  }
+  /**
+   * Set bytes at relative offset
+   */
+  setBytes(offset, bytes) {
+    this.uint8View.set(bytes, offset);
+  }
+  /**
+   * Get the underlying ArrayBuffer
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+  /**
+   * Get the base offset
+   */
+  getBaseOffset() {
+    return this.baseOffset;
+  }
+};
+function createBufferPool(config) {
+  const fullConfig = { ...defaultBufferPoolConfig(), ...config };
+  return new BufferPool(fullConfig);
+}
+function createZeroCopyBuffer(size) {
+  return new ZeroCopyBuffer(size);
+}
+function createSerializer(initialSize) {
+  return new ZeroCopySerializer(initialSize);
+}
+function copyBytes(src, dst, dstOffset = 0) {
+  dst.set(src, dstOffset);
+}
+function createView(buffer, offset, length) {
+  return new Uint8Array(buffer, offset, length);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlignedBuffer,
+  AsyncSocket,
+  BranchOptimizer,
+  BufferPool,
+  CACHE_LINE_SIZE,
+  CPUAffinity,
+  CacheOptimizer,
+  ComputeBudgetOptimizer,
+  CryptoSIMD,
+  DirectIOFile,
+  FastTimeProvider,
+  FixedBufferView,
+  Float32x4,
+  FuncCache,
+  HardwareMonitor,
+  IOBatchProcessor,
+  IOOperation,
+  InstructionBatcher,
+  KernelBypassManager,
+  LatencyMonitor,
+  LatencyOptimizer,
+  LockFreeQueue,
+  LoopOptimizer,
+  MPMCQueue,
+  MemoryMappedFile,
+  MemoryOps,
+  MemoryPool,
+  NUMAOptimizer,
+  OptimizedMath,
+  PerformanceGovernor,
+  ProfileGuidedOptimizer,
+  RealtimeTuner,
+  SIMDDetector,
+  SchedulerPolicy,
+  SpinLock,
+  SyscallBypassManager,
+  ThreadPriority,
+  ThreadPriorityLevel,
+  TransactionBuilder,
+  TransactionOptimizer,
+  VectorizedMath,
+  ZeroCopyBuffer,
+  ZeroCopySerializer,
+  busySpin,
+  busyWait,
+  calculateOptimalPrice,
+  coldPath,
+  copyBytes,
+  createBufferPool,
+  createCPUAffinity,
+  createCacheOptimizer,
+  createComputeBudgetOptimizer,
+  createCryptoSIMD,
+  createHardwareMonitor,
+  createInstructionBatcher,
+  createLatencyMonitor,
+  createLockFreeQueue,
+  createMPMCQueue,
+  createMemoryPool,
+  createNUMAOptimizer,
+  createPerformanceGovernor,
+  createRealtimeTuner,
+  createSIMDDetector,
+  createSerializer,
+  createSyscallBypassManager,
+  createThreadPriority,
+  createTimer,
+  createTransactionBuilder,
+  createTransactionOptimizer,
+  createVectorizedMath,
+  createView,
+  createZeroCopyBuffer,
+  defaultAffinityConfig,
+  defaultBufferPoolConfig,
+  defaultIOUringConfig,
+  defaultJITConfig,
+  defaultNUMAConfig,
+  defaultRealtimeConfig,
+  defaultSIMDConfig,
+  defaultSyscallBypassConfig,
+  defaultTransactionConfig,
+  defaultUltraLowLatencyConfig,
+  detectCPUFeatures,
+  estimateCompute,
+  fastInvSqrt,
+  fastNowMs,
+  fastNowNs,
+  fastNowUs,
+  getGlobalTimeProvider,
+  getKernelBypassManager,
+  getOptimalSIMDWidth,
+  getProfileOptimizer,
+  getSystemCPUInfo,
+  getSystemMemoryInfo,
+  hotPath,
+  isSIMDAvailable,
+  likely,
+  measureTime,
+  prefetch,
+  prefetchArray,
+  prefetchHint,
+  profile,
+  spinLock,
+  unlikely,
+  yieldToEventLoop
+});