@nxtedition/slice 1.1.9 → 1.1.11

package/README.md

@@ -10,7 +10,7 @@ Node.js `Buffer.subarray()` is slow. Every call creates a new `Buffer` object
 
 `Slice` avoids this entirely. It is a plain JavaScript object with `buffer`, `byteOffset`, and `byteLength` fields. Creating a slice is just setting three properties — no typed array wrapper creation, no GC pressure from short-lived `Buffer` objects. Operations like `toString`, `copy`, and `compare` delegate directly to the underlying buffer with the correct offsets.
 
-`PoolAllocator` takes this further. Like Node's internal pool, it has management overhead — but it rarely (if ever) allocates new backing stores, and because `Slice` is a plain object rather than a typed array, resizing or freeing a slice doesn't produce garbage for V8 to collect. It pre-allocates a large contiguous buffer and hands out regions using power-of-2 bucketing. When a slice is freed, its slot is recycled. When a slice is resized within the same bucket, no data moves at all — just a field update. This gives you `malloc`/`realloc`/`free` semantics with near-zero overhead per operation. The trade-off is upfront memory allocation and internal fragmentation from power-of-2 rounding — a 10-byte allocation uses a 16-byte slot. Buckets are also independent: a freed 16-byte slot cannot satisfy a 32-byte request, so the pool can become fragmented if allocation sizes are uneven. Use `stats` to monitor pool utilization and tune the pool size for your workload.
+`PoolAllocator` takes this further. Like Node's internal pool, it has management overhead — but for in-pool sizes it never allocates new backing stores (only allocations larger than the 256 KB top bucket, or made once the contiguous pool is exhausted, fall back to a standalone `Buffer`), and because `Slice` is a plain object rather than a typed array, resizing or freeing a slice doesn't produce garbage for V8 to collect. It pre-allocates a large contiguous buffer and hands out regions using power-of-2 bucketing. When a slice is freed, its slot is recycled. When a slice is resized within the same bucket, no data moves at all — just a field update. This gives you `malloc`/`realloc`/`free` semantics with near-zero overhead per operation. The trade-off is upfront memory allocation and internal fragmentation from power-of-2 rounding — a 10-byte allocation uses a 16-byte slot. Buckets are also independent: a freed 16-byte slot cannot satisfy a 32-byte request, so the pool can become fragmented if allocation sizes are uneven. Use `stats` to monitor pool utilization and tune the pool size for your workload.
 
 ## Install
 
@@ -89,28 +89,43 @@ A lightweight view over a `Buffer` with explicit offset and length tracking.
 
 #### `new Slice(buffer?: Buffer, byteOffset?: number, byteLength?: number, maxByteLength?: number)`
 
-Creates a new slice. All parameters are optional — defaults to an empty slice.
+Creates a new slice. All parameters are optional — defaults to an empty slice. The constructor does **no** validation; pass only consistent values, or use `Slice.from` for a checked construction.
+
+#### `Slice.from(buffer: Buffer, byteOffset?: number, byteLength?: number): Slice`
+
+Validated factory for wrapping an existing `Buffer`. `byteOffset` defaults to `0` and `byteLength` to the remaining bytes (`buffer.byteLength - byteOffset`). Throws `TypeError` if `buffer` is not a `Buffer`, and `RangeError` if `byteOffset`/`byteLength` are negative, non-integer, or `byteOffset + byteLength` exceeds the buffer. Prefer this over the bare constructor when the inputs are untrusted.
 
 #### Properties
 
 - `buffer: Buffer` — The underlying `Buffer`
 - `byteOffset: number` — Start offset into the buffer
 - `byteLength: number` — Current length in bytes
-- `maxByteLength: number` — Maximum capacity in bytes
+- `maxByteLength: number` — For a pool-allocated slice, the power-of-2 bucket capacity (always `>= byteLength`). For a manually-constructed slice it defaults to `byteLength` and is purely informational: no method bounds writes against it — reads and writes are validated/clamped against `byteLength`.
 - `length: number` — Alias for `byteLength`
 
 #### Methods
 
-- `reset(): void` — Clear the slice back to empty state. **Note:** this does not return the slot to the `PoolAllocator` — you must call `realloc(slice, 0)` to free pool memory.
-- `copy(target: Buffer | Slice, targetStart?: number, sourceStart?: number, sourceEnd?: number): number` — Copy data to a `Buffer` or `Slice`. Returns bytes copied.
-- `compare(target: Buffer | Slice, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1` — Compare with a `Buffer` or `Slice`
+- `reset(): void` — Clear the slice back to empty state. **Note:** this does not return the slot to the `PoolAllocator`. To free pool memory call `realloc(slice, 0)` — and do **not** `reset()` first: `reset()` detaches the slice from the pool buffer, so a subsequent `realloc(slice, 0)` can no longer locate the slot and the slot leaks.
+- `copy(target: Uint8Array | Slice, targetStart?: number, sourceStart?: number, sourceEnd?: number): number` — Copy data to a `Uint8Array`/`Buffer` or `Slice`. Returns bytes copied.
+- `compare(target: Uint8Array | Slice, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1` — Compare with a `Uint8Array`/`Buffer` or `Slice`
 - `write(string: string, offset?: number, length?: number, encoding?: BufferEncoding): number` — Write a string into the slice. Returns bytes written.
