@nxtedition/shared 1.0.10 → 1.0.12

package/README.md

@@ -4,9 +4,9 @@ A high-performance, thread-safe ring buffer for inter-thread communication in No
 
 ## Why
 
-Passing data between worker threads in Node.js typically involves structured cloning or transferring `ArrayBuffer` ownership. Structured cloning copies every byte — fine for occasional messages, but a bottleneck when streaming megabytes per second between threads. Transferable objects avoid the copy, but ownership transfer means the sender loses access, which complicates protocols that need to retain the data.
+Passing data between worker threads in Node.js typically involves structured cloning or transferring `ArrayBuffer` ownership. Structured cloning copies every byte — fine for occasional messages, but a bottleneck when streaming megabytes per second between threads. Transferable objects avoid the copy, but each transfer still requires allocating a new `ArrayBuffer`, serializing the transfer list, and coordinating ownership between threads — overhead that adds up quickly in high-throughput scenarios.
 
-This ring buffer avoids both problems. A single `SharedArrayBuffer` is mapped into both threads. The writer appends messages by advancing a write pointer; the reader consumes them by advancing a read pointer. No copies, no ownership transfers, no cloning overhead. The pointers are coordinated with `Atomics` operations, and cache-line-aligned to prevent false sharing between CPU cores.
+This ring buffer avoids these problems. A single `SharedArrayBuffer` is mapped into both threads. The writer appends messages by advancing a write pointer; the reader consumes them by advancing a read pointer. No copies, no ownership transfers, no cloning overhead. Because messages are stored inline in a contiguous buffer, data lives right where the protocol is rather than scattered across separately allocated `ArrayBuffer`s — keeping access patterns cache-friendly. The pointers are coordinated with `Atomics` operations, and cache-line-aligned to prevent false sharing between CPU cores.
 
 Reads are zero-copy: the reader callback receives a `DataView` directly into the shared buffer, so parsing can happen in-place without allocating intermediate buffers. Writes are batched — the write pointer is only published to the reader after a high-water mark is reached or the current event loop tick ends, drastically reducing the frequency of expensive atomic stores.
 

package/lib/index.js

@@ -318,7 +318,7 @@ export function writer(
     // NOTE: This is unsafe as the user function can write beyond the reserved length.
     const dataLen = fn(data) - dataPos
 
-    if (typeof dataLen !== 'number') {
+    if (!Number.isFinite(dataLen)) {
       throw new TypeError('"fn" must return the number of bytes written')
     }
     if (dataLen < 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/shared",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -27,5 +27,5 @@
     "rimraf": "^6.1.2",
     "typescript": "^5.9.3"
   },
-  "gitHead": "43180e101ef8e6b579c60f24ab5329577627134e"
+  "gitHead": "80ace3245dc851f38a288b0c3b167ca0024f0469"
 }