@nxtedition/slice 1.1.10 → 1.1.12

package/README.md

@@ -34,52 +34,56 @@ const s = new Slice()
 
 pool.realloc(s, 64) // allocate 64 bytes from pool
 s.write('hello')
-pool.realloc(s, 128) // grow — may reuse same slot
+pool.realloc(s, 128) // grow — moves to the 128-byte bucket (contents not preserved)
+pool.realloc(s, 100) // shrink within the bucket — in-place, just a field update
 pool.realloc(s, 0) // free — slot is recycled
 ```
 
 ## Benchmarks
 
-Measured on Apple M3 Pro, Node.js v25.3.0:
+Measured on Apple M3 Pro, Node.js v25.6.1. Every `PoolAllocator` iteration performs a real alloc + free pair (a bare repeated `realloc(slice, N)` would hit the same-size early return and measure a no-op).
 
-### Allocation
+### Allocation (alloc + free per iteration)
 
-| Operation        | `Buffer.allocUnsafe` | `Buffer.allocUnsafeSlow` | `PoolAllocator` | Speedup |
-| ---------------- | -------------------: | -----------------------: | --------------: | ------: |
-| alloc 64 bytes   |             38.08 ns |                 41.23 ns |     **5.66 ns** |    6.7x |
-| alloc 256 bytes  |             52.09 ns |                231.46 ns |     **5.90 ns** |    8.8x |
-| alloc 1024 bytes |             91.24 ns |                340.75 ns |     **5.83 ns** |   15.6x |
-| alloc 4096 bytes |            446.53 ns |                437.83 ns |     **6.24 ns** |   71.6x |
+| Operation             | `Buffer.allocUnsafe` | `Buffer.allocUnsafeSlow` | `PoolAllocator` | Speedup |
+| --------------------- | -------------------: | -----------------------: | --------------: | ------: |
+| alloc/free 64 bytes   |             28.87 ns |                 31.08 ns |    **14.05 ns** |    2.1x |
+| alloc/free 256 bytes  |             38.22 ns |                172.16 ns |    **12.97 ns** |    2.9x |
+| alloc/free 1024 bytes |             61.32 ns |                226.35 ns |    **13.16 ns** |    4.7x |
+| alloc/free 4096 bytes |            285.70 ns |                272.15 ns |    **13.21 ns** |   20.6x |
 
 ### Allocation (GC)
 
-| Operation        | `Buffer.allocUnsafe` | `Buffer.allocUnsafeSlow` | `PoolAllocator` | Speedup |
-| ---------------- | -------------------: | -----------------------: | --------------: | ------: |
-| alloc 64 bytes   |            400.46 ns |                167.94 ns |     **6.33 ns** |   63.3x |
-| alloc 256 bytes  |            309.57 ns |                500.58 ns |     **6.35 ns** |   48.7x |
-| alloc 4096 bytes |            653.40 ns |                620.19 ns |     **6.32 ns** |  103.4x |
+| Operation             | `Buffer.allocUnsafe` | `Buffer.allocUnsafeSlow` | `PoolAllocator` | Speedup |
+| --------------------- | -------------------: | -----------------------: | --------------: | ------: |
+| alloc/free 64 bytes   |            204.54 ns |                107.27 ns |    **17.60 ns** |    6.1x |
+| alloc/free 256 bytes  |            198.66 ns |                324.21 ns |    **17.58 ns** |   11.3x |
+| alloc/free 4096 bytes |            378.27 ns |                360.77 ns |    **17.28 ns** |   20.9x |
 
-Under GC pressure, the advantage grows dramatically — up to **103x** faster — because `PoolAllocator` reuses slots from a pre-allocated buffer and never creates objects for V8 to trace.
+Under GC pressure the advantage grows — up to **~21x** — because `PoolAllocator` reuses slots from a pre-allocated buffer and never creates objects for V8 to trace. Speedup is computed against the faster of the two `Buffer` variants.
 
 ### Slice creation vs `Buffer.subarray`
 
 | Operation              | `Buffer.subarray` |      `Slice` | Speedup |
 | ---------------------- | ----------------: | -----------: | ------: |
-| subarray 64 bytes      |          38.11 ns | **12.99 ns** |    2.9x |
-| subarray 1024 bytes    |          36.87 ns | **13.26 ns** |    2.8x |
-| subarray 64 bytes (GC) |         127.30 ns | **81.60 ns** |    1.6x |
+| subarray 64 bytes      |          29.32 ns |  **4.13 ns** |    7.1x |
+| subarray 1024 bytes    |          28.60 ns |  **4.11 ns** |    7.0x |
+| subarray 64 bytes (GC) |          90.84 ns | **80.43 ns** |    1.1x |
 
 ### Combined operations
 
+`Buffer` is the faster of `Buffer.allocUnsafe`/`Buffer.allocUnsafeSlow` per row.
+
 | Operation                             |  `Buffer` | `PoolAllocator` | Speedup |
 | ------------------------------------- | --------: | --------------: | ------: |
-| alloc/free 64 bytes                   |  32.72 ns |    **30.80 ns** |    1.1x |
-| alloc/free 64 bytes (GC)              | 273.35 ns |    **73.34 ns** |    3.7x |
-| alloc/free 256 bytes                  |  58.88 ns |    **29.38 ns** |    2.0x |
-| realloc churn (64 → 128 → 64)         |  93.63 ns |    **26.99 ns** |    3.5x |
-| realloc in-place (grow within bucket) |  60.16 ns |    **11.06 ns** |    5.4x |
-| 10 concurrent allocs then free        | 406.26 ns |   **337.83 ns** |    1.2x |
-| 10 concurrent allocs then free (GC)   | 647.95 ns |   **649.73 ns** |    1.0x |
+| new Slice + alloc/free 64 bytes       |  25.54 ns |    **15.44 ns** |    1.7x |
+| new Slice + alloc/free 64 bytes (GC)  | 116.92 ns |    **61.42 ns** |    1.9x |
+| new Slice + alloc/free 256 bytes      |  29.62 ns |    **15.38 ns** |    1.9x |
+| realloc churn (64 → 128 → 64)         |  48.76 ns |    **17.30 ns** |    2.8x |
+| realloc in-place (grow within bucket) |  48.39 ns |     **6.84 ns** |    7.1x |
+| 10 concurrent allocs then free        | 307.90 ns |   **176.16 ns** |    1.7x |
+| 10 concurrent allocs then free (GC)   | 470.07 ns |   **372.63 ns** |    1.3x |
+| 10 concurrent allocs then free ×2     | 635.30 ns |   **345.13 ns** |    1.8x |
 
 ## API
 
@@ -89,19 +93,23 @@ 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. `byteLength` defaults to the remaining bytes (`buffer.byteLength - byteOffset`), matching `Slice.from` and typed-array conventions. 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 heap-fallback slice it tracks the allocation's capacity (the high-water `byteLength`), which `realloc` uses to resize large slices in place. For a manually-constructed slice it defaults to `byteLength` and no `Slice` method bounds reads or writes against it (those are validated/clamped against `byteLength`) — but `realloc` treats any non-pool slice's `maxByteLength` as its capacity if such a slice is passed to it.
 - `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.