-- `set(source: Buffer | Slice | null | undefined, offset?: number): void` — Copy from a `Buffer` or `Slice` into this slice
-- `at(index: number): number` — Read byte at index (supports negative indexing)
+- `set(source: Buffer | Slice | null | undefined, offset?: number): void` — Copy from a `Buffer` or `Slice` into this slice. (A plain `Uint8Array` source is not accepted — it has no `copy` method.)
+- `at(index: number): number` — Read byte at integer index (supports negative indexing)
 - `test(expr: { test(buffer: Buffer, byteOffset: number, byteLength: number): boolean }): boolean` — Test the slice against an expression object
 - `toString(encoding?: BufferEncoding, start?: number, end?: number): string` — Convert to string
 - `toBuffer(start?: number, end?: number): Buffer` — Return a `Buffer` view
 
+#### Validation & bounds
+
+All offsets are **relative to the slice** (i.e. `0` is `byteOffset`). For a `Slice` target, target offsets are relative to that slice; for a raw `Buffer`/`Uint8Array` target they are absolute (passed straight through to the underlying `Buffer` method).
+
+The rule is consistent across the API:
+
+- **Start/offset arguments are validated** — `set`'s `offset`, `copy`/`compare`'s `sourceStart`/`targetStart`, `toString`/`toBuffer`'s `start`, `write`'s `offset`, and `at`'s `index` must be in-range integers. Out-of-range or non-integer values throw `RangeError`. This prevents a negative offset from resolving to a position **before** the slice and reading/writing adjacent (pool) memory.
+- **End arguments are clamped** — `sourceEnd`/`targetEnd`/`end` are clamped to the slice's logical length (matching `Buffer`'s lenient end-of-range behavior), so over-long ranges never read past the slice's end.
+- **`write`'s `length` is hybrid** — a negative or non-integer `length` throws `RangeError`, but a too-large `length` is clamped to the bytes available in the slice (it behaves like an end argument, not a strict start argument).
+- For a raw `Buffer`/`Uint8Array` target, `targetStart`/`targetEnd` (and a non-`Slice` `compare` target's range) are passed straight through to the underlying `Buffer` method, so they follow `Buffer`'s own coercion/validation rather than the rules above.
+
 #### Static
 
 - `Slice.EMPTY_BUF: Buffer` — Shared empty buffer singleton
@@ -119,19 +134,32 @@ Creates a new slice. All parameters are optional — defaults to an empty slice.
 
 Pre-allocates a contiguous memory pool and manages slices using power-of-2 bucketing.
 
-#### `new PoolAllocator(poolTotal?: number)`
+#### `new PoolAllocator(poolTotalOrBuffer?: number | Buffer | ArrayBufferView | ArrayBuffer | SharedArrayBuffer)`
 
-Creates a pool allocator. Default pool size is 128 MB.
+Creates a pool allocator. Pass a byte size to allocate a fresh backing buffer (default 128 MB, must be a non-negative integer), or pass an existing `Buffer`/`ArrayBufferView`/`ArrayBuffer`/`SharedArrayBuffer` to back the pool with caller-provided memory.
+
+> **Single-owner.** The allocator's bookkeeping lives in the instance, not in the backing buffer. When you supply your own buffer, that buffer must be owned exclusively by this allocator: do not build your own `Slice` views over it, do not share it with a second `PoolAllocator`, and (for a `SharedArrayBuffer`) do not allocate from more than one thread — the metadata is not shared or atomic, so doing any of these silently produces overlapping allocations.
 
 #### Methods
 
-- `realloc(slice: Slice, byteLength: number): Slice` — Allocate, resize, or free a slice. Pass `0` to free.
-- `isFromPool(slice: Slice | null | undefined): boolean` — Check if a slice was allocated from this pool
+- `realloc(byteLength: number): Slice` — Allocate a fresh slice.
+- `realloc(slice: Slice, byteLength: number): Slice` — Resize a slice, or free it by passing `0`. **Contents are not preserved** — `realloc` has `malloc` semantics, not C `realloc` semantics; after a resize the bytes are undefined (a same-bucket resize happens to keep them in place, but do not rely on it). Only call `realloc` with a slice that belongs to this allocator (or a fresh/empty `Slice`); passing a slice from another pool, or freeing the same pool slot through two aliasing `Slice` objects, corrupts the allocator's accounting. (Calling `realloc(slice, 0)` twice on the _same_ object is a harmless no-op — the first free empties the slice, so the second returns immediately.)
+- `isFromPool(slice: Slice | null | undefined): boolean` — Check if a slice's buffer is this pool's backing buffer. Note this is an identity check; it returns `true` for any slice over the same buffer, not only ones this allocator handed out.
+
+Allocations larger than 256 KB (the largest bucket), or made when the contiguous pool is exhausted, fall back to a fresh standalone `Buffer` (`isFromPool` returns `false`) and are excluded from `size`/`stats`.
 
 #### Properties
 
-- `size: number` — Total size of all active allocations
-- `stats: { size: number, padding: number, ratio: number, poolTotal: number, poolUsed: number, poolSize: number, poolCount: number }` — Detailed allocation statistics
+- `size: number` — Total reserved bytes of all active **pool** allocations (sum of bucket sizes; equals `stats.poolSize`).
+- `stats` — Detailed allocation statistics:
+  - `size` — same as the `size` getter (active pool bytes, including power-of-2 padding).
+  - `padding` — bytes lost to power-of-2 rounding across active pool slices.
+  - `ratio` — `size / (size - padding)`; `1` when there is no padding.
+  - `poolTotal` — capacity of the backing buffer in bytes.
+  - `poolUsed` — bump-pointer high-water mark; monotonic, never decreases.
+  - `poolSize` — active pool bytes (same as `size`).
+  - `poolCount` — number of distinct slots ever bump-allocated (monotonic high-water count, not a live count).
+  - `buckets` — per power-of-2 bucket: `{ free, used, size }`.
 
 ## License
 

package/lib/index.d.ts

@@ -4,7 +4,7 @@ export type SliceLike = {
     byteOffset: number;
     byteLength: number;
 };
-export declare class Slice {
+export declare class Slice implements SliceLike {
     buffer: Buffer;
     byteOffset: number;
     byteLength: number;
@@ -49,3 +49,4 @@ export declare class PoolAllocator {
         }[];
     };
 }
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAA;AAI5B,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,qBAAa,KAAM,YAAW,SAAS;IACrC,MAAM,EAAE,MAAM,CAAY;IAC1B,UAAU,EAAE,MAAM,CAAI;IACtB,UAAU,EAAE,MAAM,CAAI;IACtB,aAAa,EAAE,MAAM,CAAI;IAEzB,MAAM,KAAK,SAAS,IAAI,MAAM,CAE7B;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,SAAI,EAAE,UAAU,SAAiC,GAAG,KAAK;gBAuB7F,MAAM,0BAAkB,EACxB,UAAU,SAAI,EACd,UAAU,SAAoB,EAC9B,aAAa,SAAa;IAQ5B,KAAK,IAAI,IAAI;IAOb,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,CACF,MAAM,EAAE,UAAU,GAAG,KAAK,EAC1B,WAAW,CAAC,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM;IA0DT,OAAO,CACL,MAAM,EAAE,UAAU,GAAG,KAAK,EAC1B,WAAW,CAAC,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAgEb,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,MAAM;IA2B1F,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAyBrE,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IASzB,IAAI,CAAC,IAAI,EAAE;QACT,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAA;KAC1E,GAAG,OAAO;IAIX,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM;IA4BzE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM;IA8B9C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;CAkChC;AAED,qBAAa,aAAa;;gBAYtB,iBAAiB,GAAE,MAAM,GAAG,eAAe,GAAG,WAAW,GAAG,iBAAiB,GAAG,MAE1E;IAgCR,IAAI,IAAI,WAEP;IAED,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;IAIpD,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK;IAClC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,GAAG,KAAK;IAuGhD,IAAI,KAAK;;;;;;;;;;;;;MAeR;CACF"}

package/lib/index.js

@@ -1,463 +1,438 @@
-import util from 'node:util'
-
-const EMPTY_BUF = Buffer.alloc(0)
-
-                         
-                
-                    
-                    
- 
-
+import util from 'node:util';
+const EMPTY_BUF = Buffer.alloc(0);
 export class Slice {
-  buffer         = EMPTY_BUF
-  byteOffset         = 0
-  byteLength         = 0
-  maxByteLength         = 0
-
-  static get EMPTY_BUF()         {
-    return EMPTY_BUF
-  }
-
-  static from(buffer        , byteOffset = 0, byteLength = buffer.byteLength - byteOffset)        {
-    if (!(buffer instanceof Buffer)) {
-      throw new TypeError('buffer must be a Buffer')
+    buffer = EMPTY_BUF;
+    byteOffset = 0;
+    byteLength = 0;
+    maxByteLength = 0;
+    static get EMPTY_BUF() {
+        return EMPTY_BUF;
+    }
+    static from(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+        if (!(buffer instanceof Buffer)) {
+            throw new TypeError('buffer must be a Buffer');
+        }
+        if (byteOffset < 0 || !Number.isInteger(byteOffset)) {
+            throw new RangeError(`Invalid byteOffset: ${byteOffset}`);
+        }
+        if (byteLength < 0 || !Number.isInteger(byteLength)) {
+            throw new RangeError(`Invalid byteLength: ${byteLength}`);
+        }
+        if (byteOffset + byteLength > buffer.byteLength) {
+            throw new RangeError(`byteOffset + byteLength (${byteOffset + byteLength}) exceeds buffer size (${buffer.byteLength})`);
+        }
+        return new Slice(buffer, byteOffset, byteLength);
+    }
+    constructor(buffer = Slice.EMPTY_BUF, byteOffset = 0, byteLength = buffer.byteLength, maxByteLength = byteLength) {
+        this.buffer = buffer;
+        this.byteOffset = byteOffset;
+        this.byteLength = byteLength;
+        this.maxByteLength = maxByteLength;
+    }
+    reset() {
+        this.buffer = Slice.EMPTY_BUF;
+        this.byteOffset = 0;
+        this.byteLength = 0;
+        this.maxByteLength = 0;
+    }
+    get length() {
+        return this.byteLength;
+    }
+    copy(target, targetStart, sourceStart, sourceEnd) {
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (sourceStart === undefined) {
+            sourceStart = this.byteOffset;
+        }
+        else {
+            // Start offsets are validated (not clamped) so a negative offset can
+            // never resolve to a position before the slice and read adjacent
+            // (pool) memory.
+            if (sourceStart < 0 || sourceStart > this.byteLength || !Number.isInteger(sourceStart)) {
+                throw new RangeError(`Invalid sourceStart: ${sourceStart}`);
+            }
+            sourceStart += this.byteOffset;
+        }
+        if (sourceEnd === undefined) {
+            sourceEnd = sliceEnd;
+        }
+        else {
+            sourceEnd += this.byteOffset;
+        }
+        // Clamp the end against the logical slice length so copy() cannot read
+        // past the slice's own end and leak adjacent (pool) memory.
+        if (sourceEnd > sliceEnd) {
+            sourceEnd = sliceEnd;
+        }
+        if (sourceEnd < sourceStart) {
+            sourceEnd = sourceStart;
+        }
+        if (target instanceof Slice) {
+            const targetEnd = target.byteOffset + target.byteLength;
+            if (targetStart === undefined) {
+                targetStart = target.byteOffset;
+            }
+            else {
+                if (targetStart < 0 || targetStart > target.byteLength || !Number.isInteger(targetStart)) {
+                    throw new RangeError(`Invalid targetStart: ${targetStart}`);
+                }
+                targetStart += target.byteOffset;
+            }
+            target = target.buffer;
+            if (sourceEnd - sourceStart > targetEnd - targetStart) {
+                sourceEnd = sourceStart + (targetEnd - targetStart);
+            }
+        }
+        if (sourceStart === targetStart &&
+            this.buffer.buffer === target.buffer &&
+            this.buffer.byteOffset === target.byteOffset) {
+            return sourceEnd - sourceStart;
+        }
+        return this.buffer.copy(target, targetStart, sourceStart, sourceEnd);
+    }
+    compare(target, targetStart, targetEnd, sourceStart, sourceEnd) {
+        if (target === this &&
+            targetStart === undefined &&
+            targetEnd === undefined &&
+            sourceStart === undefined &&
+            sourceEnd === undefined) {
+            return 0;
+        }
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (target instanceof Slice) {
+            const targetSliceEnd = target.byteOffset + target.byteLength;
+            if (targetStart === undefined) {
+                targetStart = target.byteOffset;
+            }
+            else {
+                if (targetStart < 0 || targetStart > target.byteLength || !Number.isInteger(targetStart)) {
+                    throw new RangeError(`Invalid targetStart: ${targetStart}`);
+                }
+                targetStart += target.byteOffset;
+            }
+            if (targetEnd === undefined) {
+                targetEnd = targetSliceEnd;
+            }
+            else {
+                targetEnd += target.byteOffset;
+            }
+            if (targetEnd > targetSliceEnd) {
+                targetEnd = targetSliceEnd;
+            }
+            if (targetEnd < targetStart) {
+                targetEnd = targetStart;
+            }
+            target = target.buffer;
+        }
+        if (sourceStart === undefined) {
+            sourceStart = this.byteOffset;
+        }
+        else {
+            if (sourceStart < 0 || sourceStart > this.byteLength || !Number.isInteger(sourceStart)) {
+                throw new RangeError(`Invalid sourceStart: ${sourceStart}`);
+            }
+            sourceStart += this.byteOffset;
+        }
+        if (sourceEnd === undefined) {
+            sourceEnd = sliceEnd;
+        }
+        else {
+            sourceEnd += this.byteOffset;
+        }
+        if (sourceEnd > sliceEnd) {
+            sourceEnd = sliceEnd;
+        }
+        if (sourceEnd < sourceStart) {
+            sourceEnd = sourceStart;
+        }
+        return this.buffer.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);
+    }
+    write(string, offset, length, encoding) {
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (offset === undefined) {
+            offset = this.byteOffset;
+        }
+        else {
+            if (offset < 0 || offset > this.byteLength || !Number.isInteger(offset)) {
+                throw new RangeError(`Invalid offset: ${offset}`);
+            }
+            offset += this.byteOffset;
+        }
+        const available = sliceEnd - offset;
+        if (length === undefined) {
+            length = available;
+        }
+        else {
+            if (length < 0 || !Number.isInteger(length)) {
+                throw new RangeError(`Invalid length: ${length}`);
+            }
+            if (length > available) {
+                length = available;
+            }
+        }
+        return this.buffer.write(string, offset, length, encoding);
+    }
+    set(source, offset) {
+        if (source == null) {
+            return;
+        }
+        if (offset === undefined) {
+            offset = this.byteOffset;
+        }
+        else {
+            // Validate (not clamp): a negative offset would resolve to a position
+            // before the slice and corrupt adjacent (pool) memory.
+            if (offset < 0 || offset > this.byteLength || !Number.isInteger(offset)) {
+                throw new RangeError(`Invalid offset: ${offset}`);
+            }
+            offset += this.byteOffset;
+        }
+        const available = this.byteOffset + this.byteLength - offset;
+        if (available <= 0) {
+            return;
+        }
+        const end = source.byteLength < available ? source.byteLength : available;
+        source.copy(this.buffer, offset, 0, end);
+    }
+    at(index) {
+        if (!Number.isInteger(index) || index >= this.byteLength || index < -this.byteLength) {
+            throw new RangeError(`Index out of range: ${index}`);
+        }
+        return index >= 0
+            ? this.buffer[this.byteOffset + index]
+            : this.buffer[this.byteOffset + this.byteLength + index];
+    }
+    test(expr) {
+        return expr.test(this.buffer, this.byteOffset, this.byteLength);
+    }
+    toString(encoding, start, end) {
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (start === undefined) {
+            start = this.byteOffset;
+        }
+        else {
+            if (start < 0 || start > this.byteLength || !Number.isInteger(start)) {
+                throw new RangeError(`Invalid start: ${start}`);
+            }
+            start += this.byteOffset;
+        }
+        if (end === undefined) {
+            end = sliceEnd;
+        }
+        else {
+            end += this.byteOffset;
+        }
+        if (end > sliceEnd) {
+            end = sliceEnd;
+        }
+        if (end < start) {
+            end = start;
+        }
+        return this.buffer.toString(encoding, start, end);
+    }
+    toBuffer(start, end) {
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (start === undefined) {
+            start = this.byteOffset;
+        }
+        else {
+            if (start < 0 || start > this.byteLength || !Number.isInteger(start)) {
+                throw new RangeError(`Invalid start: ${start}`);
+            }
+            start += this.byteOffset;
+        }
+        if (end === undefined) {
+            end = sliceEnd;
+        }
+        else {
+            end += this.byteOffset;
+        }
+        if (end > sliceEnd) {
+            end = sliceEnd;
+        }
+        if (end < start) {
+            end = start;
+        }
+        return start === 0 && end === this.buffer.byteLength
+            ? this.buffer
+            : this.buffer.subarray(start, end);
+    }
+    get [Symbol.toStringTag]() {
+        return 'Slice';
+    }
+    [util.inspect.custom]() {
+        const MAX_BYTES = 32;
+        const len = this.byteLength;
+        // A malformed slice (a NaN/non-finite/fractional/negative/out-of-bounds
+        // byteOffset or byteLength) is exactly the state a developer inspects while
+        // debugging pool corruption — inspect must never throw on it. Coerce
+        // byteOffset to a safe integer index in [0, buffer.byteLength]: the
+        // `>= 0` test is false for NaN and -Infinity (→ 0), Math.floor truncates a
+        // fractional offset, and Math.min caps Infinity/oversize at the buffer end
+        // (available 0). Every buffer access below is then guaranteed in-bounds and
+        // begin + shown <= buffer.byteLength holds.
+        const bufferLength = this.buffer.byteLength;
+        const begin = this.byteOffset >= 0 ? Math.min(Math.floor(this.byteOffset), bufferLength) : 0;
+        const cap = bufferLength - begin;
+        const safeLen = len > 0 ? (len < cap ? len : cap) : 0;
+        const shown = safeLen < MAX_BYTES ? safeLen : MAX_BYTES;
+        let hex = '';
+        for (let i = 0; i < shown; i++) {
+            if (i !== 0) {
+                hex += ' ';
+            }
+            hex += this.buffer[begin + i].toString(16).padStart(2, '0');
+        }
+        if (shown < len) {
+            hex += ` ... (${len - shown} more)`;
+        }
+        const str = this.buffer.toString('utf8', begin, begin + shown);
+        const truncated = shown < len ? '…' : '';
+        return `Slice(${len}): "${str}${truncated}" <${hex}>`;
     }
-
-    if (byteOffset < 0 || !Number.isInteger(byteOffset)) {
-      throw new RangeError(`Invalid byteOffset: ${byteOffset}`)
-    }
-
-    if (byteLength < 0 || !Number.isInteger(byteLength)) {
-      throw new RangeError(`Invalid byteLength: ${byteLength}`)
-    }
-
-    if (byteOffset + byteLength > buffer.byteLength) {
-      throw new RangeError(
-        `byteOffset + byteLength (${byteOffset + byteLength}) exceeds buffer size (${buffer.byteLength})`,
-      )
-    }
-
-    return new Slice(buffer, byteOffset, byteLength)
-  }
-
-  constructor(
-    buffer = Slice.EMPTY_BUF,
-    byteOffset = 0,
-    byteLength = buffer.byteLength,
-    maxByteLength = byteLength,
-  ) {
-    this.buffer = buffer
-    this.byteOffset = byteOffset
-    this.byteLength = byteLength
-    this.maxByteLength = maxByteLength
-  }
-
-  reset()       {
-    this.buffer = Slice.EMPTY_BUF
-    this.byteOffset = 0
-    this.byteLength = 0
-    this.maxByteLength = 0
-  }
-
-  get length()         {
-    return this.byteLength
-  }
-
-  copy(
-    target                    ,
-    targetStart         ,
-    sourceStart         ,
-    sourceEnd         ,
-  )         {
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (sourceStart === undefined) {
-      sourceStart = this.byteOffset
-    } else {
-      sourceStart += this.byteOffset
-    }
-
-    if (sourceEnd === undefined) {
-      sourceEnd = sliceEnd
-    } else {
-      sourceEnd += this.byteOffset
-    }
-
-    // Clamp against the logical slice length so copy() cannot read past
-    // the slice's own end and leak adjacent (pool) memory.
-    if (sourceEnd > sliceEnd) {
-      sourceEnd = sliceEnd
-    }
-
-    if (target instanceof Slice) {
-      const targetEnd = target.byteOffset + target.byteLength
-      if (targetStart === undefined) {
-        targetStart = target.byteOffset
-      } else {
-        targetStart += target.byteOffset
-      }
-
-      target = target.buffer
-      if (sourceEnd - sourceStart > targetEnd - targetStart) {
-        sourceEnd = sourceStart + (targetEnd - targetStart)
-      }
-    }
-
-    if (
-      sourceStart === targetStart &&
-      this.buffer.buffer === target.buffer &&
-      this.buffer.byteOffset === target.byteOffset
-    ) {
-      return sourceEnd - sourceStart
-    }
-
-    return this.buffer.copy(target, targetStart, sourceStart, sourceEnd)
-  }
-
-  compare(
-    target                    ,
-    targetStart         ,
-    targetEnd         ,
-    sourceStart         ,
-    sourceEnd         ,
-  )             {
-    if (
-      target === this &&
-      targetStart === undefined &&
-      targetEnd === undefined &&
-      sourceStart === undefined &&
-      sourceEnd === undefined
-    ) {
-      return 0
-    }
-
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (target instanceof Slice) {
-      const targetSliceEnd = target.byteOffset + target.byteLength
-      if (targetStart === undefined) {
-        targetStart = target.byteOffset
-      } else {
-        targetStart += target.byteOffset
-      }
-
-      if (targetEnd === undefined) {
-        targetEnd = targetSliceEnd
-      } else {
-        targetEnd += target.byteOffset
-      }
-
-      if (targetEnd > targetSliceEnd) {
-        targetEnd = targetSliceEnd
-      }
-      target = target.buffer
-    }
-
-    if (sourceStart === undefined) {
-      sourceStart = this.byteOffset
-    } else {
-      sourceStart += this.byteOffset
-    }
-
-    if (sourceEnd === undefined) {
-      sourceEnd = sliceEnd
-    } else {
-      sourceEnd += this.byteOffset
-    }
-
-    if (sourceEnd > sliceEnd) {
-      sourceEnd = sliceEnd
-    }
-
-    return this.buffer.compare(target, targetStart, targetEnd, sourceStart, sourceEnd)
-  }
-
-  write(string        , offset         , length         , encoding                 )         {
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (offset === undefined) {
-      offset = this.byteOffset
-    } else {
-      if (offset < 0 || offset > this.byteLength) {
-        throw new RangeError(`Invalid offset: ${offset}`)
-      }
-      offset += this.byteOffset
-    }
-
-    const available = sliceEnd - offset
-    if (length === undefined) {
-      length = available
-    } else if (length > available) {
-      length = available
-    }
-
-    return this.buffer.write(string, offset, length, encoding)
-  }
-
-  set(source                                   , offset         )       {
-    if (source == null) {
-      return
-    }
-
-    if (offset === undefined) {
-      offset = this.byteOffset
-    } else {
-      offset += this.byteOffset
-    }
-
-    const available = this.byteOffset + this.byteLength - offset
-    if (available <= 0) {
-      return
-    }
-
-    const end = source.byteLength < available ? source.byteLength : available
-    source.copy(this.buffer, offset, 0, end)
-  }
-
-  at(index        )         {
-    if (index >= this.byteLength || index < -this.byteLength) {
-      throw new RangeError(`Index out of range: ${index}`)
-    }
-    return index >= 0
-      ? this.buffer[this.byteOffset + index]
-      : this.buffer[this.byteOffset + this.byteLength + index]
-  }
-
-  test(expr   
-                                                                             
-   )          {
-    return expr.test(this.buffer, this.byteOffset, this.byteLength)
-  }
-
-  toString(encoding                 , start         , end         )         {
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (start === undefined) {
-      start = this.byteOffset
-    } else {
-      start += this.byteOffset
-    }
-
-    if (end === undefined) {
-      end = sliceEnd
-    } else {
-      end += this.byteOffset
-    }
-
-    if (end > sliceEnd) {
-      end = sliceEnd
-    }
-
-    return this.buffer.toString(encoding, start, end)
-  }
-
-  toBuffer(start         , end         )         {
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (start === undefined) {
-      start = this.byteOffset
-    } else {
-      start += this.byteOffset
-    }
-
-    if (end === undefined) {
-      end = sliceEnd
-    } else {
-      end += this.byteOffset
-    }
-
-    if (end > sliceEnd) {
-      end = sliceEnd
-    }
-
-    return start === 0 && end === this.buffer.byteLength
-      ? this.buffer
-      : this.buffer.subarray(start, end)
-  }
-
-  get [Symbol.toStringTag]()         {
-    return 'Slice'
-  }
-
-  [util.inspect.custom]()         {
-    const MAX_BYTES = 32
-    const len = this.byteLength
-    const shown = len < MAX_BYTES ? len : MAX_BYTES
-
-    let hex = ''
-    for (let i = 0; i < shown; i++) {
-      if (i !== 0) {
-        hex += ' '
-      }
-      hex += this.buffer[this.byteOffset + i].toString(16).padStart(2, '0')
-    }
-    if (shown < len) {
-      hex += ` ... (${len - shown} more)`
-    }
-
-    const strEnd = shown < len ? this.byteOffset + shown : this.byteOffset + len
-    const str = this.buffer.toString('utf8', this.byteOffset, strEnd)
-    const truncated = shown < len ? '…' : ''
-
-    return `Slice(${len}): "${str}${truncated}" <${hex}>`
-  }
 }
-
 export class PoolAllocator {
-  #size = 0
-  #padding = 0
-
-  #poolsBucket             = []
-  #poolsBucketUsed           = []
-  #poolBuffer        
-  #poolOffset = 0
-  #poolSize = 0
-  #poolCount = 0
-
-  constructor(
-    poolTotalOrBuffer                                                                      = 128 *
-      1024 *
-      1024,
-  ) {
-    if (typeof poolTotalOrBuffer === 'number') {
-      this.#poolBuffer = Buffer.allocUnsafeSlow(poolTotalOrBuffer)
-    } else if (poolTotalOrBuffer instanceof Buffer) {
-      this.#poolBuffer = poolTotalOrBuffer
-    } else if (ArrayBuffer.isView(poolTotalOrBuffer)) {
-      this.#poolBuffer = Buffer.from(
-        poolTotalOrBuffer.buffer,
-        poolTotalOrBuffer.byteOffset,
-        poolTotalOrBuffer.byteLength,
-      )
-    } else if (
-      poolTotalOrBuffer instanceof ArrayBuffer ||
-      poolTotalOrBuffer instanceof SharedArrayBuffer
-    ) {
-      this.#poolBuffer = Buffer.from(poolTotalOrBuffer)
-    } else {
-      throw new TypeError(
-        'Invalid poolTotalOrBuffer: must be a Buffer, ArrayBufferView, ArrayBuffer, SharedArrayBuffer, or number',
-      )
-    }
-
-    for (let n = 0; 2 ** n <= 256 * 1024; n++) {
-      this.#poolsBucket.push([])
-      this.#poolsBucketUsed.push(0)
-    }
-  }
-
-  get size() {
-    return this.#size
-  }
-
-  isFromPool(slice                          )          {
-    return slice != null && slice.buffer === this.#poolBuffer
-  }
-
-                                    
-                                                  
-  realloc(slice                , byteLength         )        {
-    if (typeof slice === 'number') {
-      byteLength = slice
-      slice = new Slice()
-    }
-
-    if (byteLength == null || !Number.isInteger(byteLength) || byteLength < 0) {
-      throw new TypeError(`Invalid byteLength: ${byteLength}`)
-    }
-
-    // 2^30 is the largest power-of-two that fits a 32-bit signed int; a
-    // larger request overflows `1 << dstIdx` to a negative bucket size.
-    if (byteLength > 1 << 30) {
-      throw new RangeError(`byteLength too large: ${byteLength} (max ${1 << 30})`)
-    }
-
-    if (slice.byteLength === byteLength) {
-      return slice
-    }
-
-    // Ceil to nearest power of two.
-    const dstIdx = byteLength <= 8 ? 3 : 32 - Math.clz32(byteLength - 1)
-
-    if (slice.buffer === this.#poolBuffer) {
-      const srcIdx = 32 - Math.clz32(slice.maxByteLength - 1)
-
-      if (slice.maxByteLength !== 1 << srcIdx) {
-        throw new Error(`Invalid pool state`)
-      }
-
-      this.#size -= slice.maxByteLength
-      this.#padding -= slice.maxByteLength - slice.byteLength
-
-      if (srcIdx === dstIdx) {
-        slice.byteLength = byteLength
-        this.#size += slice.maxByteLength
-        this.#padding += slice.maxByteLength - slice.byteLength
-        return slice
-      }
-
-      this.#poolsBucket[srcIdx].push(slice.byteOffset)
-      this.#poolsBucketUsed[srcIdx] -= 1
-      this.#poolSize -= slice.maxByteLength
-    }
-
-    slice.reset()
-
-    if (byteLength === 0) {
-      return slice
-    }
-
-    const maxByteLength = 1 << dstIdx
-
-    if (dstIdx < this.#poolsBucket.length && this.#poolsBucket[dstIdx].length) {
-      slice.buffer = this.#poolBuffer
-      slice.byteOffset = this.#poolsBucket[dstIdx].pop() 
-      slice.byteLength = byteLength
-      slice.maxByteLength = maxByteLength
-
-      this.#poolsBucketUsed[dstIdx] += 1
-      this.#poolSize += maxByteLength
-      this.#size += maxByteLength
-      this.#padding += maxByteLength - byteLength
-    } else if (
-      dstIdx < this.#poolsBucket.length &&
-      this.#poolOffset + maxByteLength <= this.#poolBuffer.byteLength
-    ) {
-      slice.buffer = this.#poolBuffer
-      slice.byteOffset = this.#poolOffset
-      slice.byteLength = byteLength
-      slice.maxByteLength = maxByteLength
-
-      this.#poolOffset += maxByteLength
-      this.#poolCount += 1
-      this.#poolsBucketUsed[dstIdx] += 1
-      this.#poolSize += maxByteLength
-      this.#size += maxByteLength
-      this.#padding += maxByteLength - byteLength
-    } else {
-      slice.buffer = Buffer.allocUnsafeSlow(byteLength)
-      slice.byteOffset = 0
-      slice.byteLength = byteLength
-      slice.maxByteLength = byteLength
-    }
-
-    return slice
-  }
-
-  get stats() {
-    return {
-      size: this.#size,
-      padding: this.#padding,
-      ratio: this.#size > this.#padding ? this.#size / (this.#size - this.#padding) : 1,
-      poolTotal: this.#poolBuffer.byteLength,
-      poolUsed: this.#poolOffset,
-      poolSize: this.#poolSize,
-      poolCount: this.#poolCount,
-      buckets: this.#poolsBucket.map((pool, i) => ({
-        free: pool.length,
-        used: this.#poolsBucketUsed[i],
-        size: pool.length + this.#poolsBucketUsed[i],
-      })),
+    #size = 0;
+    #padding = 0;
+    #poolsBucket = [];
+    #poolsBucketUsed = [];
+    #poolBuffer;
+    #poolOffset = 0;
+    #poolSize = 0;
+    #poolCount = 0;
+    constructor(poolTotalOrBuffer = 128 *
+        1024 *
+        1024) {
+        if (typeof poolTotalOrBuffer === 'number') {
+            if (!Number.isInteger(poolTotalOrBuffer) || poolTotalOrBuffer < 0) {
+                throw new RangeError(`Invalid pool size: ${poolTotalOrBuffer}`);
+            }
+            this.#poolBuffer = Buffer.allocUnsafeSlow(poolTotalOrBuffer);
+        }
+        else if (poolTotalOrBuffer instanceof Buffer) {
+            this.#poolBuffer = poolTotalOrBuffer;
+        }
+        else if (ArrayBuffer.isView(poolTotalOrBuffer)) {
+            this.#poolBuffer = Buffer.from(poolTotalOrBuffer.buffer, poolTotalOrBuffer.byteOffset, poolTotalOrBuffer.byteLength);
+        }
+        else if (poolTotalOrBuffer instanceof ArrayBuffer ||
+            poolTotalOrBuffer instanceof SharedArrayBuffer) {
+            this.#poolBuffer = Buffer.from(poolTotalOrBuffer);
+        }
+        else {
+            throw new TypeError('Invalid poolTotalOrBuffer: must be a Buffer, ArrayBufferView, ArrayBuffer, SharedArrayBuffer, or number');
+        }
+        for (let n = 0; 2 ** n <= 256 * 1024; n++) {
+            this.#poolsBucket.push([]);
+            this.#poolsBucketUsed.push(0);
+        }
+    }
+    get size() {
+        return this.#size;
+    }
+    isFromPool(slice) {
+        return slice != null && slice.buffer === this.#poolBuffer;
+    }
+    realloc(slice, byteLength) {
+        if (typeof slice === 'number') {
+            byteLength = slice;
+            slice = new Slice();
+        }
+        if (byteLength == null || !Number.isInteger(byteLength) || byteLength < 0) {
+            throw new TypeError(`Invalid byteLength: ${byteLength}`);
+        }
+        // 2^30 is the largest power-of-two that fits a 32-bit signed int; a
+        // larger request overflows `1 << dstIdx` to a negative bucket size.
+        if (byteLength > 1 << 30) {
+            throw new RangeError(`byteLength too large: ${byteLength} (max ${1 << 30})`);
+        }
+        if (slice.byteLength === byteLength) {
+            return slice;
+        }
+        // Ceil to nearest power of two — the destination bucket and its byte size.
+        const dstIdx = byteLength <= 8 ? 3 : 32 - Math.clz32(byteLength - 1);
+        const maxByteLength = 1 << dstIdx;
+        if (slice.buffer === this.#poolBuffer) {
+            const srcMaxByteLength = slice.maxByteLength;
+            // Same-bucket resize is the hot path: just update the logical length and
+            // adjust padding by the delta — no bucket bookkeeping, no second clz32,
+            // no net change to #size. A free (byteLength === 0) is deliberately
+            // excluded so it always falls through to the free-list path below:
+            // byteLength 0 maps to dstIdx 3 / maxByteLength 8, which would otherwise
+            // match a live bucket-3 slot here and "resize" it to 0 — leaking the slot
+            // (never returned to the free list, still counted in #size/#poolSize).
+            if (byteLength !== 0 && srcMaxByteLength === maxByteLength) {
+                this.#padding += slice.byteLength - byteLength;
+                slice.byteLength = byteLength;
+                return slice;
+            }
+            const srcIdx = 32 - Math.clz32(srcMaxByteLength - 1);
+            // Corruption tripwire for a foreign/double-freed slice. maxByteLength must
+            // be a power of two that maps to a real pool bucket — index in
+            // [3, poolsBucket.length). The pool never hands out a slot below bucket 3
+            // (8 bytes), so a smaller power of two (1/2/4 → srcIdx 0/1/2) is just as
+            // corrupt as an oversized one (e.g. 2^20 → srcIdx 20, out of range):
+            // `=== 1 << srcIdx` alone passes both, after which the bucket bookkeeping
+            // below would drive an always-empty bucket's `used` count negative (or
+            // index a non-existent bucket) and drift #size/#poolSize.
+            if (srcMaxByteLength !== 1 << srcIdx || srcIdx < 3 || srcIdx >= this.#poolsBucket.length) {
+                throw new Error(`Invalid pool state`);
+            }
+            this.#size -= srcMaxByteLength;
+            this.#padding -= srcMaxByteLength - slice.byteLength;
+            this.#poolsBucket[srcIdx].push(slice.byteOffset);
+            this.#poolsBucketUsed[srcIdx] -= 1;
+            this.#poolSize -= srcMaxByteLength;
+        }
+        slice.reset();
+        if (byteLength === 0) {
+            return slice;
+        }
+        if (dstIdx < this.#poolsBucket.length && this.#poolsBucket[dstIdx].length) {
+            slice.buffer = this.#poolBuffer;
+            slice.byteOffset = this.#poolsBucket[dstIdx].pop();
+            slice.byteLength = byteLength;
+            slice.maxByteLength = maxByteLength;
+            this.#poolsBucketUsed[dstIdx] += 1;
+            this.#poolSize += maxByteLength;
+            this.#size += maxByteLength;
+            this.#padding += maxByteLength - byteLength;
+        }
+        else if (dstIdx < this.#poolsBucket.length &&
+            this.#poolOffset + maxByteLength <= this.#poolBuffer.byteLength) {
+            slice.buffer = this.#poolBuffer;
+            slice.byteOffset = this.#poolOffset;
+            slice.byteLength = byteLength;
+            slice.maxByteLength = maxByteLength;
+            this.#poolOffset += maxByteLength;
+            this.#poolCount += 1;
+            this.#poolsBucketUsed[dstIdx] += 1;
+            this.#poolSize += maxByteLength;
+            this.#size += maxByteLength;
+            this.#padding += maxByteLength - byteLength;
+        }
+        else {
+            slice.buffer = Buffer.allocUnsafeSlow(byteLength);
+            slice.byteOffset = 0;
+            slice.byteLength = byteLength;
+            slice.maxByteLength = byteLength;
+        }
+        return slice;
+    }
+    get stats() {
+        return {
+            size: this.#size,
+            padding: this.#padding,
+            ratio: this.#size > this.#padding ? this.#size / (this.#size - this.#padding) : 1,
+            poolTotal: this.#poolBuffer.byteLength,
+            poolUsed: this.#poolOffset,
+            poolSize: this.#poolSize,
+            poolCount: this.#poolCount,
+            buckets: this.#poolsBucket.map((pool, i) => ({
+                free: pool.length,
+                used: this.#poolsBucketUsed[i],
+                size: pool.length + this.#poolsBucketUsed[i],
+            })),
+        };
     }
-  }
 }
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/slice",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -14,7 +14,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib && tsc -p tsconfig.build.json && amaroc ./src/index.ts && mv src/index.js lib/",
+    "build": "rimraf lib && tsc -p tsconfig.build.json",
     "prepublishOnly": "yarn build",
     "typecheck": "tsc --noEmit",
     "test": "yarn build && node --test",
@@ -24,11 +24,10 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "amaroc": "^1.0.1",
     "oxlint-tsgolint": "^0.17.0",
     "rimraf": "^6.1.3",
     "tsd": "^0.33.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "2c131da7ca8ea328fd681e975dd7caf57f9f4896"
+  "gitHead": "7c9c7457c885c644c7a1e70ef894d4727ce240d6"
 }