sol-trade-sdk 0.1.0

package/dist/index-1BK_FXsW.d.mts

@@ -0,0 +1,2327 @@
+import { TransactionInstruction } from '@solana/web3.js';
+
+/**
+ * Compiler-level optimizations for TypeScript/JavaScript code.
+ * Provides JIT compilation hints, optimization patterns, and
+ * performance-critical code paths.
+ */
+/**
+ * Configuration for JIT-like optimizations
+ */
+interface JITConfig {
+    enabled: boolean;
+    cacheSize: number;
+    optimizationLevel: 'O0' | 'O1' | 'O2' | 'O3';
+    inlineThreshold: number;
+    loopVectorize: boolean;
+    slpVectorize: boolean;
+}
+/**
+ * Default JIT configuration
+ */
+declare function defaultJITConfig(): JITConfig;
+/**
+ * Branch prediction optimization hints
+ */
+declare class BranchOptimizer {
+    /**
+     * Hint that the condition is likely true
+     * Use this to guide branch prediction in hot paths
+     */
+    static likely(condition: boolean): boolean;
+    /**
+     * Hint that the condition is likely false
+     * Use this to guide branch prediction in error handling paths
+     */
+    static unlikely(condition: boolean): boolean;
+}
+/**
+ * Hint that the condition is likely true
+ */
+declare function likely(condition: boolean): boolean;
+/**
+ * Hint that the condition is likely false
+ */
+declare function unlikely(condition: boolean): boolean;
+/**
+ * Loop optimization utilities
+ */
+declare class LoopOptimizer {
+    /**
+     * Hint that a loop should be unrolled
+     */
+    static unrollHint(factor: number): number;
+    /**
+     * Hint that a loop should be vectorized
+     */
+    static vectorizeHint(): void;
+    /**
+     * Hint that a loop should be parallelized
+     */
+    static parallelHint(): void;
+}
+/**
+ * Cache line size (typical for modern CPUs)
+ */
+declare const CACHE_LINE_SIZE = 64;
+/**
+ * Cache-aligned buffer
+ */
+declare class AlignedBuffer {
+    private data;
+    private offset;
+    constructor(size: number, align?: number);
+    /**
+     * Get the aligned buffer
+     */
+    get buffer(): Buffer;
+    /**
+     * Get the underlying buffer
+     */
+    get underlying(): Buffer;
+}
+/**
+ * Prefetch hint - documents intent for prefetching
+ */
+declare function prefetchHint(address: number): void;
+/**
+ * Profile-guided optimization utilities
+ */
+declare class ProfileGuidedOptimizer {
+    private profileData;
+    private callCounts;
+    /**
+     * Instrument a function for profiling
+     */
+    instrument<T extends (...args: any[]) => any>(name: string, fn: T): T;
+    /**
+     * Get the most frequently called functions
+     */
+    getHotFunctions(topN?: number): Array<{
+        name: string;
+        count: number;
+    }>;
+    /**
+     * Get functions with highest average execution time
+     */
+    getSlowFunctions(topN?: number): Array<{
+        name: string;
+        avgTime: number;
+    }>;
+}
+/**
+ * Optimized mathematical operations
+ */
+declare class OptimizedMath {
+    /**
+     * Fast exponential approximation
+     */
+    static fastExp(x: number): number;
+    /**
+     * Fast logarithm
+     */
+    static fastLog(x: number): number;
+    /**
+     * Fast square root
+     */
+    static fastSqrt(x: number): number;
+    /**
+     * Fast inverse square root (Quake III algorithm)
+     */
+    static fastInvSqrt(x: number): number;
+    /**
+     * Fast power
+     */
+    static fastPow(base: number, exp: number): number;
+    /**
+     * Fast absolute value for integers
+     */
+    static fastAbs(x: number): number;
+}
+/**
+ * Fast inverse square root
+ */
+declare function fastInvSqrt(x: number): number;
+/**
+ * Cache for expensive function results
+ */
+declare class FuncCache<T> {
+    private cache;
+    private hits;
+    private misses;
+    private maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Get a cached value
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set a cached value
+     */
+    set(key: string, value: T): void;
+    /**
+     * Get cache statistics
+     */
+    stats(): {
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+    /**
+     * Clear the cache
+     */
+    clear(): void;
+}
+/**
+ * Simple spin lock for very short critical sections
+ * Note: In JavaScript, this is not truly blocking, but uses busy waiting
+ */
+declare class SpinLock {
+    private locked;
+    /**
+     * Acquire the lock
+     */
+    lock(): Promise<void>;
+    /**
+     * Release the lock
+     */
+    unlock(): void;
+    /**
+     * Try to acquire the lock without blocking
+     */
+    tryLock(): boolean;
+}
+/**
+ * Mark a function as a hot path (frequently executed)
+ * This is a no-op but documents intent for optimization
+ */
+declare function hotPath(): void;
+/**
+ * Mark a function as a cold path (rarely executed)
+ * This is a no-op but documents intent for optimization
+ */
+declare function coldPath(): void;
+/**
+ * Optimized memory operations
+ */
+declare class MemoryOps {
+    /**
+     * Copy memory with potential SIMD optimization
+     */
+    static memCopy(dst: Uint8Array, src: Uint8Array): number;
+    /**
+     * Set memory with potential SIMD optimization
+     */
+    static memSet(dst: Uint8Array, value: number): void;
+    /**
+     * Zero memory
+     */
+    static memZero(dst: Uint8Array): void;
+}
+/**
+ * CPU features
+ */
+interface CPUFeatures {
+    hasSIMD: boolean;
+    hasAVX: boolean;
+    hasAVX2: boolean;
+    hasSSE: boolean;
+    hasSSE2: boolean;
+    hasSSE3: boolean;
+    hasSSE41: boolean;
+    hasSSE42: boolean;
+    hasFMA: boolean;
+    hasBMI: boolean;
+    hasBMI2: boolean;
+    hasPopcnt: boolean;
+    cacheLine: number;
+    numCPU: number;
+}
+/**
+ * Detect CPU features
+ * Note: In JavaScript, most CPU features are not directly accessible
+ */
+declare function detectCPUFeatures(): CPUFeatures;
+/**
+ * Get or create global profile optimizer
+ */
+declare function getProfileOptimizer(): ProfileGuidedOptimizer;
+/**
+ * Profile decorator using global profile optimizer
+ */
+declare function profile(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+
+/**
+ * Hardware Optimization Module for Sol Trade SDK
+ * Provides CPU affinity, NUMA optimization, and cache optimizations.
+ */
+/**
+ * CPU topology information
+ */
+interface CPUTopology {
+    physicalCores: number;
+    logicalCores: number;
+    numaNodes: number;
+    cacheLevels: CacheInfo[];
+}
+/**
+ * Cache information
+ */
+interface CacheInfo {
+    level: number;
+    size: number;
+    lineSize: number;
+    associativity: number;
+}
+/**
+ * CPU affinity configuration
+ */
+interface AffinityConfig {
+    /** Enable CPU pinning */
+    enablePinning: boolean;
+    /** Preferred CPU cores */
+    preferredCores: number[];
+    /** Avoid hyperthreading pairs */
+    avoidSMT: boolean;
+    /** NUMA node preference */
+    numaNode: number;
+}
+/**
+ * Default affinity configuration
+ */
+declare function defaultAffinityConfig(): AffinityConfig;
+/**
+ * NUMA configuration
+ */
+interface NUMAConfig {
+    /** Enable NUMA-aware allocation */
+    enableNUMA: boolean;
+    /** Preferred NUMA node */
+    preferredNode: number;
+    /** Interleave memory across nodes */
+    interleave: boolean;
+}
+/**
+ * Default NUMA configuration
+ */
+declare function defaultNUMAConfig(): NUMAConfig;
+/**
+ * CPU affinity manager for pinning threads to specific cores.
+ * Reduces context switches and improves cache locality.
+ */
+declare class CPUAffinity {
+    private config;
+    private pinnedCores;
+    constructor(config?: AffinityConfig);
+    /**
+     * Get CPU topology information
+     */
+    getTopology(): CPUTopology;
+    /**
+     * Pin current execution context to a specific core
+     * Note: In Node.js, this is advisory only via worker threads
+     */
+    pinToCore(coreId: number): boolean;
+    /**
+     * Pin to multiple cores
+     */
+    pinToCores(coreIds: number[]): boolean;
+    /**
+     * Get recommended cores for pinning
+     */
+    getRecommendedCores(count?: number): number[];
+    /**
+     * Check if a core is available
+     */
+    isCoreAvailable(coreId: number): boolean;
+    /**
+     * Get current core (simulated)
+     */
+    getCurrentCore(): number;
+    /**
+     * Get pinned cores
+     */
+    getPinnedCores(): number[];
+    /**
+     * Unpin all cores
+     */
+    unpinAll(): void;
+}
+/**
+ * NUMA (Non-Uniform Memory Access) optimizer.
+ * Optimizes memory allocation for NUMA architectures.
+ */
+declare class NUMAOptimizer {
+    private config;
+    private allocations;
+    constructor(config?: NUMAConfig);
+    /**
+     * Allocate memory with NUMA awareness
+     */
+    allocate(size: number, tag?: string): ArrayBuffer;
+    /**
+     * Allocate typed array with NUMA awareness
+     */
+    allocateTypedArray<T extends TypedArray>(constructor: TypedArrayConstructor<T>, length: number, tag?: string): T;
+    /**
+     * Get allocation information
+     */
+    getAllocation(tag: string): NUMAAllocation | undefined;
+    /**
+     * Get local memory node for current thread
+     */
+    getLocalNode(): number;
+    /**
+     * Get number of NUMA nodes
+     */
+    getNodeCount(): number;
+    /**
+     * Check if NUMA is available
+     */
+    isNUMAAvailable(): boolean;
+    /**
+     * Migrate allocation to preferred node
+     * Note: No-op in JavaScript
+     */
+    migrateToNode(tag: string, node: number): boolean;
+    /**
+     * Free allocation tracking
+     */
+    free(tag: string): void;
+    /**
+     * Get all allocations
+     */
+    getAllAllocations(): Map<string, NUMAAllocation>;
+}
+/**
+ * NUMA allocation tracking
+ */
+interface NUMAAllocation {
+    buffer: ArrayBuffer;
+    size: number;
+    node: number;
+    timestamp: number;
+}
+/**
+ * Typed array types
+ */
+type TypedArray = Uint8Array | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array;
+interface TypedArrayConstructor<T> {
+    new (buffer: ArrayBuffer): T;
+    BYTES_PER_ELEMENT: number;
+}
+/**
+ * Cache optimization utilities.
+ * Provides cache-friendly data structure layouts and prefetching hints.
+ */
+declare class CacheOptimizer {
+    private cacheLineSize;
+    private l1Size;
+    private l2Size;
+    private l3Size;
+    constructor();
+    /**
+     * Set cache parameters
+     */
+    setCacheParams(params: {
+        cacheLineSize?: number;
+        l1Size?: number;
+        l2Size?: number;
+        l3Size?: number;
+    }): void;
+    /**
+     * Align size to cache line boundary
+     */
+    alignToCacheLine(size: number): number;
+    /**
+     * Check if address is cache line aligned
+     */
+    isCacheLineAligned(address: number): boolean;
+    /**
+     * Calculate cache-friendly array stride
+     */
+    calculateStride(elementSize: number): number;
+    /**
+     * Create cache-friendly layout for array of objects
+     */
+    createSoALayout<T extends Record<string, number | bigint>>(count: number, schema: Record<keyof T, 'u8' | 'u16' | 'u32' | 'u64' | 'f32' | 'f64'>): StructureOfArrays<T>;
+    /**
+     * Get cache line size
+     */
+    getCacheLineSize(): number;
+    /**
+     * Get L1 cache size
+     */
+    getL1Size(): number;
+    /**
+     * Get L2 cache size
+     */
+    getL2Size(): number;
+    /**
+     * Get L3 cache size
+     */
+    getL3Size(): number;
+}
+/**
+ * Structure of Arrays layout
+ */
+interface StructureOfArrays<T> {
+    arrays: Record<keyof T, TypedArray>;
+    offsets: Record<keyof T, number>;
+    count: number;
+    get(index: number): T;
+    set(index: number, value: T): void;
+}
+/**
+ * Hardware performance monitoring
+ */
+declare class HardwareMonitor {
+    private startTime;
+    private measurements;
+    /**
+     * Start monitoring
+     */
+    start(): void;
+    /**
+     * Take a measurement
+     */
+    measure(label: string): void;
+    /**
+     * Get memory information
+     */
+    getMemoryInfo(): MemoryInfo;
+    /**
+     * Get all measurements
+     */
+    getMeasurements(): HardwareMeasurement[];
+    /**
+     * Reset measurements
+     */
+    reset(): void;
+}
+/**
+ * Memory information
+ */
+interface MemoryInfo {
+    used: number;
+    total: number;
+    external: number;
+    rss: number;
+}
+/**
+ * Hardware measurement
+ */
+interface HardwareMeasurement {
+    label: string;
+    timestamp: number;
+    memory: MemoryInfo;
+}
+/**
+ * Create a CPU affinity manager
+ */
+declare function createCPUAffinity(config?: Partial<AffinityConfig>): CPUAffinity;
+/**
+ * Create a NUMA optimizer
+ */
+declare function createNUMAOptimizer(config?: Partial<NUMAConfig>): NUMAOptimizer;
+/**
+ * Create a cache optimizer
+ */
+declare function createCacheOptimizer(): CacheOptimizer;
+/**
+ * Create a hardware monitor
+ */
+declare function createHardwareMonitor(): HardwareMonitor;
+/**
+ * Get system CPU information
+ */
+declare function getSystemCPUInfo(): {
+    cores: number;
+    model: string;
+};
+/**
+ * Get system memory information
+ */
+declare function getSystemMemoryInfo(): {
+    total: number;
+    free: number;
+};
+
+/**
+ * Kernel bypass optimizations for ultra-low latency I/O.
+ * Provides io_uring-like support for async I/O without kernel copies,
+ * along with fallback implementations for different platforms.
+ */
+/**
+ * I/O operation types
+ */
+declare enum IOOperation {
+    READ = "READ",
+    WRITE = "WRITE",
+    FSYNC = "FSYNC",
+    POLL = "POLL",
+    TIMEOUT = "TIMEOUT"
+}
+/**
+ * I/O request for kernel bypass operations
+ */
+interface IORequest {
+    op: IOOperation;
+    fd: number;
+    buffer?: Buffer;
+    offset: number;
+    size: number;
+    callback?: (id: number, data: Buffer | null, bytesTransferred: number) => void;
+    userData?: unknown;
+}
+/**
+ * I/O result
+ */
+interface IOResult {
+    requestId: number;
+    bytesTransferred: number;
+    buffer?: Buffer;
+    error?: Error;
+    userData?: unknown;
+}
+/**
+ * io_uring configuration
+ */
+interface IOUringConfig {
+    queueDepth: number;
+    sqThreadIdle: number;
+    sqThreadCpu: number;
+    cqSize: number;
+    flags: number;
+    features: string[];
+}
+/**
+ * Default io_uring configuration
+ */
+declare function defaultIOUringConfig(): IOUringConfig;
+/**
+ * Manager for kernel bypass I/O operations.
+ * Uses optimized async I/O when available, falls back to standard async I/O.
+ */
+declare class KernelBypassManager {
+    private config;
+    private uringAvailable;
+    private requestCounter;
+    private pendingRequests;
+    private running;
+    private processTimer;
+    constructor(config?: IOUringConfig);
+    /**
+     * Check if io_uring-like functionality is available
+     */
+    private checkUringAvailability;
+    /**
+     * Check if io_uring is available
+     */
+    isUringAvailable(): boolean;
+    /**
+     * Start the I/O processing loop
+     */
+    start(): void;
+    /**
+     * Stop the I/O processing loop
+     */
+    stop(): void;
+    /**
+     * Main processing loop
+     */
+    private processLoop;
+    /**
+     * Process pending I/O requests
+     */
+    private processPendingRequests;
+    /**
+     * Process a read request
+     */
+    private processRead;
+    /**
+     * Process a write request
+     */
+    private processWrite;
+    /**
+     * Submit an async read request
+     */
+    submitRead(fd: number, size: number, offset?: number, callback?: (id: number, data: Buffer | null, bytesTransferred: number) => void, userData?: unknown): number;
+    /**
+     * Submit an async write request
+     */
+    submitWrite(fd: number, buffer: Buffer, offset?: number, callback?: (id: number, data: Buffer | null, bytesTransferred: number) => void, userData?: unknown): number;
+}
+/**
+ * File with direct I/O support (bypassing page cache)
+ */
+declare class DirectIOFile {
+    private path;
+    private fd;
+    private directIO;
+    constructor(path: string);
+    /**
+     * Open file with direct I/O if available
+     */
+    open(): Promise<boolean>;
+    /**
+     * Close the file
+     */
+    close(): Promise<void>;
+    /**
+     * Read from file
+     */
+    read(size: number, offset?: number): Promise<Buffer>;
+    /**
+     * Read using direct I/O with aligned buffer
+     */
+    private readDirect;
+    /**
+     * Write to file
+     */
+    write(data: Buffer, offset?: number): Promise<number>;
+    /**
+     * Sync file to disk
+     */
+    fsync(): Promise<void>;
+}
+/**
+ * Memory-mapped file for zero-copy access
+ */
+declare class MemoryMappedFile {
+    private path;
+    private fd;
+    private buffer;
+    constructor(path: string);
+    /**
+     * Open and memory-map the file
+     */
+    open(size?: number): Promise<boolean>;
+    /**
+     * Close the memory-mapped file
+     */
+    close(): Promise<void>;
+    /**
+     * Read from memory-mapped file
+     */
+    read(offset: number, size: number): Buffer;
+    /**
+     * Write to memory-mapped file
+     */
+    write(offset: number, data: Buffer): void;
+    /**
+     * Flush changes to disk
+     */
+    flush(): Promise<void>;
+}
+/**
+ * Async socket with kernel bypass optimizations
+ */
+declare class AsyncSocket {
+    private socket;
+    /**
+     * Set the underlying socket
+     */
+    setSocket(socket: any): void;
+    /**
+     * Enable kernel bypass optimizations for this socket
+     */
+    enableKernelBypass(): boolean;
+    /**
+     * Async receive with optimization
+     */
+    recv(size: number): Promise<Buffer>;
+    /**
+     * Async send with optimization
+     */
+    send(data: Buffer): Promise<void>;
+}
+/**
+ * Batch processor for I/O operations with kernel bypass
+ */
+declare class IOBatchProcessor {
+    private maxBatchSize;
+    private readBatch;
+    private writeBatch;
+    private manager;
+    constructor(maxBatchSize?: number);
+    /**
+     * Add read to batch
+     */
+    addRead(fd: number, size: number, offset?: number, callback?: (id: number, data: Buffer | null, bytesTransferred: number) => void): void;
+    /**
+     * Add write to batch
+     */
+    addWrite(fd: number, data: Buffer, offset?: number, callback?: (id: number, data: Buffer | null, bytesTransferred: number) => void): void;
+    /**
+     * Flush all pending reads
+     */
+    flushReads(): number[];
+    /**
+     * Flush all pending writes
+     */
+    flushWrites(): number[];
+    /**
+     * Flush all pending operations
+     */
+    flushAll(): {
+        readIds: number[];
+        writeIds: number[];
+    };
+}
+/**
+ * Get or create global kernel bypass manager
+ */
+declare function getKernelBypassManager(config?: IOUringConfig): KernelBypassManager;
+
+/**
+ * Protocol Optimization Module for Sol Trade SDK
+ * Provides transaction optimization, compute budget management, and builder patterns.
+ */
+
+/**
+ * Transaction configuration
+ */
+interface TransactionConfig {
+    /** Compute unit limit */
+    computeUnitLimit: number;
+    /** Compute unit price (micro-lamports) */
+    computeUnitPrice: number;
+    /** Priority fee in lamports */
+    priorityFee: number;
+    /** Enable dynamic compute budget */
+    dynamicComputeBudget: boolean;
+    /** Enable instruction packing */
+    packInstructions: boolean;
+    /** Maximum transaction size */
+    maxTransactionSize: number;
+    /** Enable address lookup tables */
+    useAddressLookupTables: boolean;
+}
+/**
+ * Default transaction configuration
+ */
+declare function defaultTransactionConfig(): TransactionConfig;
+/**
+ * Compute budget statistics
+ */
+interface ComputeBudgetStats {
+    totalComputeUsed: number;
+    totalComputeLimit: number;
+    averageComputePerInstruction: number;
+    estimatedFee: number;
+    efficiency: number;
+}
+/**
+ * Instruction group for batching
+ */
+interface InstructionGroup {
+    instructions: TransactionInstruction[];
+    computeEstimate: number;
+    priority: number;
+}
+/**
+ * Transaction optimization result
+ */
+interface OptimizationResult {
+    instructions: TransactionInstruction[];
+    computeLimit: number;
+    computePrice: number;
+    estimatedSize: number;
+    optimizations: string[];
+}
+/**
+ * High-performance transaction builder with optimization.
+ * Constructs optimized Solana transactions for trading.
+ */
+declare class TransactionBuilder {
+    private instructions;
+    private config;
+    private computeEstimates;
+    private signers;
+    constructor(config?: TransactionConfig);
+    /**
+     * Initialize default compute estimates for common instructions
+     */
+    private initializeComputeEstimates;
+    /**
+     * Add an instruction to the transaction
+     */
+    addInstruction(instruction: TransactionInstruction, computeEstimate?: number, priority?: number): this;
+    /**
+     * Add multiple instructions
+     */
+    addInstructions(instructions: TransactionInstruction[]): this;
+    /**
+     * Add compute budget instructions
+     */
+    addComputeBudget(units: number, price: number): this;
+    /**
+     * Estimate total compute units
+     */
+    estimateCompute(): number;
+    /**
+     * Build optimized transaction instructions
+     */
+    build(): OptimizationResult;
+    /**
+     * Build and return only the instructions (without compute budget)
+     */
+    buildInstructions(): TransactionInstruction[];
+    /**
+     * Clear all instructions
+     */
+    clear(): this;
+    /**
+     * Get current instruction count
+     */
+    getInstructionCount(): number;
+    /**
+     * Get current signer count
+     */
+    getSignerCount(): number;
+    private packInstructions;
+    private calculateOptimalComputeLimit;
+    private calculateOptimalPrice;
+    private estimateTransactionSize;
+    private addComputeBudgetInstructions;
+}
+/**
+ * Optimizes compute budget allocation for transactions.
+ * Provides dynamic adjustment based on network conditions.
+ */
+declare class ComputeBudgetOptimizer {
+    private baseConfig;
+    private networkStats;
+    private history;
+    private maxHistorySize;
+    constructor(config?: TransactionConfig);
+    /**
+     * Update network statistics
+     */
+    updateNetworkStats(stats: Partial<NetworkStats>): void;
+    /**
+     * Get optimized compute budget for current conditions
+     */
+    getOptimizedBudget(priority?: 'low' | 'normal' | 'high' | 'critical'): {
+        computeLimit: number;
+        computePrice: number;
+        priorityFee: number;
+    };
+    /**
+     * Record transaction result for learning
+     */
+    recordResult(computeUsed: number, computeLimit: number, success: boolean, confirmationTimeMs: number): void;
+    /**
+     * Get recommended compute limit based on history
+     */
+    getRecommendedComputeLimit(): number;
+    /**
+     * Get optimization statistics
+     */
+    getStats(): ComputeBudgetStats;
+    /**
+     * Reset history
+     */
+    reset(): void;
+    private calculateEstimatedFee;
+}
+/**
+ * Network statistics
+ */
+interface NetworkStats {
+    averageComputePrice: number;
+    congestionLevel: number;
+    recentSuccessRate: number;
+}
+/**
+ * Batches multiple instructions into optimized groups.
+ */
+declare class InstructionBatcher {
+    private groups;
+    private maxComputePerGroup;
+    /**
+     * Add an instruction group
+     */
+    addGroup(group: InstructionGroup): this;
+    /**
+     * Batch all groups into optimal transaction sets
+     */
+    batch(): InstructionGroup[][];
+    /**
+     * Set maximum compute per batch
+     */
+    setMaxComputePerGroup(compute: number): this;
+    /**
+     * Clear all groups
+     */
+    clear(): this;
+}
+/**
+ * High-level transaction optimizer.
+ * Applies multiple optimization strategies.
+ */
+declare class TransactionOptimizer {
+    private config;
+    private budgetOptimizer;
+    constructor(config?: TransactionConfig);
+    /**
+     * Optimize a set of instructions
+     */
+    optimize(instructions: TransactionInstruction[], options?: {
+        priority?: 'low' | 'normal' | 'high' | 'critical';
+        useLookupTables?: boolean;
+    }): OptimizationResult;
+    /**
+     * Optimize for minimum latency
+     */
+    optimizeForLatency(instructions: TransactionInstruction[]): OptimizationResult;
+    /**
+     * Optimize for minimum cost
+     */
+    optimizeForCost(instructions: TransactionInstruction[]): OptimizationResult;
+    /**
+     * Get the compute budget optimizer
+     */
+    getBudgetOptimizer(): ComputeBudgetOptimizer;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<TransactionConfig>): void;
+}
+/**
+ * Create a transaction builder
+ */
+declare function createTransactionBuilder(config?: Partial<TransactionConfig>): TransactionBuilder;
+/**
+ * Create a compute budget optimizer
+ */
+declare function createComputeBudgetOptimizer(config?: Partial<TransactionConfig>): ComputeBudgetOptimizer;
+/**
+ * Create an instruction batcher
+ */
+declare function createInstructionBatcher(): InstructionBatcher;
+/**
+ * Create a transaction optimizer
+ */
+declare function createTransactionOptimizer(config?: Partial<TransactionConfig>): TransactionOptimizer;
+/**
+ * Estimate compute units for common operations
+ */
+declare function estimateCompute(operation: string): number;
+/**
+ * Calculate optimal compute unit price
+ */
+declare function calculateOptimalPrice(targetLatencyMs: number, currentCongestion: number): number;
+
+/**
+ * Realtime Tuning Module for Sol Trade SDK
+ * Provides realtime configuration, thread priority, and performance tuning.
+ */
+/**
+ * Realtime configuration
+ */
+interface RealtimeConfig {
+    /** Enable realtime mode */
+    enableRealtime: boolean;
+    /** Target latency in microseconds */
+    targetLatencyUs: number;
+    /** CPU core for pinning */
+    cpuCore: number;
+    /** Thread priority level */
+    priority: ThreadPriorityLevel;
+    /** Enable busy waiting */
+    busyWait: boolean;
+    /** Scheduler policy */
+    scheduler: SchedulerPolicy;
+    /** Memory lock */
+    lockMemory: boolean;
+}
+/**
+ * Thread priority levels
+ */
+declare enum ThreadPriorityLevel {
+    Idle = 0,
+    Lowest = 1,
+    Low = 2,
+    Normal = 3,
+    High = 4,
+    Highest = 5,
+    Realtime = 6
+}
+/**
+ * Scheduler policies
+ */
+declare enum SchedulerPolicy {
+    /** Normal scheduler */
+    Normal = "normal",
+    /** FIFO scheduler */
+    FIFO = "fifo",
+    /** Round-robin scheduler */
+    RoundRobin = "rr",
+    /** Batch scheduler */
+    Batch = "batch",
+    /** Idle scheduler */
+    Idle = "idle"
+}
+/**
+ * Default realtime configuration
+ */
+declare function defaultRealtimeConfig(): RealtimeConfig;
+/**
+ * Tuning statistics
+ */
+interface TuningStats {
+    adjustments: number;
+    averageLatencyUs: number;
+    minLatencyUs: number;
+    maxLatencyUs: number;
+    violations: number;
+    lastAdjustmentTime: number;
+}
+/**
+ * Thread priority manager for realtime performance.
+ * Controls execution priority of trading threads.
+ */
+declare class ThreadPriority {
+    private currentPriority;
+    private config;
+    constructor(config?: RealtimeConfig);
+    /**
+     * Set thread priority
+     */
+    setPriority(priority: ThreadPriorityLevel): boolean;
+    /**
+     * Get current priority
+     */
+    getPriority(): ThreadPriorityLevel;
+    /**
+     * Increase priority by one level
+     */
+    increasePriority(): boolean;
+    /**
+     * Decrease priority by one level
+     */
+    decreasePriority(): boolean;
+    /**
+     * Set realtime priority
+     */
+    setRealtime(): boolean;
+    /**
+     * Set normal priority
+     */
+    setNormal(): boolean;
+    /**
+     * Check if running at realtime priority
+     */
+    isRealtime(): boolean;
+}
+/**
+ * Realtime performance tuner for trading systems.
+ * Automatically adjusts system parameters for optimal latency.
+ */
+declare class RealtimeTuner {
+    private config;
+    private running;
+    private tunerInterval;
+    private latencies;
+    private stats;
+    private callbacks;
+    private lastAdjustment;
+    private adjustmentCooldownMs;
+    constructor(config?: RealtimeConfig);
+    /**
+     * Start the realtime tuner
+     */
+    start(): void;
+    /**
+     * Stop the realtime tuner
+     */
+    stop(): void;
+    /**
+     * Record a latency measurement
+     */
+    recordLatency(latencyUs: number): void;
+    /**
+     * Get current tuning statistics
+     */
+    getStats(): TuningStats;
+    /**
+     * Register a callback for tuning events
+     */
+    onTune(callback: (stats: TuningStats) => void): void;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    private applyConfiguration;
+    private tune;
+    private adjustForLowerLatency;
+}
+/**
+ * Busy wait for a precise amount of time.
+ * More accurate than setTimeout for short durations.
+ */
+declare function busyWait(microseconds: number): void;
+/**
+ * Spin lock with timeout
+ */
+declare function spinLock(condition: () => boolean, timeoutUs: number): boolean;
+/**
+ * Latency monitoring for realtime systems
+ */
+declare class LatencyMonitor {
+    private measurements;
+    private maxMeasurements;
+    private histogram;
+    private bucketSize;
+    constructor(maxMeasurements?: number, bucketSize?: number);
+    /**
+     * Record a latency measurement
+     */
+    record(latencyUs: number): void;
+    /**
+     * Get percentile latency
+     */
+    getPercentile(percentile: number): number;
+    /**
+     * Get average latency
+     */
+    getAverage(): number;
+    /**
+     * Get minimum latency
+     */
+    getMin(): number;
+    /**
+     * Get maximum latency
+     */
+    getMax(): number;
+    /**
+     * Get histogram
+     */
+    getHistogram(): Map<number, number>;
+    /**
+     * Reset all measurements
+     */
+    reset(): void;
+    /**
+     * Get summary statistics
+     */
+    getSummary(): {
+        count: number;
+        min: number;
+        max: number;
+        avg: number;
+        p50: number;
+        p95: number;
+        p99: number;
+        p999: number;
+    };
+}
+/**
+ * Performance governor for trading systems
+ */
+declare class PerformanceGovernor {
+    private targetThroughput;
+    private currentThroughput;
+    private adjustments;
+    /**
+     * Set target throughput (operations per second)
+     */
+    setTargetThroughput(opsPerSecond: number): void;
+    /**
+     * Report actual throughput
+     */
+    reportThroughput(opsPerSecond: number): void;
+    /**
+     * Get recommended batch size
+     */
+    getRecommendedBatchSize(): number;
+    /**
+     * Get adjustment count
+     */
+    getAdjustments(): number;
+}
+/**
+ * Create a realtime tuner
+ */
+declare function createRealtimeTuner(config?: Partial<RealtimeConfig>): RealtimeTuner;
+/**
+ * Create a thread priority manager
+ */
+declare function createThreadPriority(config?: Partial<RealtimeConfig>): ThreadPriority;
+/**
+ * Create a latency monitor
+ */
+declare function createLatencyMonitor(maxMeasurements?: number, bucketSize?: number): LatencyMonitor;
+/**
+ * Create a performance governor
+ */
+declare function createPerformanceGovernor(): PerformanceGovernor;
+/**
+ * Measure function execution time
+ */
+declare function measureTime<T>(fn: () => T): {
+    result: T;
+    elapsedUs: number;
+};
+/**
+ * Create a high-resolution timer
+ */
+declare function createTimer(): {
+    start: () => void;
+    elapsed: () => number;
+    reset: () => void;
+};
+
+/**
+ * SIMD (Single Instruction Multiple Data) Module for Sol Trade SDK
+ * Provides SIMD operations, detection, and crypto optimizations.
+ */
+/**
+ * SIMD configuration
+ */
+interface SIMDConfig {
+    /** Enable SIMD operations */
+    enableSIMD: boolean;
+    /** Preferred SIMD width (128, 256, 512) */
+    preferredWidth: number;
+    /** Enable WebAssembly SIMD */
+    enableWasmSIMD: boolean;
+    /** Fallback to scalar on failure */
+    fallbackToScalar: boolean;
+}
+/**
+ * Default SIMD configuration
+ */
+declare function defaultSIMDConfig(): SIMDConfig;
+/**
+ * SIMD capabilities
+ */
+interface SIMDCapabilities {
+    /** SSE support */
+    sse: boolean;
+    /** SSE2 support */
+    sse2: boolean;
+    /** SSE3 support */
+    sse3: boolean;
+    /** SSSE3 support */
+    ssse3: boolean;
+    /** SSE4.1 support */
+    sse41: boolean;
+    /** SSE4.2 support */
+    sse42: boolean;
+    /** AVX support */
+    avx: boolean;
+    /** AVX2 support */
+    avx2: boolean;
+    /** AVX-512 support */
+    avx512: boolean;
+    /** NEON support (ARM) */
+    neon: boolean;
+    /** WebAssembly SIMD128 support */
+    wasmSimd128: boolean;
+}
+/**
+ * Vector types
+ */
+type Float32Vector = Float32Array;
+type Float64Vector = Float64Array;
+type Int32Vector = Int32Array;
+type Int64Vector = BigInt64Array;
+/**
+ * Detects SIMD capabilities of the runtime environment.
+ */
+declare class SIMDDetector {
+    private capabilities;
+    /**
+     * Detect SIMD capabilities
+     */
+    detect(): SIMDCapabilities;
+    /**
+     * Check if WebAssembly SIMD128 is available
+     */
+    private detectWasmSIMD128;
+    /**
+     * Detect NEON support (ARM)
+     */
+    private detectNEON;
+    /**
+     * Check if specific capability is available
+     */
+    hasCapability(capability: keyof SIMDCapabilities): boolean;
+    /**
+     * Get optimal vector width
+     */
+    getOptimalWidth(): number;
+    /**
+     * Check if any SIMD is available
+     */
+    hasAnySIMD(): boolean;
+}
+/**
+ * Vectorized mathematical operations using SIMD where available.
+ */
+declare class VectorizedMath {
+    private config;
+    private detector;
+    constructor(config?: SIMDConfig);
+    /**
+     * Vector addition: result = a + b
+     */
+    add(a: Float32Array, b: Float32Array, result?: Float32Array): Float32Array;
+    /**
+     * Vector subtraction: result = a - b
+     */
+    subtract(a: Float32Array, b: Float32Array, result?: Float32Array): Float32Array;
+    /**
+     * Vector multiplication: result = a * b
+     */
+    multiply(a: Float32Array, b: Float32Array, result?: Float32Array): Float32Array;
+    /**
+     * Vector division: result = a / b
+     */
+    divide(a: Float32Array, b: Float32Array, result?: Float32Array): Float32Array;
+    /**
+     * Vector dot product
+     */
+    dot(a: Float32Array, b: Float32Array): number;
+    /**
+     * Vector sum
+     */
+    sum(a: Float32Array): number;
+    /**
+     * Vector minimum
+     */
+    min(a: Float32Array): number;
+    /**
+     * Vector maximum
+     */
+    max(a: Float32Array): number;
+    /**
+     * Element-wise absolute value
+     */
+    abs(a: Float32Array, result?: Float32Array): Float32Array;
+    /**
+     * Element-wise square root
+     */
+    sqrt(a: Float32Array, result?: Float32Array): Float32Array;
+}
+/**
+ * SIMD-optimized cryptographic operations.
+ * Provides accelerated hashing and verification.
+ */
+declare class CryptoSIMD {
+    private config;
+    private detector;
+    constructor(config?: SIMDConfig);
+    /**
+     * XOR two byte arrays (SIMD-accelerated)
+     */
+    xor(a: Uint8Array, b: Uint8Array, result?: Uint8Array): Uint8Array;
+    /**
+     * Compare two byte arrays for equality (SIMD-accelerated)
+     */
+    equals(a: Uint8Array, b: Uint8Array): boolean;
+    /**
+     * Fill array with value (SIMD-accelerated)
+     */
+    fill(buffer: Uint8Array, value: number): void;
+    /**
+     * Copy bytes (SIMD-accelerated)
+     */
+    copy(src: Uint8Array, dst: Uint8Array, srcOffset?: number, dstOffset?: number, length?: number): void;
+    /**
+     * Compute parity of byte array
+     */
+    parity(data: Uint8Array): number;
+    /**
+     * Rotate bytes left
+     */
+    rotateLeft(data: Uint8Array, bits: number, result?: Uint8Array): Uint8Array;
+}
+/**
+ * 128-bit SIMD vector (4 floats)
+ */
+declare class Float32x4 {
+    private data;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    static fromArray(arr: Float32Array, offset?: number): Float32x4;
+    add(other: Float32x4): Float32x4;
+    subtract(other: Float32x4): Float32x4;
+    multiply(other: Float32x4): Float32x4;
+    toArray(): Float32Array;
+    get x(): number;
+    get y(): number;
+    get z(): number;
+    get w(): number;
+}
+/**
+ * Create a SIMD detector
+ */
+declare function createSIMDDetector(): SIMDDetector;
+/**
+ * Create a vectorized math instance
+ */
+declare function createVectorizedMath(config?: Partial<SIMDConfig>): VectorizedMath;
+/**
+ * Create a crypto SIMD instance
+ */
+declare function createCryptoSIMD(config?: Partial<SIMDConfig>): CryptoSIMD;
+/**
+ * Check if SIMD is available
+ */
+declare function isSIMDAvailable(): boolean;
+/**
+ * Get optimal SIMD width
+ */
+declare function getOptimalSIMDWidth(): number;
+
+/**
+ * Syscall Bypass Module for Sol Trade SDK
+ * Provides high-performance time and system call optimizations.
+ */
+/**
+ * Configuration for syscall bypass optimizations
+ */
+interface SyscallBypassConfig {
+    /** Enable fast time provider using cached time */
+    enableFastTime: boolean;
+    /** Time cache interval in microseconds */
+    timeCacheIntervalUs: number;
+    /** Enable syscall batching */
+    enableBatching: boolean;
+    /** Maximum batch size for syscalls */
+    maxBatchSize: number;
+    /** Enable vDSO (virtual dynamic shared object) time */
+    useVdsoTime: boolean;
+}
+/**
+ * Default syscall bypass configuration
+ */
+declare function defaultSyscallBypassConfig(): SyscallBypassConfig;
+/**
+ * High-performance time provider with caching to reduce syscalls.
+ * Uses a background update mechanism to cache current time.
+ */
+declare class FastTimeProvider {
+    private cachedTimeNs;
+    private cachedTimeMs;
+    private lastUpdateNs;
+    private updateIntervalNs;
+    private running;
+    private updateTimer;
+    private useHighRes;
+    constructor(updateIntervalUs?: number, useHighRes?: boolean);
+    /**
+     * Start the background time update loop
+     */
+    start(): void;
+    /**
+     * Stop the background time update loop
+     */
+    stop(): void;
+    /**
+     * Get cached time in nanoseconds (fast, no syscall)
+     */
+    nowNs(): bigint;
+    /**
+     * Get cached time in microseconds (fast, no syscall)
+     */
+    nowUs(): bigint;
+    /**
+     * Get cached time in milliseconds (fast, no syscall)
+     */
+    nowMs(): number;
+    /**
+     * Get precise time (may involve syscall)
+     */
+    preciseNowNs(): bigint;
+    /**
+     * Get precise time in microseconds
+     */
+    preciseNowUs(): bigint;
+    private updateTime;
+}
+/**
+ * Manages syscall bypass optimizations for high-frequency trading.
+ * Reduces system call overhead through caching and batching.
+ */
+declare class SyscallBypassManager {
+    private config;
+    private timeProvider;
+    private syscallQueue;
+    private batchTimer;
+    private stats;
+    constructor(config?: SyscallBypassConfig);
+    /**
+     * Initialize the syscall bypass manager
+     */
+    initialize(): void;
+    /**
+     * Shutdown the syscall bypass manager
+     */
+    shutdown(): void;
+    /**
+     * Get fast cached time in nanoseconds
+     */
+    fastTimeNs(): bigint;
+    /**
+     * Get fast cached time in microseconds
+     */
+    fastTimeUs(): bigint;
+    /**
+     * Get fast cached time in milliseconds
+     */
+    fastTimeMs(): number;
+    /**
+     * Queue a syscall for batching
+     */
+    queueSyscall(syscall: () => void): void;
+    /**
+     * Execute a function with syscall bypass timing
+     */
+    measure<T>(fn: () => T): {
+        result: T;
+        elapsedNs: bigint;
+    };
+    /**
+     * Get syscall bypass statistics
+     */
+    getStats(): SyscallStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    private startBatching;
+    private flushBatch;
+}
+/**
+ * Syscall bypass statistics
+ */
+interface SyscallStats {
+    totalCalls: number;
+    bypassedCalls: number;
+    batchedCalls: number;
+    timeSavedNs: bigint;
+    bypassRate?: number;
+}
+/**
+ * Create a new syscall bypass manager with default configuration
+ */
+declare function createSyscallBypassManager(config?: Partial<SyscallBypassConfig>): SyscallBypassManager;
+/**
+ * Get the global fast time provider (creates if needed)
+ */
+declare function getGlobalTimeProvider(): FastTimeProvider;
+/**
+ * Fast time access using global provider
+ */
+declare function fastNowNs(): bigint;
+declare function fastNowUs(): bigint;
+declare function fastNowMs(): number;
+
+/**
+ * Ultra-Low Latency (ULL) Module for Sol Trade SDK
+ * Provides memory pools, lock-free queues, and latency optimization.
+ */
+/**
+ * Configuration for ultra-low latency optimizations
+ */
+interface UltraLowLatencyConfig {
+    /** Memory pool size per object type */
+    memoryPoolSize: number;
+    /** Lock-free queue capacity */
+    queueCapacity: number;
+    /** Enable busy spinning instead of yielding */
+    enableBusySpin: boolean;
+    /** Spin count before yielding */
+    spinCount: number;
+    /** Enable memory prefetching */
+    enablePrefetch: boolean;
+    /** NUMA-aware memory allocation */
+    numaAware: boolean;
+}
+/**
+ * Default ULL configuration
+ */
+declare function defaultUltraLowLatencyConfig(): UltraLowLatencyConfig;
+/**
+ * Latency statistics
+ */
+interface LatencyStats {
+    minLatencyUs: number;
+    maxLatencyUs: number;
+    avgLatencyUs: number;
+    p50LatencyUs: number;
+    p99LatencyUs: number;
+    p999LatencyUs: number;
+    totalOperations: number;
+}
+/**
+ * High-performance memory pool for object reuse.
+ * Reduces GC pressure and allocation latency.
+ */
+declare class MemoryPool<T> {
+    private pool;
+    private factory;
+    private resetFn;
+    private maxSize;
+    private leased;
+    constructor(factory: () => T, resetFn: (obj: T) => void, maxSize?: number);
+    /**
+     * Acquire an object from the pool
+     */
+    acquire(): T;
+    /**
+     * Release an object back to the pool
+     */
+    release(obj: T): void;
+    /**
+     * Execute a function with a pooled object
+     */
+    with<R>(fn: (obj: T) => R): R;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        available: number;
+        inUse: number;
+        total: number;
+    };
+}
+/**
+ * Lock-free circular buffer queue for single-producer single-consumer scenarios.
+ * Uses atomic operations for synchronization.
+ */
+declare class LockFreeQueue<T> {
+    private buffer;
+    private capacity;
+    private mask;
+    private head;
+    private tail;
+    private config;
+    constructor(capacity?: number, config?: UltraLowLatencyConfig);
+    /**
+     * Enqueue an item (producer only)
+     */
+    enqueue(item: T): boolean;
+    /**
+     * Dequeue an item (consumer only)
+     */
+    dequeue(): T | undefined;
+    /**
+     * Try dequeue with spinning
+     */
+    dequeueSpin(timeoutUs?: number): T | undefined;
+    /**
+     * Get current size
+     */
+    size(): number;
+    /**
+     * Check if empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if full
+     */
+    isFull(): boolean;
+    /**
+     * Clear the queue
+     */
+    clear(): void;
+}
+/**
+ * Thread-safe queue supporting multiple producers and consumers.
+ * Uses compare-and-swap for atomic operations.
+ */
+declare class MPMCQueue<T> {
+    private buffer;
+    private capacity;
+    private mask;
+    private enqueuePos;
+    private dequeuePos;
+    constructor(capacity?: number);
+    /**
+     * Enqueue an item (thread-safe)
+     */
+    enqueue(item: T): boolean;
+    /**
+     * Dequeue an item (thread-safe)
+     */
+    dequeue(): T | undefined;
+    private compareAndSwapEnqueuePos;
+    private compareAndSwapDequeuePos;
+}
+/**
+ * Latency optimizer for trading operations.
+ * Provides latency measurement, optimization, and reporting.
+ */
+declare class LatencyOptimizer {
+    private latencies;
+    private maxSamples;
+    private config;
+    private optimizationCallbacks;
+    constructor(maxSamples?: number, config?: UltraLowLatencyConfig);
+    /**
+     * Record a latency measurement
+     */
+    recordLatency(latencyUs: number): void;
+    /**
+     * Measure and record function execution time
+     */
+    measure<T>(fn: () => T): {
+        result: T;
+        latencyUs: number;
+    };
+    /**
+     * Get latency statistics
+     */
+    getStats(): LatencyStats;
+    /**
+     * Register an optimization callback
+     */
+    onOptimization(callback: () => void): void;
+    /**
+     * Trigger optimization
+     */
+    optimize(): void;
+    /**
+     * Reset statistics
+     */
+    reset(): void;
+}
+/**
+ * Software prefetch hint (no-op in JS, but documents intent)
+ */
+declare function prefetch<T>(obj: T): void;
+/**
+ * Prefetch an array element
+ */
+declare function prefetchArray<T>(arr: T[], index: number): void;
+/**
+ * Create a memory pool with default configuration
+ */
+declare function createMemoryPool<T>(factory: () => T, resetFn: (obj: T) => void, size?: number): MemoryPool<T>;
+/**
+ * Create a lock-free queue
+ */
+declare function createLockFreeQueue<T>(capacity?: number): LockFreeQueue<T>;
+/**
+ * Create an MPMC queue
+ */
+declare function createMPMCQueue<T>(capacity?: number): MPMCQueue<T>;
+/**
+ * Busy spin for a number of iterations
+ */
+declare function busySpin(iterations: number): void;
+/**
+ * Yield to event loop
+ */
+declare function yieldToEventLoop(): Promise<void>;
+
+/**
+ * Zero-Copy Module for Sol Trade SDK
+ * Provides zero-copy buffer operations and serialization.
+ */
+/**
+ * Buffer view with zero-copy semantics
+ */
+interface BufferView {
+    buffer: ArrayBuffer;
+    byteOffset: number;
+    byteLength: number;
+}
+/**
+ * Serializable interface for zero-copy operations
+ */
+interface ZeroCopySerializable {
+    serialize(): Uint8Array;
+    deserialize(data: Uint8Array): void;
+    serializedSize(): number;
+}
+/**
+ * Buffer pool configuration
+ */
+interface BufferPoolConfig {
+    /** Buffer size in bytes */
+    bufferSize: number;
+    /** Number of buffers in pool */
+    poolSize: number;
+    /** Enable automatic expansion */
+    autoExpand: boolean;
+    /** Maximum pool size */
+    maxPoolSize: number;
+}
+/**
+ * Default buffer pool configuration
+ */
+declare function defaultBufferPoolConfig(): BufferPoolConfig;
+/**
+ * Zero-copy buffer with view semantics.
+ * Allows multiple views into the same underlying buffer without copying.
+ */
+declare class ZeroCopyBuffer {
+    private buffer;
+    private view;
+    private uint8View;
+    private offset;
+    constructor(size?: number);
+    /**
+     * Create from existing buffer (zero-copy)
+     */
+    static from(buffer: ArrayBuffer): ZeroCopyBuffer;
+    /**
+     * Create a view into this buffer without copying
+     */
+    slice(start: number, end: number): Uint8Array;
+    /**
+     * Get current write offset
+     */
+    getOffset(): number;
+    /**
+     * Set write offset
+     */
+    setOffset(offset: number): void;
+    /**
+     * Get buffer capacity
+     */
+    capacity(): number;
+    /**
+     * Write Uint8 at current offset
+     */
+    writeUint8(value: number): void;
+    /**
+     * Write Uint16 at current offset (little-endian)
+     */
+    writeUint16(value: number): void;
+    /**
+     * Write Uint32 at current offset (little-endian)
+     */
+    writeUint32(value: number): void;
+    /**
+     * Write BigUint64 at current offset (little-endian)
+     */
+    writeUint64(value: bigint): void;
+    /**
+     * Write bytes at current offset
+     */
+    writeBytes(bytes: Uint8Array): void;
+    /**
+     * Read Uint8 at offset
+     */
+    readUint8(offset: number): number;
+    /**
+     * Read Uint16 at offset (little-endian)
+     */
+    readUint16(offset: number): number;
+    /**
+     * Read Uint32 at offset (little-endian)
+     */
+    readUint32(offset: number): number;
+    /**
+     * Read BigUint64 at offset (little-endian)
+     */
+    readUint64(offset: number): bigint;
+    /**
+     * Read bytes at offset
+     */
+    readBytes(offset: number, length: number): Uint8Array;
+    /**
+     * Get the underlying ArrayBuffer
+     */
+    getBuffer(): ArrayBuffer;
+    /**
+     * Get as Uint8Array (full buffer)
+     */
+    asUint8Array(): Uint8Array;
+    /**
+     * Get used portion as Uint8Array (zero-copy view)
+     */
+    asUsedUint8Array(): Uint8Array;
+    /**
+     * Reset offset to beginning
+     */
+    reset(): void;
+    /**
+     * Ensure capacity (creates new buffer if needed, copies data)
+     */
+    ensureCapacity(minCapacity: number): void;
+}
+/**
+ * High-performance buffer pool for zero-copy operations.
+ * Reduces allocation overhead by reusing buffers.
+ */
+declare class BufferPool {
+    private pool;
+    private inUse;
+    private config;
+    constructor(config?: BufferPoolConfig);
+    /**
+     * Acquire a buffer from the pool
+     */
+    acquire(): ArrayBuffer;
+    /**
+     * Acquire a ZeroCopyBuffer wrapper
+     */
+    acquireZeroCopyBuffer(): ZeroCopyBuffer;
+    /**
+     * Release a buffer back to the pool
+     */
+    release(buffer: ArrayBuffer): void;
+    /**
+     * Execute a function with a pooled buffer
+     */
+    with<T>(fn: (buffer: ArrayBuffer) => T): T;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        available: number;
+        inUse: number;
+        total: number;
+    };
+    /**
+     * Clear all buffers
+     */
+    clear(): void;
+}
+/**
+ * High-performance serializer with zero-copy semantics.
+ * Minimizes memory copies during serialization/deserialization.
+ */
+declare class ZeroCopySerializer {
+    private buffer;
+    private textEncoder;
+    private textDecoder;
+    constructor(initialSize?: number);
+    /**
+     * Serialize a string (length-prefixed)
+     */
+    writeString(value: string): void;
+    /**
+     * Serialize a PublicKey (32 bytes)
+     */
+    writePublicKey(bytes: Uint8Array): void;
+    /**
+     * Serialize a BigInt (8 bytes)
+     */
+    writeBigInt(value: bigint): void;
+    /**
+     * Serialize a number (4 bytes)
+     */
+    writeNumber(value: number): void;
+    /**
+     * Serialize a boolean (1 byte)
+     */
+    writeBoolean(value: boolean): void;
+    /**
+     * Serialize bytes with length prefix
+     */
+    writeByteArray(bytes: Uint8Array): void;
+    /**
+     * Deserialize a string
+     */
+    readString(offset: number): {
+        value: string;
+        nextOffset: number;
+    };
+    /**
+     * Deserialize a PublicKey
+     */
+    readPublicKey(offset: number): {
+        value: Uint8Array;
+        nextOffset: number;
+    };
+    /**
+     * Deserialize a BigInt
+     */
+    readBigInt(offset: number): {
+        value: bigint;
+        nextOffset: number;
+    };
+    /**
+     * Deserialize a number
+     */
+    readNumber(offset: number): {
+        value: number;
+        nextOffset: number;
+    };
+    /**
+     * Deserialize a boolean
+     */
+    readBoolean(offset: number): {
+        value: boolean;
+        nextOffset: number;
+    };
+    /**
+     * Deserialize a byte array
+     */
+    readByteArray(offset: number): {
+        value: Uint8Array;
+        nextOffset: number;
+    };
+    /**
+     * Get serialized data as Uint8Array (zero-copy view)
+     */
+    getData(): Uint8Array;
+    /**
+     * Reset for reuse
+     */
+    reset(): void;
+    /**
+     * Get current offset
+     */
+    getOffset(): number;
+}
+/**
+ * Fixed-size view into a buffer for predictable memory layout.
+ * Useful for structures with known sizes.
+ */
+declare class FixedBufferView {
+    private buffer;
+    private view;
+    private uint8View;
+    private baseOffset;
+    constructor(buffer: ArrayBuffer, offset: number, size: number);
+    /**
+     * Get Uint8 at relative offset
+     */
+    getUint8(offset: number): number;
+    /**
+     * Set Uint8 at relative offset
+     */
+    setUint8(offset: number, value: number): void;
+    /**
+     * Get Uint32 at relative offset
+     */
+    getUint32(offset: number): number;
+    /**
+     * Set Uint32 at relative offset
+     */
+    setUint32(offset: number, value: number): void;
+    /**
+     * Get BigUint64 at relative offset
+     */
+    getUint64(offset: number): bigint;
+    /**
+     * Set BigUint64 at relative offset
+     */
+    setUint64(offset: number, value: bigint): void;
+    /**
+     * Get bytes at relative offset
+     */
+    getBytes(offset: number, length: number): Uint8Array;
+    /**
+     * Set bytes at relative offset
+     */
+    setBytes(offset: number, bytes: Uint8Array): void;
+    /**
+     * Get the underlying ArrayBuffer
+     */
+    getBuffer(): ArrayBuffer;
+    /**
+     * Get the base offset
+     */
+    getBaseOffset(): number;
+}
+/**
+ * Create a buffer pool with default configuration
+ */
+declare function createBufferPool(config?: Partial<BufferPoolConfig>): BufferPool;
+/**
+ * Create a zero-copy buffer
+ */
+declare function createZeroCopyBuffer(size?: number): ZeroCopyBuffer;
+/**
+ * Create a zero-copy serializer
+ */
+declare function createSerializer(initialSize?: number): ZeroCopySerializer;
+/**
+ * Copy bytes without allocation (if possible)
+ */
+declare function copyBytes(src: Uint8Array, dst: Uint8Array, dstOffset?: number): void;
+/**
+ * Create a zero-copy view of a buffer
+ */
+declare function createView(buffer: ArrayBuffer, offset: number, length: number): Uint8Array;
+
+type index_AffinityConfig = AffinityConfig;
+type index_AlignedBuffer = AlignedBuffer;
+declare const index_AlignedBuffer: typeof AlignedBuffer;
+type index_AsyncSocket = AsyncSocket;
+declare const index_AsyncSocket: typeof AsyncSocket;
+type index_BranchOptimizer = BranchOptimizer;
+declare const index_BranchOptimizer: typeof BranchOptimizer;
+type index_BufferPool = BufferPool;
+declare const index_BufferPool: typeof BufferPool;
+type index_BufferPoolConfig = BufferPoolConfig;
+type index_BufferView = BufferView;
+declare const index_CACHE_LINE_SIZE: typeof CACHE_LINE_SIZE;
+type index_CPUAffinity = CPUAffinity;
+declare const index_CPUAffinity: typeof CPUAffinity;
+type index_CPUFeatures = CPUFeatures;
+type index_CPUTopology = CPUTopology;
+type index_CacheInfo = CacheInfo;
+type index_CacheOptimizer = CacheOptimizer;
+declare const index_CacheOptimizer: typeof CacheOptimizer;
+type index_ComputeBudgetOptimizer = ComputeBudgetOptimizer;
+declare const index_ComputeBudgetOptimizer: typeof ComputeBudgetOptimizer;
+type index_ComputeBudgetStats = ComputeBudgetStats;
+type index_CryptoSIMD = CryptoSIMD;
+declare const index_CryptoSIMD: typeof CryptoSIMD;
+type index_DirectIOFile = DirectIOFile;
+declare const index_DirectIOFile: typeof DirectIOFile;
+type index_FastTimeProvider = FastTimeProvider;
+declare const index_FastTimeProvider: typeof FastTimeProvider;
+type index_FixedBufferView = FixedBufferView;
+declare const index_FixedBufferView: typeof FixedBufferView;
+type index_Float32Vector = Float32Vector;
+type index_Float32x4 = Float32x4;
+declare const index_Float32x4: typeof Float32x4;
+type index_Float64Vector = Float64Vector;
+type index_FuncCache<T> = FuncCache<T>;
+declare const index_FuncCache: typeof FuncCache;
+type index_HardwareMonitor = HardwareMonitor;
+declare const index_HardwareMonitor: typeof HardwareMonitor;
+type index_IOBatchProcessor = IOBatchProcessor;
+declare const index_IOBatchProcessor: typeof IOBatchProcessor;
+type index_IOOperation = IOOperation;
+declare const index_IOOperation: typeof IOOperation;
+type index_IORequest = IORequest;
+type index_IOResult = IOResult;
+type index_IOUringConfig = IOUringConfig;
+type index_InstructionBatcher = InstructionBatcher;
+declare const index_InstructionBatcher: typeof InstructionBatcher;
+type index_InstructionGroup = InstructionGroup;
+type index_Int32Vector = Int32Vector;
+type index_Int64Vector = Int64Vector;
+type index_JITConfig = JITConfig;
+type index_KernelBypassManager = KernelBypassManager;
+declare const index_KernelBypassManager: typeof KernelBypassManager;
+type index_LatencyMonitor = LatencyMonitor;
+declare const index_LatencyMonitor: typeof LatencyMonitor;
+type index_LatencyOptimizer = LatencyOptimizer;
+declare const index_LatencyOptimizer: typeof LatencyOptimizer;
+type index_LatencyStats = LatencyStats;
+type index_LockFreeQueue<T> = LockFreeQueue<T>;
+declare const index_LockFreeQueue: typeof LockFreeQueue;
+type index_LoopOptimizer = LoopOptimizer;
+declare const index_LoopOptimizer: typeof LoopOptimizer;
+type index_MPMCQueue<T> = MPMCQueue<T>;
+declare const index_MPMCQueue: typeof MPMCQueue;
+type index_MemoryMappedFile = MemoryMappedFile;
+declare const index_MemoryMappedFile: typeof MemoryMappedFile;
+type index_MemoryOps = MemoryOps;
+declare const index_MemoryOps: typeof MemoryOps;
+type index_MemoryPool<T> = MemoryPool<T>;
+declare const index_MemoryPool: typeof MemoryPool;
+type index_NUMAConfig = NUMAConfig;
+type index_NUMAOptimizer = NUMAOptimizer;
+declare const index_NUMAOptimizer: typeof NUMAOptimizer;
+type index_OptimizationResult = OptimizationResult;
+type index_OptimizedMath = OptimizedMath;
+declare const index_OptimizedMath: typeof OptimizedMath;
+type index_PerformanceGovernor = PerformanceGovernor;
+declare const index_PerformanceGovernor: typeof PerformanceGovernor;
+type index_ProfileGuidedOptimizer = ProfileGuidedOptimizer;
+declare const index_ProfileGuidedOptimizer: typeof ProfileGuidedOptimizer;
+type index_RealtimeConfig = RealtimeConfig;
+type index_RealtimeTuner = RealtimeTuner;
+declare const index_RealtimeTuner: typeof RealtimeTuner;
+type index_SIMDCapabilities = SIMDCapabilities;
+type index_SIMDConfig = SIMDConfig;
+type index_SIMDDetector = SIMDDetector;
+declare const index_SIMDDetector: typeof SIMDDetector;
+type index_SchedulerPolicy = SchedulerPolicy;
+declare const index_SchedulerPolicy: typeof SchedulerPolicy;
+type index_SpinLock = SpinLock;
+declare const index_SpinLock: typeof SpinLock;
+type index_SyscallBypassConfig = SyscallBypassConfig;
+type index_SyscallBypassManager = SyscallBypassManager;
+declare const index_SyscallBypassManager: typeof SyscallBypassManager;
+type index_ThreadPriority = ThreadPriority;
+declare const index_ThreadPriority: typeof ThreadPriority;
+type index_ThreadPriorityLevel = ThreadPriorityLevel;
+declare const index_ThreadPriorityLevel: typeof ThreadPriorityLevel;
+type index_TransactionBuilder = TransactionBuilder;
+declare const index_TransactionBuilder: typeof TransactionBuilder;
+type index_TransactionConfig = TransactionConfig;
+type index_TransactionOptimizer = TransactionOptimizer;
+declare const index_TransactionOptimizer: typeof TransactionOptimizer;
+type index_TuningStats = TuningStats;
+type index_UltraLowLatencyConfig = UltraLowLatencyConfig;
+type index_VectorizedMath = VectorizedMath;
+declare const index_VectorizedMath: typeof VectorizedMath;
+type index_ZeroCopyBuffer = ZeroCopyBuffer;
+declare const index_ZeroCopyBuffer: typeof ZeroCopyBuffer;
+type index_ZeroCopySerializable = ZeroCopySerializable;
+type index_ZeroCopySerializer = ZeroCopySerializer;
+declare const index_ZeroCopySerializer: typeof ZeroCopySerializer;
+declare const index_busySpin: typeof busySpin;
+declare const index_busyWait: typeof busyWait;
+declare const index_calculateOptimalPrice: typeof calculateOptimalPrice;
+declare const index_coldPath: typeof coldPath;
+declare const index_copyBytes: typeof copyBytes;
+declare const index_createBufferPool: typeof createBufferPool;
+declare const index_createCPUAffinity: typeof createCPUAffinity;
+declare const index_createCacheOptimizer: typeof createCacheOptimizer;
+declare const index_createComputeBudgetOptimizer: typeof createComputeBudgetOptimizer;
+declare const index_createCryptoSIMD: typeof createCryptoSIMD;
+declare const index_createHardwareMonitor: typeof createHardwareMonitor;
+declare const index_createInstructionBatcher: typeof createInstructionBatcher;
+declare const index_createLatencyMonitor: typeof createLatencyMonitor;
+declare const index_createLockFreeQueue: typeof createLockFreeQueue;
+declare const index_createMPMCQueue: typeof createMPMCQueue;
+declare const index_createMemoryPool: typeof createMemoryPool;
+declare const index_createNUMAOptimizer: typeof createNUMAOptimizer;
+declare const index_createPerformanceGovernor: typeof createPerformanceGovernor;
+declare const index_createRealtimeTuner: typeof createRealtimeTuner;
+declare const index_createSIMDDetector: typeof createSIMDDetector;
+declare const index_createSerializer: typeof createSerializer;
+declare const index_createSyscallBypassManager: typeof createSyscallBypassManager;
+declare const index_createThreadPriority: typeof createThreadPriority;
+declare const index_createTimer: typeof createTimer;
+declare const index_createTransactionBuilder: typeof createTransactionBuilder;
+declare const index_createTransactionOptimizer: typeof createTransactionOptimizer;
+declare const index_createVectorizedMath: typeof createVectorizedMath;
+declare const index_createView: typeof createView;
+declare const index_createZeroCopyBuffer: typeof createZeroCopyBuffer;
+declare const index_defaultAffinityConfig: typeof defaultAffinityConfig;
+declare const index_defaultBufferPoolConfig: typeof defaultBufferPoolConfig;
+declare const index_defaultIOUringConfig: typeof defaultIOUringConfig;
+declare const index_defaultJITConfig: typeof defaultJITConfig;
+declare const index_defaultNUMAConfig: typeof defaultNUMAConfig;
+declare const index_defaultRealtimeConfig: typeof defaultRealtimeConfig;
+declare const index_defaultSIMDConfig: typeof defaultSIMDConfig;
+declare const index_defaultSyscallBypassConfig: typeof defaultSyscallBypassConfig;
+declare const index_defaultTransactionConfig: typeof defaultTransactionConfig;
+declare const index_defaultUltraLowLatencyConfig: typeof defaultUltraLowLatencyConfig;
+declare const index_detectCPUFeatures: typeof detectCPUFeatures;
+declare const index_estimateCompute: typeof estimateCompute;
+declare const index_fastInvSqrt: typeof fastInvSqrt;
+declare const index_fastNowMs: typeof fastNowMs;
+declare const index_fastNowNs: typeof fastNowNs;
+declare const index_fastNowUs: typeof fastNowUs;
+declare const index_getGlobalTimeProvider: typeof getGlobalTimeProvider;
+declare const index_getKernelBypassManager: typeof getKernelBypassManager;
+declare const index_getOptimalSIMDWidth: typeof getOptimalSIMDWidth;
+declare const index_getProfileOptimizer: typeof getProfileOptimizer;
+declare const index_getSystemCPUInfo: typeof getSystemCPUInfo;
+declare const index_getSystemMemoryInfo: typeof getSystemMemoryInfo;
+declare const index_hotPath: typeof hotPath;
+declare const index_isSIMDAvailable: typeof isSIMDAvailable;
+declare const index_likely: typeof likely;
+declare const index_measureTime: typeof measureTime;
+declare const index_prefetch: typeof prefetch;
+declare const index_prefetchArray: typeof prefetchArray;
+declare const index_prefetchHint: typeof prefetchHint;
+declare const index_profile: typeof profile;
+declare const index_spinLock: typeof spinLock;
+declare const index_unlikely: typeof unlikely;
+declare const index_yieldToEventLoop: typeof yieldToEventLoop;
+declare namespace index {
+  export { type index_AffinityConfig as AffinityConfig, index_AlignedBuffer as AlignedBuffer, index_AsyncSocket as AsyncSocket, index_BranchOptimizer as BranchOptimizer, index_BufferPool as BufferPool, type index_BufferPoolConfig as BufferPoolConfig, type index_BufferView as BufferView, index_CACHE_LINE_SIZE as CACHE_LINE_SIZE, index_CPUAffinity as CPUAffinity, type index_CPUFeatures as CPUFeatures, type index_CPUTopology as CPUTopology, type index_CacheInfo as CacheInfo, index_CacheOptimizer as CacheOptimizer, index_ComputeBudgetOptimizer as ComputeBudgetOptimizer, type index_ComputeBudgetStats as ComputeBudgetStats, index_CryptoSIMD as CryptoSIMD, index_DirectIOFile as DirectIOFile, index_FastTimeProvider as FastTimeProvider, index_FixedBufferView as FixedBufferView, type index_Float32Vector as Float32Vector, index_Float32x4 as Float32x4, type index_Float64Vector as Float64Vector, index_FuncCache as FuncCache, index_HardwareMonitor as HardwareMonitor, index_IOBatchProcessor as IOBatchProcessor, index_IOOperation as IOOperation, type index_IORequest as IORequest, type index_IOResult as IOResult, type index_IOUringConfig as IOUringConfig, index_InstructionBatcher as InstructionBatcher, type index_InstructionGroup as InstructionGroup, type index_Int32Vector as Int32Vector, type index_Int64Vector as Int64Vector, type index_JITConfig as JITConfig, index_KernelBypassManager as KernelBypassManager, index_LatencyMonitor as LatencyMonitor, index_LatencyOptimizer as LatencyOptimizer, type index_LatencyStats as LatencyStats, index_LockFreeQueue as LockFreeQueue, index_LoopOptimizer as LoopOptimizer, index_MPMCQueue as MPMCQueue, index_MemoryMappedFile as MemoryMappedFile, index_MemoryOps as MemoryOps, index_MemoryPool as MemoryPool, type index_NUMAConfig as NUMAConfig, index_NUMAOptimizer as NUMAOptimizer, type index_OptimizationResult as OptimizationResult, index_OptimizedMath as OptimizedMath, index_PerformanceGovernor as PerformanceGovernor, index_ProfileGuidedOptimizer as ProfileGuidedOptimizer, type index_RealtimeConfig as RealtimeConfig, index_RealtimeTuner as RealtimeTuner, type index_SIMDCapabilities as SIMDCapabilities, type index_SIMDConfig as SIMDConfig, index_SIMDDetector as SIMDDetector, index_SchedulerPolicy as SchedulerPolicy, index_SpinLock as SpinLock, type index_SyscallBypassConfig as SyscallBypassConfig, index_SyscallBypassManager as SyscallBypassManager, index_ThreadPriority as ThreadPriority, index_ThreadPriorityLevel as ThreadPriorityLevel, index_TransactionBuilder as TransactionBuilder, type index_TransactionConfig as TransactionConfig, index_TransactionOptimizer as TransactionOptimizer, type index_TuningStats as TuningStats, type index_UltraLowLatencyConfig as UltraLowLatencyConfig, index_VectorizedMath as VectorizedMath, index_ZeroCopyBuffer as ZeroCopyBuffer, type index_ZeroCopySerializable as ZeroCopySerializable, index_ZeroCopySerializer as ZeroCopySerializer, index_busySpin as busySpin, index_busyWait as busyWait, index_calculateOptimalPrice as calculateOptimalPrice, index_coldPath as coldPath, index_copyBytes as copyBytes, index_createBufferPool as createBufferPool, index_createCPUAffinity as createCPUAffinity, index_createCacheOptimizer as createCacheOptimizer, index_createComputeBudgetOptimizer as createComputeBudgetOptimizer, index_createCryptoSIMD as createCryptoSIMD, index_createHardwareMonitor as createHardwareMonitor, index_createInstructionBatcher as createInstructionBatcher, index_createLatencyMonitor as createLatencyMonitor, index_createLockFreeQueue as createLockFreeQueue, index_createMPMCQueue as createMPMCQueue, index_createMemoryPool as createMemoryPool, index_createNUMAOptimizer as createNUMAOptimizer, index_createPerformanceGovernor as createPerformanceGovernor, index_createRealtimeTuner as createRealtimeTuner, index_createSIMDDetector as createSIMDDetector, index_createSerializer as createSerializer, index_createSyscallBypassManager as createSyscallBypassManager, index_createThreadPriority as createThreadPriority, index_createTimer as createTimer, index_createTransactionBuilder as createTransactionBuilder, index_createTransactionOptimizer as createTransactionOptimizer, index_createVectorizedMath as createVectorizedMath, index_createView as createView, index_createZeroCopyBuffer as createZeroCopyBuffer, index_defaultAffinityConfig as defaultAffinityConfig, index_defaultBufferPoolConfig as defaultBufferPoolConfig, index_defaultIOUringConfig as defaultIOUringConfig, index_defaultJITConfig as defaultJITConfig, index_defaultNUMAConfig as defaultNUMAConfig, index_defaultRealtimeConfig as defaultRealtimeConfig, index_defaultSIMDConfig as defaultSIMDConfig, index_defaultSyscallBypassConfig as defaultSyscallBypassConfig, index_defaultTransactionConfig as defaultTransactionConfig, index_defaultUltraLowLatencyConfig as defaultUltraLowLatencyConfig, index_detectCPUFeatures as detectCPUFeatures, index_estimateCompute as estimateCompute, index_fastInvSqrt as fastInvSqrt, index_fastNowMs as fastNowMs, index_fastNowNs as fastNowNs, index_fastNowUs as fastNowUs, index_getGlobalTimeProvider as getGlobalTimeProvider, index_getKernelBypassManager as getKernelBypassManager, index_getOptimalSIMDWidth as getOptimalSIMDWidth, index_getProfileOptimizer as getProfileOptimizer, index_getSystemCPUInfo as getSystemCPUInfo, index_getSystemMemoryInfo as getSystemMemoryInfo, index_hotPath as hotPath, index_isSIMDAvailable as isSIMDAvailable, index_likely as likely, index_measureTime as measureTime, index_prefetch as prefetch, index_prefetchArray as prefetchArray, index_prefetchHint as prefetchHint, index_profile as profile, index_spinLock as spinLock, index_unlikely as unlikely, index_yieldToEventLoop as yieldToEventLoop };
+}
+
+export { type SIMDCapabilities as $, type AffinityConfig as A, BranchOptimizer as B, CACHE_LINE_SIZE as C, DirectIOFile as D, type Int64Vector as E, FastTimeProvider as F, LatencyOptimizer as G, HardwareMonitor as H, IOBatchProcessor as I, type JITConfig as J, KernelBypassManager as K, LatencyMonitor as L, type LatencyStats as M, LockFreeQueue as N, LoopOptimizer as O, MPMCQueue as P, MemoryMappedFile as Q, MemoryOps as R, MemoryPool as S, type NUMAConfig as T, NUMAOptimizer as U, type OptimizationResult as V, OptimizedMath as W, PerformanceGovernor as X, ProfileGuidedOptimizer as Y, type RealtimeConfig as Z, RealtimeTuner as _, AlignedBuffer as a, getKernelBypassManager as a$, type SIMDConfig as a0, SIMDDetector as a1, SchedulerPolicy as a2, SpinLock as a3, type SyscallBypassConfig as a4, SyscallBypassManager as a5, ThreadPriority as a6, ThreadPriorityLevel as a7, TransactionBuilder as a8, type TransactionConfig as a9, createSIMDDetector as aA, createSerializer as aB, createSyscallBypassManager as aC, createThreadPriority as aD, createTimer as aE, createTransactionBuilder as aF, createTransactionOptimizer as aG, createVectorizedMath as aH, createView as aI, createZeroCopyBuffer as aJ, defaultAffinityConfig as aK, defaultBufferPoolConfig as aL, defaultIOUringConfig as aM, defaultJITConfig as aN, defaultNUMAConfig as aO, defaultRealtimeConfig as aP, defaultSIMDConfig as aQ, defaultSyscallBypassConfig as aR, defaultTransactionConfig as aS, defaultUltraLowLatencyConfig as aT, detectCPUFeatures as aU, estimateCompute as aV, fastInvSqrt as aW, fastNowMs as aX, fastNowNs as aY, fastNowUs as aZ, getGlobalTimeProvider as a_, TransactionOptimizer as aa, type TuningStats as ab, type UltraLowLatencyConfig as ac, VectorizedMath as ad, ZeroCopyBuffer as ae, type ZeroCopySerializable as af, ZeroCopySerializer as ag, busySpin as ah, busyWait as ai, calculateOptimalPrice as aj, coldPath as ak, copyBytes as al, createBufferPool as am, createCPUAffinity as an, createCacheOptimizer as ao, createComputeBudgetOptimizer as ap, createCryptoSIMD as aq, createHardwareMonitor as ar, createInstructionBatcher as as, createLatencyMonitor as at, createLockFreeQueue as au, createMPMCQueue as av, createMemoryPool as aw, createNUMAOptimizer as ax, createPerformanceGovernor as ay, createRealtimeTuner as az, AsyncSocket as b, getOptimalSIMDWidth as b0, getProfileOptimizer as b1, getSystemCPUInfo as b2, getSystemMemoryInfo as b3, hotPath as b4, isSIMDAvailable as b5, likely as b6, measureTime as b7, prefetch as b8, prefetchArray as b9, prefetchHint as ba, profile as bb, spinLock as bc, unlikely as bd, yieldToEventLoop as be, BufferPool as c, type BufferPoolConfig as d, type BufferView as e, CPUAffinity as f, type CPUFeatures as g, type CPUTopology as h, index as i, type CacheInfo as j, CacheOptimizer as k, ComputeBudgetOptimizer as l, type ComputeBudgetStats as m, CryptoSIMD as n, FixedBufferView as o, type Float32Vector as p, Float32x4 as q, type Float64Vector as r, FuncCache as s, IOOperation as t, type IORequest as u, type IOResult as v, type IOUringConfig as w, InstructionBatcher as x, type InstructionGroup as y, type Int32Vector as z };