+- `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.
@@ -117,8 +125,10 @@ All offsets are **relative to the slice** (i.e. `0` is `byteOffset`). For a `Sli
 
 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`/`length`, 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.
+- **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 validated, then clamped** — `sourceEnd`/`targetEnd`/`end` must be integers (`NaN`, fractional, and `±Infinity` throw `RangeError`; omit the argument to mean "to the end of the slice"). In-range validation stays lenient: integer ends beyond the slice are clamped to the slice's logical length (matching `Buffer`'s 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
 
@@ -130,17 +140,17 @@ Pre-allocates a contiguous memory pool and manages slices using power-of-2 bucke
 
 #### `new PoolAllocator(poolTotalOrBuffer?: number | Buffer | ArrayBufferView | ArrayBuffer | SharedArrayBuffer)`
 
-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.
+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. `Infinity` means **unbounded**: no pool is pre-allocated, every allocation falls back to a standalone `Buffer`, and `size` stays `0` — so size-based pruning never triggers. `NaN`, negative, and fractional sizes throw `RangeError`.
 
 > **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(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 slice twice, corrupts the allocator's accounting.
+- `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 or in-place 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 over the same backing buffer, or freeing the same pool slot through two aliasing `Slice` objects, throws `Invalid pool state` when the corruption is detectable (a bucket's live count would go negative) — but do not rely on detection: an aliasing free while other slices remain live in the same bucket silently corrupts the 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`.
+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`. Resizing such a slice while the request stays above 256 KB reuses the existing backing store in place when it fits — capacity is retained up to the power-of-2 ceiling of the request (< 2× waste), so size churn **within the retained capacity** does not reallocate (churn spanning a wider than 2× band still reallocates); shrinking below that bound, or to a pool-eligible size, allocates anew (rejoining the pool when possible). Note the in-place path keeps whatever backing buffer the slice already has — including a hand-constructed one — so do not use `realloc` to detach a slice from caller-shared memory.
 
 #### Properties
 

package/lib/index.d.ts

@@ -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,SAAiC,EAC3C,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;IAuET,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;IAwEb,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;IA+BzE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM;IAiC9C,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;IAuCR,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;IAsIhD,IAAI,KAAK;;;;;;;;;;;;;MAeR;CACF"}

package/lib/index.js

@@ -1,517 +1,501 @@
-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')
-    }
-
-    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
+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');
+        }
+        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 - byteOffset, 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 {
+            // Ends are clamped when out of range but must still be integers: a
+            // NaN/fractional end compares false against the clamps below and would
+            // poison the aliasing short-circuit's returned count. Omit the argument
+            // to mean "to the end of the slice".
+            if (!Number.isInteger(sourceEnd)) {
+                throw new RangeError(`Invalid sourceEnd: ${sourceEnd}`);
+            }
+            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) {
+            // The regions alias so the copy is a no-op, but the returned count must
+            // match what Buffer.copy would report: clamped to the target's remaining
+            // capacity. (For a Slice target, sourceEnd was already capacity-clamped
+            // above; this min is then a no-op.)
+            const available = target.byteLength - targetStart;
+            const count = sourceEnd - sourceStart;
+            return count > available ? (available > 0 ? available : 0) : count;
+        }
+        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 {
+                // Validated here (not left to Buffer.compare) so the error names the
+                // slice-relative value the caller passed, not a byteOffset-shifted one.
+                if (!Number.isInteger(targetEnd)) {
+                    throw new RangeError(`Invalid targetEnd: ${targetEnd}`);
+                }
+                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 {
+            if (!Number.isInteger(sourceEnd)) {
+                throw new RangeError(`Invalid sourceEnd: ${sourceEnd}`);
+            }
+            sourceEnd += this.byteOffset;
+        }
+        if (sourceEnd > sliceEnd) {
+            sourceEnd = sliceEnd;
+        }
+        if (sourceEnd < sourceStart) {
+            sourceEnd = sourceStart;
+        }
+        return this.buffer.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);
     }
-
-    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
+    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);
     }
-
-    if (end === undefined) {
-      end = sliceEnd
-    } else {
-      end += this.byteOffset
+    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);
     }
-
-    if (end > sliceEnd) {
-      end = sliceEnd
+    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];
     }
-    if (end < start) {
-      end = start
+    test(expr) {
+        return expr.test(this.buffer, this.byteOffset, this.byteLength);
     }
-
-    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
-
-    // Never read past the underlying buffer. A malformed slice (byteOffset /
-    // byteLength extending beyond the buffer) is exactly the state a developer
-    // inspects while debugging pool corruption — inspect must not throw on it.
-    const available = this.buffer.byteLength - this.byteOffset
-    const safeLen = available > 0 ? (len < available ? len : available) : 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[this.byteOffset + i].toString(16).padStart(2, '0')
+    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 {
+            if (!Number.isInteger(end)) {
+                throw new RangeError(`Invalid end: ${end}`);
+            }
+            end += this.byteOffset;
+        }
+        if (end > sliceEnd) {
+            end = sliceEnd;
+        }
+        if (end < start) {
+            end = start;
+        }
+        return this.buffer.toString(encoding, start, end);
     }
-    if (shown < len) {
-      hex += ` ... (${len - shown} more)`
+    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 {
+            if (!Number.isInteger(end)) {
+                throw new RangeError(`Invalid end: ${end}`);
+            }
+            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}>`;
     }
