@btc-vision/bitcoin 7.0.0-alpha.2 → 7.0.0-alpha.4

package/browser/io/MemoryPool.d.ts

@@ -1,220 +0,0 @@
-/**
- * Memory pool using SharedArrayBuffer for zero-allocation operations.
- *
- * Provides thread-safe memory allocation using Atomics for concurrent access.
- * Ideal for parsing operations where temporary buffers are needed.
- *
- * @packageDocumentation
- */
-/**
- * Thread-safe memory pool using SharedArrayBuffer.
- *
- * Allocates memory from a pre-allocated SharedArrayBuffer pool,
- * eliminating garbage collection pressure from repeated allocations.
- *
- * Uses Atomics for thread-safe allocation when used with Workers.
- *
- * @example
- * ```typescript
- * import { MemoryPool } from '@btc-vision/bitcoin';
- *
- * // Create a 1MB pool
- * const pool = new MemoryPool(1024 * 1024);
- *
- * // Allocate memory for transaction parsing
- * const txBuffer = pool.alloc(500);
- * // ... use txBuffer ...
- *
- * // Reset pool when done (all allocations become invalid)
- * pool.reset();
- * ```
- */
-export declare class MemoryPool {
-    #private;
-    /**
-     * Creates a new MemoryPool.
-     *
-     * @param size - Size of the pool in bytes (default 4MB)
-     *
-     * @example
-     * ```typescript
-     * import { MemoryPool } from '@btc-vision/bitcoin';
-     *
-     * // 4MB pool (default)
-     * const pool = new MemoryPool();
-     *
-     * // 16MB pool
-     * const largePool = new MemoryPool(16 * 1024 * 1024);
-     * ```
-     */
-    constructor(size?: number);
-    /**
-     * Total capacity of the pool in bytes.
-     */
-    get capacity(): number;
-    /**
-     * Current allocation offset (bytes used).
-     *
-     * Uses Atomics for thread-safe reading.
-     */
-    get used(): number;
-    /**
-     * Remaining available bytes.
-     */
-    get available(): number;
-    /**
-     * The underlying SharedArrayBuffer.
-     *
-     * Can be transferred to Workers for shared memory access.
-     */
-    get sharedBuffer(): SharedArrayBuffer;
-    /**
-     * Creates a MemoryPool from an existing SharedArrayBuffer.
-     *
-     * Useful for sharing a pool between Workers.
-     *
-     * @param buffer - Existing SharedArrayBuffer
-     * @returns A new MemoryPool instance wrapping the buffer
-     *
-     * @example
-     * ```typescript
-     * // Main thread
-     * const pool = new MemoryPool(1024 * 1024);
-     * worker.postMessage({ buffer: pool.sharedBuffer });
-     *
-     * // Worker thread
-     * self.onmessage = (e) => {
-     *     const pool = MemoryPool.fromSharedBuffer(e.data.buffer);
-     *     const mem = pool.alloc(100);
-     * };
-     * ```
-     */
-    static fromSharedBuffer(buffer: SharedArrayBuffer): MemoryPool;
-    /**
-     * Allocates memory from the pool.
-     *
-     * Thread-safe using Atomics.add for concurrent access.
-     *
-     * @param size - Number of bytes to allocate
-     * @returns Uint8Array view into the pool
-     * @throws RangeError if pool is exhausted
-     *
-     * @example
-     * ```typescript
-     * const pool = new MemoryPool(1024);
-     * const buf1 = pool.alloc(100); // First 100 bytes
-     * const buf2 = pool.alloc(200); // Next 200 bytes
-     * ```
-     */
-    alloc(size: number): Uint8Array;
-    /**
-     * Allocates memory and fills it with zeros.
-     *
-     * @param size - Number of bytes to allocate
-     * @returns Uint8Array view into the pool, filled with zeros
-     * @throws RangeError if pool is exhausted
-     */
-    allocZeroed(size: number): Uint8Array;
-    /**
-     * Allocates memory for a specific typed array.
-     *
-     * @param length - Number of elements
-     * @param bytesPerElement - Size of each element in bytes
-     * @returns Uint8Array view (use constructor of target type on underlying buffer)
-     * @throws RangeError if pool is exhausted
-     *
-     * @example
-     * ```typescript
-     * const pool = new MemoryPool(1024);
-     * const bytes = pool.allocTyped(10, 4); // 40 bytes for 10 Uint32
-     * const u32View = new Uint32Array(bytes.buffer, bytes.byteOffset, 10);
-     * ```
-     */
-    allocTyped(length: number, bytesPerElement: number): Uint8Array;
-    /**
-     * Resets the pool, making all memory available again.
-     *
-     * WARNING: All previously allocated views become invalid.
-     * Only call when you're sure no references are held.
-     *
-     * Thread-safe using Atomics.store.
-     *
-     * @example
-     * ```typescript
-     * const pool = new MemoryPool(1024);
-     * const buf = pool.alloc(100);
-     * // ... use buf ...
-     * pool.reset(); // buf is now invalid!
-     * ```
-     */
-    reset(): void;
-    /**
-     * Checks if the pool can accommodate an allocation.
-     *
-     * @param size - Number of bytes needed
-     * @returns True if allocation would succeed
-     */
-    canAlloc(size: number): boolean;
-}
-/**
- * Non-shared memory pool using regular ArrayBuffer.
- *
- * Use when SharedArrayBuffer is not available (e.g., browsers without
- * proper COOP/COEP headers) or when thread-safety is not needed.
- *
- * @example
- * ```typescript
- * import { SimpleMemoryPool } from '@btc-vision/bitcoin';
- *
- * const pool = new SimpleMemoryPool(1024 * 1024);
- * const buf = pool.alloc(100);
- * ```
- */
-export declare class SimpleMemoryPool {
-    #private;
-    /**
-     * Creates a new SimpleMemoryPool.
-     *
-     * @param size - Size of the pool in bytes
-     */
-    constructor(size: number);
-    /**
-     * Total capacity of the pool in bytes.
-     */
-    get capacity(): number;
-    /**
-     * Current allocation offset (bytes used).
-     */
-    get used(): number;
-    /**
-     * Remaining available bytes.
-     */
-    get available(): number;
-    /**
-     * Allocates memory from the pool.
-     *
-     * @param size - Number of bytes to allocate
-     * @returns Uint8Array view into the pool
-     * @throws RangeError if pool is exhausted
-     */
-    alloc(size: number): Uint8Array;
-    /**
-     * Allocates memory and fills it with zeros.
-     *
-     * @param size - Number of bytes to allocate
-     * @returns Uint8Array view into the pool, filled with zeros
-     */
-    allocZeroed(size: number): Uint8Array;
-    /**
-     * Resets the pool, making all memory available again.
-     */
-    reset(): void;
-    /**
-     * Checks if the pool can accommodate an allocation.
-     *
-     * @param size - Number of bytes needed
-     * @returns True if allocation would succeed
-     */
-    canAlloc(size: number): boolean;
-}
-//# sourceMappingURL=MemoryPool.d.ts.map

