@nxtedition/shared 1.0.0 → 1.0.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 nxtedition
+Copyright (c) nxtedition
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,50 +1,162 @@
-# shared
+# @nxtedition/shared
 
-Ring Buffer for NodeJS cross Worker communication.
+A high-performance, thread-safe ring buffer for inter-thread communication in Node.js using `SharedArrayBuffer`.
+
+## 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.
+
+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.
+
+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.
+
+## Platform Assumptions
+
+This library assumes that unaligned 32-bit reads and writes will not tear on the target platform. This holds true on x86/x64 and ARM64, which are the primary targets for Node.js.
 
 ## Install
 
-```
-npm i @nxtedition/shared
+```sh
+npm install @nxtedition/shared
 ```
 
-## Quick Start
+## Usage
 
 ```js
-// index.js
+import { alloc, reader, writer } from '@nxtedition/shared'
+
+// Allocate shared memory (pass these buffers to a worker thread)
+const { sharedState, sharedBuffer } = alloc(1024 * 1024) // 1 MB ring buffer
+
+// --- Writer side (e.g. main thread) ---
+const w = writer({ sharedState, sharedBuffer })
 
-import * as shared from '@nxtedition/shared'
-import tp from 'timers/promise'
+const payload = Buffer.from('hello world')
+w.writeSync(payload.length, (data) => {
+  payload.copy(data.buffer, data.offset)
+  return data.offset + payload.length
+})
 
-const writer = shared.alloc(16 * 1024 * 1024)
-const reader = shared.alloc(16 * 1024 * 1024)
+// --- Reader side (e.g. worker thread) ---
+const r = reader({ sharedState, sharedBuffer })
 