-
-    const str = this.buffer.toString('utf8', this.byteOffset, this.byteOffset + shown)
-    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') {
-      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.
-    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
+    #size = 0;
+    #padding = 0;
+    #poolsBucket = [];
+    #poolsBucketUsed = [];
+    #poolBuffer;
+    #poolOffset = 0;
+    #poolSize = 0;
+    #poolCount = 0;
+    constructor(poolTotalOrBuffer = 128 *
+        1024 *
+        1024) {
+        if (typeof poolTotalOrBuffer === 'number') {
+            // Infinity means "unbounded": no pre-allocated pool, every allocation
+            // falls back to a standalone Buffer and size stays 0 — the 1.0.x
+            // contract that consumers (e.g. SubscriptionRegistry maxSize: Infinity)
+            // rely on. NaN and negative/fractional sizes are still rejected.
+            if (poolTotalOrBuffer === Infinity) {
+                poolTotalOrBuffer = 0;
+            }
+            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);
+        }
     }
-
-    slice.reset()
-
-    if (byteLength === 0) {
-      return slice
+    get size() {
+        return this.#size;
     }
-
-    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
+    isFromPool(slice) {
+        return slice != null && slice.buffer === this.#poolBuffer;
     }
-
-    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],
-      })),
+    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. A used count
+            // already at 0 means this slot was never handed out by this allocator
+            // (double-free through an aliasing Slice, or a slice from another
+            // allocator over the same backing buffer) — freeing it would push a
+            // duplicate/foreign offset onto the free list and later hand out two
+            // overlapping slices.
+            if (srcMaxByteLength !== 1 << srcIdx ||
+                srcIdx < 3 ||
+                srcIdx >= this.#poolsBucket.length ||
+                this.#poolsBucketUsed[srcIdx] <= 0) {
+                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;
+        }
+        else if (dstIdx >= this.#poolsBucket.length &&
+            byteLength <= slice.maxByteLength &&
+            slice.maxByteLength <= maxByteLength &&
+            Number.isInteger(slice.byteOffset) &&
+            slice.byteOffset >= 0 &&
+            slice.maxByteLength <= slice.buffer.byteLength - slice.byteOffset) {
+            // In-place resize of a heap (non-pool) slice. The request is above the
+            // top pool bucket (so it can never rejoin the pool) and fits the slice's
+            // existing capacity, so reallocating ~300KB+ of backing store for a size
+            // change would be pure waste. Retained capacity is bounded by the
+            // power-of-two ceiling of the request (< 2x), so a shrink from a much
+            // larger allocation still releases its memory. The byteOffset/window
+            // checks keep a hand-constructed slice's resize inside its real buffer
+            // (a negative or fractional byteOffset would inflate the window
+            // arithmetic) — but they cannot detect a foreign buffer that aliases
+            // other memory; passing such a slice is documented misuse. Contents are
+            // incidentally retained but remain undefined per realloc's malloc
+            // semantics.
+            slice.byteLength = byteLength;
+            return slice;
+        }
+        if (byteLength === 0) {
+            slice.reset();
+            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.10",
+  "version": "1.1.12",
   "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": "7c9c7457c885c644c7a1e70ef894d4727ce240d6"
+  "gitHead": "c9f2526dc870597de119b8ec5083f97901d4a2e2"
 }