package/browser/io/MemoryPool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MemoryPool.d.ts","sourceRoot":"","sources":["../../src/io/MemoryPool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU;;IAsBnB;;;;;;;;;;;;;;;OAeG;gBACgB,IAAI,GAAE,MAAwB;IASjD;;OAEG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;;OAIG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;OAIG;IACH,IAAW,YAAY,IAAI,iBAAiB,CAE3C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,GAAG,UAAU;IAarE;;;;;;;;;;;;;;;OAeG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAmBtC;;;;;;OAMG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM5C;;;;;;;;;;;;;;OAcG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,UAAU;IAItE;;;;;;;;;;;;;;;OAeG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGzC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB;;IAIzB;;;;OAIG;gBACgB,IAAI,EAAE,MAAM;IAI/B;;OAEG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;;;OAMG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAgBtC;;;;;OAKG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM5C;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGzC"}

package/build/io/MemoryPool.d.ts

@@ -1,220 +0,0 @@
-/**
- * Memory pool using SharedArrayBuffer for zero-allocation operations.
- *
- * Provides thread-safe memory allocation using Atomics for concurrent access.
- * Ideal for parsing operations where temporary buffers are needed.
- *
- * @packageDocumentation
- */
-/**
- * Thread-safe memory pool using SharedArrayBuffer.
- *
- * Allocates memory from a pre-allocated SharedArrayBuffer pool,
- * eliminating garbage collection pressure from repeated allocations.
- *
- * Uses Atomics for thread-safe allocation when used with Workers.
- *
- * @example
- * ```typescript
- * import { MemoryPool } from '@btc-vision/bitcoin';
- *
- * // Create a 1MB pool
- * const pool = new MemoryPool(1024 * 1024);
- *
- * // Allocate memory for transaction parsing
- * const txBuffer = pool.alloc(500);
- * // ... use txBuffer ...
- *
- * // Reset pool when done (all allocations become invalid)
- * pool.reset();
- * ```
- */
-export declare class MemoryPool {
-    #private;
-    /**
-     * Creates a new MemoryPool.
-     *
-     * @param size - Size of the pool in bytes (default 4MB)
-     *
-     * @example
-     * ```typescript
-     * import { MemoryPool } from '@btc-vision/bitcoin';
-     *
-     * // 4MB pool (default)
-     * const pool = new MemoryPool();
-     *
-     * // 16MB pool
-     * const largePool = new MemoryPool(16 * 1024 * 1024);
-     * ```
-     */
-    constructor(size?: number);
-    /**
-     * Total capacity of the pool in bytes.
-     */
-    get capacity(): number;
-    /**
-     * Current allocation offset (bytes used).
-     *
-     * Uses Atomics for thread-safe reading.
-     */
-    get used(): number;
-    /**
-     * Remaining available bytes.
-     */
-    get available(): number;
-    /**
-     * The underlying SharedArrayBuffer.
-     *
-     * Can be transferred to Workers for shared memory access.
-     */
-    get sharedBuffer(): SharedArrayBuffer;
-    /**
-     * Creates a MemoryPool from an existing SharedArrayBuffer.
-     *
-     * Useful for sharing a pool between Workers.
-     *
-     * @param buffer - Existing SharedArrayBuffer
-     * @returns A new MemoryPool instance wrapping the buffer
-     *
-     * @example
-     * ```typescript
-     * // Main thread
-     * const pool = new MemoryPool(1024 * 1024);
-     * worker.postMessage({ buffer: pool.sharedBuffer });
-     *
-     * // Worker thread
-     * self.onmessage = (e) => {
-     *     const pool = MemoryPool.fromSharedBuffer(e.data.buffer);
-     *     const mem = pool.alloc(100);
-     * };
-     * ```
-     */
-    static fromSharedBuffer(buffer: SharedArrayBuffer): MemoryPool;
-    /**
-     * Allocates memory from the pool.
-     *
-     * Thread-safe using Atomics.add for concurrent access.
-     *
-     * @param size - Number of bytes to allocate
-     * @returns Uint8Array view into the pool
-     * @throws RangeError if pool is exhausted
-     *
-     * @example
-     * ```typescript
-     * const pool = new MemoryPool(1024);
-     * const buf1 = pool.alloc(100); // First 100 bytes
-     * const buf2 = pool.alloc(200); // Next 200 bytes
-     * ```
-     */
-    alloc(size: number): Uint8Array;
-    /**
-     * Allocates memory and fills it with zeros.
-     *
-     * @param size - Number of bytes to allocate
-     * @returns Uint8Array view into the pool, filled with zeros
-     * @throws RangeError if pool is exhausted
-     */
-    allocZeroed(size: number): Uint8Array;
-    /**
-     * Allocates memory for a specific typed array.
-     *
-     * @param length - Number of elements
-     * @param bytesPerElement - Size of each element in bytes
-     * @returns Uint8Array view (use constructor of target type on underlying buffer)
-     * @throws RangeError if pool is exhausted
-     *
-     * @example
-     * ```typescript
-     * const pool = new MemoryPool(1024);
-     * const bytes = pool.allocTyped(10, 4); // 40 bytes for 10 Uint32
-     * const u32View = new Uint32Array(bytes.buffer, bytes.byteOffset, 10);
-     * ```
-     */
-    allocTyped(length: number, bytesPerElement: number): Uint8Array;
-    /**
-     * Resets the pool, making all memory available again.
-     *
-     * WARNING: All previously allocated views become invalid.
-     * Only call when you're sure no references are held.
-     *
-     * Thread-safe using Atomics.store.
-     *
-     * @example
-     * ```typescript
-     * const pool = new MemoryPool(1024);
-     * const buf = pool.alloc(100);
-     * // ... use buf ...
-     * pool.reset(); // buf is now invalid!
-     * ```
-     */
-    reset(): void;
-    /**
-     * Checks if the pool can accommodate an allocation.
-     *
-     * @param size - Number of bytes needed
-     * @returns True if allocation would succeed
-     */
-    canAlloc(size: number): boolean;
-}
-/**
- * Non-shared memory pool using regular ArrayBuffer.
- *
- * Use when SharedArrayBuffer is not available (e.g., browsers without
- * proper COOP/COEP headers) or when thread-safety is not needed.
- *
- * @example
- * ```typescript
- * import { SimpleMemoryPool } from '@btc-vision/bitcoin';
- *
- * const pool = new SimpleMemoryPool(1024 * 1024);
- * const buf = pool.alloc(100);
- * ```
- */
-export declare class SimpleMemoryPool {
-    #private;
-    /**
-     * Creates a new SimpleMemoryPool.
-     *
-     * @param size - Size of the pool in bytes
-     */
-    constructor(size: number);
-    /**
-     * Total capacity of the pool in bytes.
-     */
-    get capacity(): number;
-    /**
-     * Current allocation offset (bytes used).
-     */
-    get used(): number;
-    /**
-     * Remaining available bytes.
-     */
-    get available(): number;
-    /**
-     * Allocates memory from the pool.
-     *
-     * @param size - Number of bytes to allocate
-     * @returns Uint8Array view into the pool
-     * @throws RangeError if pool is exhausted
-     */
-    alloc(size: number): Uint8Array;
-    /**
-     * Allocates memory and fills it with zeros.
-     *
-     * @param size - Number of bytes to allocate
-     * @returns Uint8Array view into the pool, filled with zeros
-     */
-    allocZeroed(size: number): Uint8Array;
-    /**
-     * Resets the pool, making all memory available again.
-     */
-    reset(): void;
-    /**
-     * Checks if the pool can accommodate an allocation.
-     *
-     * @param size - Number of bytes needed
-     * @returns True if allocation would succeed
-     */
-    canAlloc(size: number): boolean;
-}
-//# sourceMappingURL=MemoryPool.d.ts.map

package/build/io/MemoryPool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MemoryPool.d.ts","sourceRoot":"","sources":["../../src/io/MemoryPool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU;;IAsBnB;;;;;;;;;;;;;;;OAeG;gBACgB,IAAI,GAAE,MAAwB;IASjD;;OAEG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;;OAIG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;OAIG;IACH,IAAW,YAAY,IAAI,iBAAiB,CAE3C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,GAAG,UAAU;IAarE;;;;;;;;;;;;;;;OAeG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAmBtC;;;;;;OAMG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM5C;;;;;;;;;;;;;;OAcG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,UAAU;IAItE;;;;;;;;;;;;;;;OAeG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGzC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB;;IAIzB;;;;OAIG;gBACgB,IAAI,EAAE,MAAM;IAI/B;;OAEG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;;;OAMG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAgBtC;;;;;OAKG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM5C;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGzC"}