-const worker = new Worker(new URL('worker.js', import.meta.url), {
-  workerData: { reader, writer },
+r.readSome((data) => {
+  const msg = data.buffer.subarray(data.offset, data.offset + data.length).toString()
+  console.log(msg) // 'hello world'
 })
+```
+
+### Batching writes with cork
 
-const writeToWorker = shared.writer(reader)
+```js
+w.cork(() => {
+  for (const item of items) {
+    const buf = Buffer.from(JSON.stringify(item))
+    w.writeSync(buf.length, (data) => {
+      buf.copy(data.buffer, data.offset)
+      return data.offset + buf.length
+    })
+  }
+})
+// All writes flushed atomically when cork returns
+```
 
-writeToWorker(Buffer.from('ping'))
+### Non-blocking writes with tryWrite
 
-for await (const buffer of shared.reader(writer)) {
-  console.log(`From worker ${buffer}`)
-  await tp.setTimeout(1e3) // Backpressure
-  writeToWorker(Buffer.from('pong'))
+```js
+const buf = Buffer.from('data')
+const ok = w.tryWrite(buf.length, (data) => {
+  buf.copy(data.buffer, data.offset)
+  return data.offset + buf.length
+})
+if (!ok) {
+  // Buffer is full — the reader hasn't caught up yet
 }
 ```
 
+### Cross-thread usage
+
 ```js
-// worker.js
+// main.js
+import { alloc, writer } from '@nxtedition/shared'
+import { Worker } from 'node:worker_threads'
 
-import * as shared from '@nxtedition/shared'
-import tp from 'timers/promise'
+const { sharedState, sharedBuffer } = alloc(1024 * 1024)
+const worker = new Worker('./reader-worker.js', {
+  workerData: { sharedState, sharedBuffer },
+})
+
+const w = writer({ sharedState, sharedBuffer })
+// ... write messages
+```
 
-const writeToParent = shared.writer(workerData.writer)
+```js
+// reader-worker.js
+import { reader } from '@nxtedition/shared'
+import { workerData } from 'node:worker_threads'
+
+const r = reader(workerData)
 
-for await (const buffer of shared.reader(workerData.reader)) {
-  console.log(`From parent ${buffer}`)
-  await tp.setTimeout(1e3) // Backpressure
-  writeToWorker(Buffer.from('pong'))
+function poll() {
+  const count = r.readSome((data) => {
+    // process data.buffer at data.offset..data.offset+data.length
+  })
+  setImmediate(poll)
 }
+poll()
 ```
+
+## API
+
+### `alloc(size: number): SharedBuffers`
+
+Allocates the shared memory buffers for a ring buffer of the given byte size.
+
+- **size** — Buffer capacity in bytes (must be a positive integer, max ~2 GB)
+- Returns `{ sharedState: SharedArrayBuffer, sharedBuffer: SharedArrayBuffer }`
+
+### `reader(buffers: SharedBuffers): Reader`
+
+Creates a reader for the ring buffer.
+
+#### `reader.readSome(next): number`
+
+Reads a batch of messages. Calls `next(data)` for each message, where `data` has:
+
+- `buffer: Buffer` — The underlying shared buffer
+- `view: DataView` — A DataView over the shared buffer
+- `offset: number` — Start offset of the message payload
+- `length: number` — Length of the message payload in bytes
+
+Return `false` from the callback to stop reading early. Returns the number of messages processed.
+
+Messages are batched: up to 1024 items or 256 KiB per call.
+
+### `writer(buffers: SharedBuffers, options?): Writer`
+
+Creates a writer for the ring buffer.
+
+**Options:**
+
+- `yield?: () => void` — Called when the writer must wait for the reader to catch up. Useful to prevent deadlocks when the writer thread also drives the reader.
+- `logger?: { warn(obj, msg): void }` — Logger for yield warnings (pino-compatible).
+
+#### `writer.writeSync(len, fn, timeout?): void`
+
+Synchronously writes a message. Blocks (via `Atomics.wait`) until buffer space is available.
+
+- **len** — Maximum payload size in bytes. Writing beyond `len` bytes in the callback is undefined behavior.
+- **fn(data) → number** — Write callback. Write payload into `data.buffer` starting at `data.offset`. **Must return the end position** (`data.offset + bytesWritten`), not the byte count.
+- **timeout** — Max wait time in ms (default: 60000). Throws on timeout.
+
+#### `writer.tryWrite(len, fn): boolean`
+
+Non-blocking write attempt. Returns `false` if the buffer is full. The `fn` callback follows the same contract as `writeSync`.
+
+#### `writer.cork(callback): T`
+
+Batches multiple writes within the callback. The write pointer is only published to the reader when `cork` returns, reducing atomic operation overhead.
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,36 @@
+export interface SharedBuffers {
+    sharedState: SharedArrayBuffer;
+    sharedBuffer: SharedArrayBuffer;
+}
+export interface BufferRegion {
+    buffer: Buffer;
+    view: DataView;
+    offset: number;
+    length: number;
+}
+/**
+ * Allocates the shared memory buffers.
+ */
+export declare function alloc(size: number): SharedBuffers;
+export interface Reader {
+    readSome(next: (data: BufferRegion) => void | boolean): number;
+}
+/**
+ * Creates a reader for the ring buffer.
+ */
+export declare function reader({ sharedState, sharedBuffer }: SharedBuffers): Reader;
+export interface WriterOptions {
+    yield?: () => void;
+    logger?: {
+        warn(obj: object, msg: string): void;
+    };
+}
+export interface Writer {
+    tryWrite(len: number, fn: (data: BufferRegion) => number): boolean;
+    writeSync(len: number, fn: (data: BufferRegion) => number, timeout?: number): void;
+    cork<T>(callback: () => T): T;
+}
+/**
+ * Creates a writer for the ring buffer.
+ */
+export declare function writer({ sharedState, sharedBuffer }: SharedBuffers, { yield: onYield, logger }?: WriterOptions): Writer;

package/lib/index.js

@@ -0,0 +1,461 @@
+// By placing the read and write indices far apart (multiples of a common
+// cache line size, 64 bytes), we prevent "false sharing". This is a
+// low-level CPU optimization where two cores writing to different variables
+// that happen to be on the same cache line would otherwise constantly
+// invalidate each other's caches, hurting performance.
+// Int32 is 4 bytes, so an index of 16 means 16 * 4 = 64 bytes offset.
+const WRITE_INDEX = 0
+const READ_INDEX = 16
+
+// High-Water Mark for batching operations to reduce the frequency
+// of expensive atomic writes.
+const HWM_BYTES = 256 * 1024 // 256 KiB
+const HWM_COUNT = 1024 // 1024 items
+
+                                
+                                
+                                 
+ 
+
+                               
+                
+                
+                
+                
+ 
+
+/**
+ * Allocates the shared memory buffers.
+ */
+export function alloc(size        )                {
+  if (!Number.isInteger(size)) {
+    throw new TypeError('size must be a positive integer')
+  }
+  if (size <= 0) {
+    throw new RangeError('size must be a positive integer')
+  }
+  if (size >= 2 ** 31 - 8) {
+    throw new RangeError('size exceeds maximum of 2GB minus header size')
+  }
+
+  return {
+    // A small buffer for sharing state (read/write pointers).
+    sharedState: new SharedArrayBuffer(128),
+    // The main buffer for transferring data.
+    // We need another 8 bytes for entry headers.
+    sharedBuffer: new SharedArrayBuffer(size + 8),
+  }
+}
+
+                         
+                                                                
+ 
+
+/**
+ * Creates a reader for the ring buffer.
+ */
+export function reader({ sharedState, sharedBuffer }               )         {
+  if (!(sharedState instanceof SharedArrayBuffer)) {
+    throw new TypeError('sharedState must be a SharedArrayBuffer')
+  }
+  if (!(sharedBuffer instanceof SharedArrayBuffer)) {
+    throw new TypeError('sharedBuffer must be a SharedArrayBuffer')
+  }
+  if (sharedBuffer.byteLength >= 2 ** 31) {
+    throw new RangeError('Shared buffer size exceeds maximum of 2GB')
+  }
+
+  const state = new Int32Array(sharedState)
+  const size = sharedBuffer.byteLength
+  const buffer = Buffer.from(sharedBuffer)
+  const view = new DataView(sharedBuffer)
+
+  // This object is reused to avoid creating new objects in a hot path.
+  // This helps V8 maintain a stable hidden class for the object,
+  // which is a key optimization (zero-copy read).
+  const data               = { buffer, view, offset: 0, length: 0 }
+
+  // Local copies of the pointers. The `| 0` is a hint to the V8 JIT
+  // compiler that these are 32-bit integers, enabling optimizations.
+  let readPos = Atomics.load(state, READ_INDEX) | 0
+  let writePos = Atomics.load(state, WRITE_INDEX) | 0
+
+  function readSome(next                                        )         {
+    let count = 0
+    let bytes = 0
+
+    writePos = state[WRITE_INDEX] | 0
+
+    // First, check if the local writePos matches the readPos.
+    // If so, refresh it from shared memory in case the writer has added data.
+    if (readPos === writePos) {
+      writePos = Atomics.load(state, WRITE_INDEX) | 0
+    }
+
+    // Process messages in a batch to minimize loop and atomic operation overhead.
+    while (count < HWM_COUNT && bytes < HWM_BYTES && readPos !== writePos) {
+      const dataPos = readPos + 4
+      const dataLen = view.getInt32(dataPos - 4, true) | 0
+
+      bytes += 4
+
+      // A length of -1 is a special marker indicating the writer has
+      // wrapped around to the beginning of the buffer.
+      if (dataLen === -1) {
+        readPos = 0
+        // After wrapping, we must re-check against the writer's position.
+        // It's possible the writer is now at a position > 0.
+        writePos = Atomics.load(state, WRITE_INDEX) | 0
+      } else {
+        if (dataLen < 0) {
+          throw new Error('Invalid data length')
+        }
+        if (dataPos + dataLen > size) {
+          throw new Error('Data exceeds buffer size')
+        }
+
+        readPos += 4 + dataLen
+
+        bytes += dataLen
+        count += 1
+
+        // This is a "zero-copy" operation. We don't copy the data out.
+        // Instead, we pass a "view" into the shared buffer.
+        data.offset = dataPos
+        data.length = dataLen
+
+        if (next(data) === false) {
+          break
+        }
+      }
+    }
+
+    // IMPORTANT: The reader only updates its shared `readPos` after a batch
+    // is processed. This significantly reduces atomic operation overhead.
+    if (bytes > 0) {
+      Atomics.store(state, READ_INDEX, readPos)
+    }
+
+    return count
+  }
+
+  return { readSome }
+}
+
+                                
+                    
+                                                   
+ 
+
+                         
+                                                                    
+                                                                                    
+                               
+ 
+
+/**
+ * Creates a writer for the ring buffer.
+ */
+export function writer(
+  { sharedState, sharedBuffer }               ,
+  { yield: onYield, logger }                = {},
+)         {
+  if (!(sharedState instanceof SharedArrayBuffer)) {
+    throw new TypeError('sharedState must be a SharedArrayBuffer')
+  }
+  if (!(sharedBuffer instanceof SharedArrayBuffer)) {
+    throw new TypeError('sharedBuffer must be a SharedArrayBuffer')
+  }
+  if (sharedBuffer.byteLength >= 2 ** 31) {
+    throw new RangeError('Shared buffer size exceeds maximum of 2GB')
+  }
+
+  const state = new Int32Array(sharedState)
+  const size = sharedBuffer.byteLength
+  const buffer = Buffer.from(sharedBuffer)
+  const view = new DataView(sharedBuffer)
+
+  // This object is reused to avoid creating new objects in a hot path.
+  // This helps V8 maintain a stable hidden class for the object,
+  // which is a key optimization (zero-copy read).
+  const data               = { buffer, view, offset: 0, length: 0 }
+
+  // Local copies of the pointers. The `| 0` is a hint to the V8 JIT
+  // compiler that these are 32-bit integers, enabling optimizations.
+  let readPos = Atomics.load(state, READ_INDEX) | 0
+  let writePos = Atomics.load(state, WRITE_INDEX) | 0
+
+  let yielding = 0
+  let corked = 0
+  let pending = 0
+
+  if (onYield != null && typeof onYield !== 'function') {
+    throw new TypeError('onYield must be a function')
+  }
+
+  /**
+   * Pauses the writer thread to wait for the reader to catch up.
+   */
+  function _yield(delay        )       {
+    if (yielding > 128) {
+      throw new Error('Detected possible deadlock: writer yielding too many times')
+    }
+
+    // First, ensure the very latest write position is visible to the reader.
+    _flush()
+
+    if (onYield) {
+      yielding += 1
+      try {
+        // Call the user-provided yield function, if any. This can be important
+        // if the writer is waiting for the reader to process data which would
+        // otherwise deadlock.
+        onYield()
+      } finally {
+        yielding -= 1
+      }
+    }
+
+    // Atomics.wait is the most efficient way to pause. It puts the thread
+    // to sleep, consuming no CPU, until the reader changes the READ_INDEX.
+    if (delay > 0) {
+      Atomics.wait(state, READ_INDEX, readPos, delay)
+    } else {
+      // @ts-expect-error Atomics.pause is Stage 3, available in Node.js 25+
+      Atomics.pause()
+    }
+
+    // After waking up, refresh the local view of the reader's position.
+    readPos = Atomics.load(state, READ_INDEX) | 0
+  }
+
+  /**
+   * Tries to acquire enough space in the buffer for a new message.
+   */
+  function _acquire(len        )          {
+    // Total space required: payload + its 4-byte length header + a potential
+    // 4-byte header for the *next* message (for wrap-around check).
+    const required = len + 4 + 4
+
+    if (writePos >= readPos) {
+      // Case 1: The writer is ahead of the reader. [ 0 - R ... W - size ]
+      // There is free space from W to the end (s) and from 0 to R.
+
+      if (size - writePos >= required) {
+        // Enough space at the end of the buffer.
+        return true
+      }
+
+      readPos = state[READ_INDEX] | 0
+      if (readPos === 0) {
+        _yield(0)
+      }
+
+      // Not enough space at the end. Check if there's space at the beginning.
+      if (readPos === 0) {
+        // Reader is at the beginning, so no space to wrap around into.
+        return false
+      }
+
+      // Mark the current position with a wrap-around signal (-1).
+      view.setInt32(writePos, -1, true)
+
+      // Reset writer position to the beginning.
+      writePos = 0
+
+      if (writePos + 4 > size) {
+        // assertion
+        throw new Error(`Write position ${writePos} with next header exceeds buffer size ${size}`)
+      }
+      if (writePos === readPos) {
+        // assertion
+        throw new Error(`Write position ${writePos} cannot equal read position ${readPos}`)
+      }
+
+      Atomics.store(state, WRITE_INDEX, writePos)
+    }
+
+    // Case 2: The writer has wrapped around. [ 0 ... W - R ... s ]
+    // The only free space is between W and R.
+
+    readPos = state[READ_INDEX] | 0
+    if (readPos - writePos < required) {
+      _yield(0)
+    }
+
+    return readPos - writePos >= required
+  }
+
+  /**
+   * "Uncorks" the stream by publishing the pending write position.
+   * This is called from a microtask to batch atomic stores.
+   */
+  function _uncork()       {
+    corked -= 1
+    if (corked === 0) {
+      _flush()
+    }
+  }
+
+  function _flush()       {
+    if (pending > 0) {
+      Atomics.store(state, WRITE_INDEX, writePos)
+      pending = 0
+    }
+  }
+
+  /**
+   * Performs the actual write into the buffer after space has been acquired.
+   */
+  function _write(dataCap        , fn                                )       {
+    const dataPos = writePos + 4
+
+    data.offset = dataPos
+    data.length = dataCap
+
+    // The user-provided function writes the data and returns the final position.
+    // We calculate the actual bytes written from that.
+    // NOTE: This is unsafe as the user function can write beyond the reserved length.
+    const dataLen = fn(data) - dataPos
+
+    if (typeof dataLen !== 'number') {
+      throw new TypeError('"fn" must return the number of bytes written')
+    }
+    if (dataLen < 0) {
+      throw new RangeError(`"fn" returned a negative number ${dataLen}`)
+    }
+    if (dataLen > dataCap) {
+      throw new RangeError(`"fn" returned a number ${dataLen} that exceeds capacity ${dataCap}`)
+    }
+
+    if (dataPos + dataLen > size) {
+      // assertion
+      throw new Error(`Data position ${dataPos} with length ${dataLen} exceeds buffer size ${size}`)
+    }
+
+    const nextPos = writePos + 4 + dataLen
+
+    if (nextPos + 4 > size) {
+      // assertion
+      throw new Error(`Write position ${nextPos} with next header exceeds buffer size ${size}`)
+    }
+    if (nextPos === readPos) {
+      // assertion
+      throw new Error(`Write position ${nextPos} cannot equal read position ${readPos}`)
+    }
+
+    // Write the actual length of the data into the 4-byte header.
+    view.setInt32(writePos, dataLen, true)
+    writePos += 4 + dataLen
+    pending += 4 + dataLen
+
+    // This is the "corking" optimization. Instead of calling Atomics.store
+    // on every write, we batch them. We either write when a certain
+    // amount of data is pending (HWM_BYTES) or at the end of the current
+    // event loop tick. This drastically reduces atomic operation overhead.
+    if (pending >= HWM_BYTES) {
+      Atomics.store(state, WRITE_INDEX, writePos)
+      pending = 0
+    } else if (corked === 0) {
+      corked += 1
+      setImmediate(_uncork)
+    }
+  }
+
+  /**
+   * Public write method. Acquires space and synchronously writes data with a timeout. Will
+   * wait until space is available.
+   * Writing more than "len" bytes in the callback will cause undefined behavior.
+   */
+  function writeSync(
+    len        ,
+    fn                                ,
+    timeout         = 60e3,
+  )       {
+    if (typeof len !== 'number') {
+      throw new TypeError('"len" must be a non-negative number')
+    }
+    if (len < 0) {
+      throw new RangeError(`"len" ${len} is negative`)
+    }
+    if (len >= 2 ** 31 || len > size - 8) {
+      throw new Error(`"len" ${len} exceeds maximum allowed size ${size - 8}`)
+    }
+    if (typeof fn !== 'function') {
+      throw new TypeError('"fn" must be a function')
+    }
+    if (typeof timeout !== 'number') {
+      throw new TypeError('"timeout" must be a non-negative number')
+    }
+    if (timeout < 0) {
+      throw new RangeError('"timeout" must be a non-negative number')
+    }
+
+    if (!_acquire(len)) {
+      const startTime = performance.now()
+      let yieldCount = 0
+      let yieldTime = 0
+      for (let n = 0; !_acquire(len); n++) {
+        if (performance.now() - startTime > timeout) {
+          throw new Error('Timeout while waiting for space in the buffer')
+        }
+        _yield(3)
+        yieldCount += 1
+        yieldTime += 3
+      }
+      const elapsedTime = performance.now() - startTime
+      logger?.warn(
+        { yieldLength: len, readPos, writePos, elapsedTime, yieldCount, yieldTime },
+        'yielded',
+      )
+    }
+
+    _write(len, fn)
+
+    if (writePos === readPos) {
+      throw new Error(`Write position ${writePos} cannot equal read position ${readPos}`)
+    }
+  }
+
+  /**
+   * Public write method. Acquires space and tries to write data.
+   * Writing more than "len" bytes in the callback will cause undefined behavior.
+   */
+  function tryWrite(len        , fn                                )          {
+    if (typeof len !== 'number') {
+      throw new TypeError('"len" must be a non-negative number')
+    }
+    if (len < 0) {
+      throw new RangeError(`"len" ${len} is negative`)
+    }
+    if (len >= 2 ** 31 || len > size - 8) {
+      throw new Error(`"len" ${len} exceeds maximum allowed size ${size - 8}`)
+    }
+    if (typeof fn !== 'function') {
+      throw new TypeError('"fn" must be a function')
+    }
+
+    if (!_acquire(len)) {
+      return false
+    }
+
+    _write(len, fn)
+
+    if (writePos === readPos) {
+      throw new Error(`Write position ${writePos} cannot equal read position ${readPos}`)
+    }
+
+    return true
+  }
+
+  function cork   (callback         )    {
+    corked += 1
+    try {
+      return callback()
+    } finally {
+      _uncork()
+    }
+  }
+
+  return { tryWrite, writeSync, cork }
+}

package/package.json

@@ -1,66 +1,31 @@
 {
   "name": "@nxtedition/shared",
-  "version": "1.0.0",
-  "description": "Ring Buffer for NodeJS cross Worker communication",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/nxtedition/shared.git"
-  },
-  "author": "Robert Nagy <ronagy@icloud.com>",
-  "license": "MIT License",
-  "bugs": {
-    "url": "https://github.com/nxtedition/shared/issues"
-  },
+  "version": "1.0.10",
   "type": "module",
-  "homepage": "https://github.com/nxtedition/shared#readme",
-  "lint-staged": {
-    "*.{js,jsx,ts}": [
-      "eslint",
-      "prettier --write"
-    ]
-  },
-  "prettier": {
-    "printWidth": 100,
-    "semi": false,
-    "singleQuote": true,
-    "jsxSingleQuote": true
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
   },
-  "eslintConfig": {
-    "root": true,
-    "parserOptions": {
-      "ecmaFeatures": {
-        "ecmaVersion": 2020
-      }
-    },
-    "extends": [
-      "standard",
-      "prettier",
-      "prettier/prettier"
-    ],
-    "rules": {
-      "quotes": [
-        "error",
-        "single",
-        {
-          "avoidEscape": true,
-          "allowTemplateLiterals": true
-        }
-      ]
-    }
+  "scripts": {
+    "build": "rimraf lib && tsc && amaroc ./src/index.ts && mv src/index.js lib/",
+    "prepublishOnly": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test",
+    "test:ci": "node --test"
   },
   "devDependencies": {
-    "eslint": "^8.12.0",
-    "eslint-config-prettier": "^8.4.0",
-    "eslint-config-standard": "^16.0.3",
-    "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.0.0",
-    "husky": "^7.0.4",
-    "lint-staged": "^12.3.7",
-    "prettier": "^2.6.2"
+    "@types/node": "^25.2.3",
+    "amaroc": "^1.0.1",
+    "oxlint-tsgolint": "^0.12.2",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3"
   },
-  "scripts": {
-    "prepare": "husky install"
-  }
+  "gitHead": "43180e101ef8e6b579c60f24ab5329577627134e"
 }

package/.editorconfig

@@ -1,12 +0,0 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false

package/.husky/pre-commit

@@ -1,3 +0,0 @@
-#!/bin/sh
-. "$(dirname "$0")/_/husky.sh"
-npx lint-staged

package/index.js

@@ -1,125 +0,0 @@
-const WRITE_INDEX = 0
-const READ_INDEX = 1
-const END_OF_PACKET = -1
-
-export function alloc(size) {
-  return {
-    sharedState: new SharedArrayBuffer(8),
-    sharedBuffer: new SharedArrayBuffer(size),
-  }
-}
-
-async function* _reader({ sharedState, sharedBuffer }, cb) {
-  const state = new Int32Array(sharedState)
-  const buffer = Buffer.from(sharedBuffer)
-
-  let readPos = 0
-  let writePos = 0
-
-  while (true) {
-    const { async, value } = Atomics.waitAsync(state, WRITE_INDEX, writePos)
-    if (async) {
-      await value
-    }
-    writePos = Atomics.load(state, WRITE_INDEX)
-
-    while (readPos !== writePos) {
-      const len = buffer.readInt32LE(readPos)
-
-      if (len === END_OF_PACKET) {
-        readPos = 0
-      } else {
-        const raw = buffer.slice(readPos + 4, readPos + len)
-        readPos += len
-        if (cb) {
-          cb(raw)
-        } else {
-          yield raw
-        }
-      }
-
-      Atomics.store(state, READ_INDEX, readPos)
-    }
-
-    Atomics.notify(state, READ_INDEX)
-  }
-}
-
-export function reader(options, cb) {
-  if (cb) {
-    _reader(options, cb).next()
-  } else {
-    return _reader(options)
-  }
-}
-
-export function writer({ sharedState, sharedBuffer }) {
-  const state = new Int32Array(sharedState)
-  const buffer = Buffer.from(sharedBuffer)
-  const size = buffer.byteLength
-  const queue = []
-
-  let readPos = 0
-  let writePos = 0
-  let flushing = null
-
-  function tryWrite(...raw) {
-    readPos = Atomics.load(state, READ_INDEX)
-
-    const len = raw.reduce((len, buf) => len + buf.byteLength, 4)
-
-    if (size - writePos < len + 4) {
-      if (readPos < len + 4) {
-        return false
-      }
-
-      buffer.writeInt32LE(-1, writePos)
-      writePos = 0
-    } else {
-      const available = writePos >= readPos ? size - writePos : readPos - writePos
-
-      if (available < len + 4) {
-        return false
-      }
-    }
-
-    buffer.writeInt32LE(len, writePos)
-    writePos += 4
-
-    for (const buf of raw) {
-      buffer.set(buf, writePos)
-      writePos += buf.byteLength
-    }
-
-    Atomics.store(state, WRITE_INDEX, writePos)
-    Atomics.notify(state, WRITE_INDEX)
-
-    return true
-  }
-
-  async function flush() {
-    while (queue.length) {
-      while (!tryWrite(queue[0])) {
-        const { async, value } = Atomics.waitAsync(state, READ_INDEX, readPos)
-        if (async) {
-          await value
-        }
-      }
-      queue.shift()
-    }
-
-    flushing = null
-  }
-
-  function write(...raw) {
-    if (!queue.length && tryWrite(...raw)) {
-      return
-    }
-
-    queue.push(Buffer.concat(raw))
-
-    return (flushing ??= flush())
-  }
-
-  return write
-}