@nxtedition/lib 28.0.6 → 28.0.8

package/app.js

@@ -635,19 +635,7 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
       stats$ = rxjs.timer(0, 10e3).pipe(rx.map(() => ({})))
     }
 
-    const memoryUsageBC = new BroadcastChannel('nxt:memoryUsage').unref()
-
-    let memoryUsageMap
-    if (isMainThread) {
-      memoryUsageMap = new Map()
-      memoryUsageBC.onmessage = ({ data: { data, id } }) => {
-        memoryUsageMap.set(id, data)
-      }
-    }
-
-    setInterval(() => {
-      memoryUsageBC.postMessage({ data: process.memoryUsage(), id: serviceWorkerId })
-    }, 1e3).unref()
+    let statsMap
 
     const startTime = Date.now()
     stats$ = stats$.pipe(
@@ -679,12 +667,21 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
               totalArrayBuffers: 0,
             }
 
-            if (memoryUsageMap) {
-              for (const memoryUsage of memoryUsageMap.values()) {
-                memory.totalHeapTotal += memoryUsage.heapTotal
-                memory.totalHeapUsed += memoryUsage.heapUsed
-                memory.totalExternal += memoryUsage.external
-                memory.totalArrayBuffers += memoryUsage.arrayBuffers
+            const http = {
+              userAgent,
+              pending: globalThis._nxt_lib_http_pending?.size,
+              totalPending: 0,
+            }
+
+            const undici = {
+              sockets: globalThis.__undici_sockets?.size ?? 0,
+              totalSockets: 0,
+            }
+
+            if (statsMap) {
+              for (const stats of statsMap.values()) {
+                http.totalPending += stats.http?.pending ?? 0
+                undici.totalSockets += stats.undici?.sockets ?? 0
               }
             }
 
@@ -700,13 +697,8 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
               resourceLimits,
               utilization: performance.eventLoopUtilization?.(elu2, elu1),
               heap: v8.getHeapStatistics(),
-              http: {
-                userAgent,
-                pending: globalThis._nxt_lib_http_pending?.size,
-              },
-              undici: {
-                sockets: globalThis.__undici_sockets?.size ?? 0,
-              },
+              http,
+              undici,
             }
           }),
         ),
@@ -726,11 +718,20 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
       rx.refCount(),
     )
 
+    const statsBC = new BroadcastChannel('nxt:app:stats').unref()
+    if (isMainThread) {
+      statsMap = new Map()
+      statsBC.onmessage = ({ data: { data, id } }) => {
+        statsMap.set(id, data)
+      }
+    }
+
     monitorProviders.stats$ = stats$
 
     if (process.env.NODE_ENV === 'production') {
       appDestroyers.unshift(
         stats$.pipe(rx.auditTime(10e3)).subscribe((stats) => {
+          statsBC.postMessage({ id: threadId, data: stats })
           logger.debug(stats, 'STATS')
         }),
       )
@@ -779,7 +780,7 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
             rx.repeatWhen((complete$) => complete$.pipe(rx.delay(10e3))),
           ),
           stats$.pipe(
-            rx.map(({ memory, heap, utilization, undici }) => {
+            rx.map(({ memory, heap, utilization, undici, http }) => {
               const messages = []
 
               if (memory?.containerLimit) {
@@ -812,8 +813,16 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
               if (undici) {
                 messages.push({
                   id: 'app:undici_upstream_sockets',
-                  level: undici.sockets > 8192 ? 50 : undici.sockets > 4096 ? 40 : 30,
-                  msg: `Undici: ${undici.sockets} upstream connected`,
+                  level: undici.totalSockets > 8192 ? 50 : undici.totalSockets > 4096 ? 40 : 30,
+                  msg: `Undici: ${undici.totalSockets} upstream connected`,
+                })
+              }
+
+              if (http) {
+                messages.push({
+                  id: 'app:http_pending_requests',
+                  level: http.totalPending > 8192 ? 50 : http.totalPending > 4096 ? 40 : 30,
+                  msg: `HTTP: ${http.totalPending} pending requests`,
                 })
               }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "28.0.6",
+  "version": "28.0.8",
   "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -92,5 +92,5 @@
     "pino": ">=7.0.0",
     "rxjs": "^7.0.0"
   },
-  "gitHead": "008526f8d31968edaa2e642998deaa3880a34bb8"
+  "gitHead": "5d6fb19ef1936e749aadecc51007ddda71dcf0a3"
 }

package/sequence.js

@@ -96,11 +96,10 @@ export class Sequence {
         this.#value = '0'
       } else if (Array.isArray(value)) {
         this.#identity = identity
-        this.#count = 0
         for (const part of value) {
           if (typeof part === 'string') {
-            const [sequenceStr, id] = part.split(ID_SEP)
-            const sequence = parseInt(sequenceStr)
+            const [sequenceStr, id] = part.split(ID_SEP, 2)
+            const sequence = Number(sequenceStr)
             this.#parts.push(id, sequence)
             this.#identity = null
             this.#count += part
@@ -117,16 +116,15 @@ export class Sequence {
         }
         assert(this.#identity === 0 || this.#parts.length > 0)
       } else if (typeof value === 'string') {
-        const [countStr, token] = value.split('-')
-        const count = parseInt(countStr)
+        const [countStr, token] = value.split('-', 2)
         if (token) {
           for (const str of token.split('_')) {
             const [sequenceStr, id] = str.split(ID_SEP)
-            const sequence = parseInt(sequenceStr)
+            const sequence = Number(sequenceStr)
             this.#parts.push(id, sequence)
           }
         }
-        this.#count = count
+        this.#count = Number(countStr)
         this.#value = value
       } else if (value instanceof Sequence) {
         this.#count = value.#count
@@ -141,10 +139,6 @@ export class Sequence {
         throw new Error('invalid sequence count')
       }
 
-      if (!Array.isArray(this.#parts)) {
-        throw new Error('invalid sequence parts')
-      }
-
       {
         let count = 0
         for (let n = 0; n < this.#parts.length; n += 2) {
@@ -289,7 +283,13 @@ export class Sequence {
       throw new TypeError('strict must be a boolean')
     }
 
-    if (strict && (other.identity || this.identity) && other.identity !== this.identity) {
+    if (
+      strict &&
+      (other.identity || this.identity) &&
+      other.identity !== this.identity &&
+      this.#value !== '0' &&
+      other.#value !== '0'
+    ) {
       throw new Error('Cannot compare sequences with different identities')
     }
 

package/shared.js

@@ -1,6 +1,3 @@
-import stream from 'node:stream'
-import assert from 'node:assert'
-
 // 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
@@ -21,11 +18,22 @@ const HWM_COUNT = 1024 // 1024 items
  * @returns {{sharedState: SharedArrayBuffer, sharedBuffer: SharedArrayBuffer}}
  */
 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.
-    sharedBuffer: new SharedArrayBuffer(size),
+    // We need another 8 bytes for entry headers.
+    sharedBuffer: new SharedArrayBuffer(size + 8),
   }
 }
 
@@ -35,6 +43,16 @@ export function alloc(size) {
  * @returns {{ readSome: function }}
  */
 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)
@@ -52,7 +70,7 @@ export function reader({ sharedState, sharedBuffer }) {
 
   /**
    * Reads a batch of messages from the buffer.
-   * @param {(data: {buffer: Buffer, view: DataView, offset: number, length: number}) => void} next Callback to process a message.
+   * @param {(data: {buffer: Buffer, view: DataView, offset: number, length: number}) => void|boolean} next Callback to process a message.
    * @returns {number} The number of messages read.
    */
   function readSome(next) {
@@ -70,10 +88,11 @@ export function reader({ sharedState, sharedBuffer }) {
       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) {
-        bytes += 4
         readPos = 0
         // After wrapping, we must re-check against the writer's position.
         // It's possible the writer is now at a position > 0.
@@ -86,22 +105,17 @@ export function reader({ sharedState, sharedBuffer }) {
           throw new Error('Data exceeds buffer size')
         }
 
-        bytes += dataLen
         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
-        const cont = next(data)
-
-        if (readPos === writePos) {
-          // If we reach the end of the buffer, we must re-check the writer's position.
-          writePos = Atomics.load(state, WRITE_INDEX) | 0
-        }
 
-        if (cont === false) {
+        if (next(data) === false) {
           break
         }
       }
@@ -125,6 +139,16 @@ export function reader({ sharedState, sharedBuffer }) {
  * @returns {{ write: function, cork: function(function) }}
  */
 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)
@@ -140,7 +164,7 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
   let readPos = Atomics.load(state, READ_INDEX) | 0
   let writePos = Atomics.load(state, WRITE_INDEX) | 0
 
-  let yielding = false
+  let yielding = 0
   let corked = 0
   let pending = 0
 
@@ -153,22 +177,22 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
    * @param {number} delay The timeout for Atomics.wait.
    */
   function _yield(delay) {
-    if (yielding) {
-      throw new Error('Cannot yield while yielding')
+    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 = true
+      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 = false
+        yielding -= 1
       }
     }
 
@@ -176,6 +200,8 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
     // to sleep, consuming no CPU, until the reader changes the READ_INDEX.
     if (delay > 0) {
       Atomics.wait(state, READ_INDEX, readPos, delay)
+    } else {
+      Atomics.pause()
     }
 
     // After waking up, refresh the local view of the reader's position.
@@ -192,24 +218,22 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
     // 4-byte header for the *next* message (for wrap-around check).
     const required = len + 4 + 4
 
-    if (required < 0) {
-      throw new Error(`Required length ${required} is negative, expected at least 0`)
-    }
-    if (required > size) {
-      throw new Error(`Required length ${required} exceeds buffer size ${size}`)
-    }
-
     if (writePos >= readPos) {
-      // Case 1: The writer is ahead of the reader. [ 0 ---- R ... W ---- S ]
-      // There is free space from W to the end (S) and from 0 to R.
+      // 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
       }
 
+      if (readPos === 0) {
+        readPos = Atomics.load(state, READ_INDEX) | 0
+      }
+
       // Not enough space at the end. Check if there's space at the beginning.
       if (readPos === 0) {
-        // Reader is at the very beginning, so no space to wrap around into.
+        // Reader is at the beginning, so no space to wrap around into.
         return false
       }
 
@@ -220,17 +244,24 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
       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 ]
+    // Case 2: The writer has wrapped around. [ 0 ... W - R ... s ]
     // The only free space is between W and R.
+
+    if (readPos - writePos < required) {
+      readPos = Atomics.load(state, READ_INDEX) | 0
+    }
+
     return readPos - writePos >= required
   }
 
@@ -245,84 +276,114 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
     }
   }
 
+  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.
-   * @param {number} len The exact length of the payload.
+   * @param {number} dataCap Max length of the payload.
    * @param {({ buffer, view, offset, length }) => number} fn The callback that writes the data.
    * @returns {void}
    */
-  function _write(len, fn) {
+  function _write(dataCap, fn) {
     const dataPos = writePos + 4
 
     data.offset = dataPos
-    data.length = len
+    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 Error(`Data length ${dataLen} is negative`)
+      throw new RangeError(`"fn" returned a negative number ${dataLen}`)
     }
-    if (dataLen > len) {
-      throw new Error(`Data length ${dataLen} exceeds expected length ${len}`)
+    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}`)
     }
 
-    // Write the actual length of the data into the 4-byte header.
-    view.setInt32(writePos, dataLen, true)
-    writePos += 4 + dataLen
+    const nextPos = writePos + 4 + dataLen
 
-    if (writePos + 4 > size) {
-      throw new Error(`Write position ${writePos} with next header exceeds buffer size ${size}`)
+    if (nextPos + 4 > size) {
+      // assertion
+      throw new Error(`Write position ${nextPos} with next header exceeds buffer size ${size}`)
     }
-    if (writePos === readPos) {
-      throw new Error(`Write position ${writePos} cannot equal read position ${readPos}`)
+    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
-    // JS microtask. This drastically reduces atomic operation overhead.
+    // event loop tick. This drastically reduces atomic operation overhead.
     if (pending >= HWM_BYTES) {
       Atomics.store(state, WRITE_INDEX, writePos)
       pending = 0
-    } else {
-      pending += 4 + dataLen
-      if (corked === 0) {
-        corked += 1
-        setImmediate(_uncork)
-      }
+    } else if (corked === 0) {
+      corked += 1
+      setImmediate(_uncork)
     }
   }
 
   /**
-   * Public write method. Acquires space and writes data.
+   * 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.
    * @param {number} len The maximum expected length of the payload.
    * @param {({ buffer, view, offset, length }) => number} fn The callback that writes the data.
+   * @param {number} [timeout=60000] The maximum time to wait for space in milliseconds.
    */
-  function writeSync(len, fn) {
+  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 Error(`Length ${len} is negative`)
+      throw new RangeError(`"len" ${len} is negative`)
     }
     if (len >= 2 ** 31 || len > size - 8) {
-      throw new Error(`Length ${len} exceeds maximum allowed size`)
+      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)) {
-      readPos = Atomics.load(state, READ_INDEX) | 0
-      if (!_acquire(len)) {
-        const startTime = performance.now()
-        logger?.warn({ readPos, writePos }, 'yield started')
-        _yield(0)
-        while (!_acquire(len)) {
-          _yield(3)
+      const startTime = performance.now()
+      logger?.warn({ readPos, writePos }, 'yield started')
+      _yield(0)
+      for (let n = 0; !_acquire(len); n++) {
+        if (performance.now() - startTime > timeout) {
+          throw new Error('Timeout while waiting for space in the buffer')
         }
-        const elapsedTime = performance.now() - startTime
-        logger?.warn({ readPos, writePos, elapsedTime }, 'yield completed')
+        _yield(3)
       }
+      const elapsedTime = performance.now() - startTime
+      logger?.warn({ readPos, writePos, elapsedTime }, 'yield completed')
     }
 
     _write(len, fn)
@@ -332,19 +393,28 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
     }
   }
 
+  /**
+   * Public write method. Acquires space and tries to writes data.
+   * Writing more than "len" bytes in the callback will cause undefined behavior.
+   * @param {number} len The maximum expected length of the payload.
+   * @param {({ buffer, view, offset, length }) => number} fn The callback that writes the data.
+   */
   function tryWrite(len, fn) {
+    if (typeof len !== 'number') {
+      throw new TypeError('"len" must be a non-negative number')
+    }
     if (len < 0) {
-      throw new Error(`Length ${len} is negative`)
+      throw new RangeError(`"len" ${len} is negative`)
     }
     if (len >= 2 ** 31 || len > size - 8) {
-      throw new Error(`Length ${len} exceeds maximum allowed size`)
+      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)) {
-      readPos = Atomics.load(state, READ_INDEX) | 0
-      if (!_acquire(len)) {
-        return false
-      }
+      return false
     }
 
     _write(len, fn)
@@ -356,13 +426,6 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
     return true
   }
 
-  function _flush() {
-    if (pending > 0) {
-      Atomics.store(state, WRITE_INDEX, writePos)
-      pending = 0
-    }
-  }
-
   function cork(callback) {
     corked += 1
     try {
@@ -374,118 +437,3 @@ export function writer({ sharedState, sharedBuffer }, { yield: onYield, logger }
 
   return { tryWrite, writeSync, cork }
 }
-
-export class Writable extends stream.Writable {
-  #writer
-  #retries = 0
-  #timeout = null
-
-  #chunk
-  #encoding
-  #callback
-
-  constructor({ state, ...options }) {
-    super({ ...options })
-    this.#writer = writer(state)
-  }
-
-  _write(chunk, encoding, callback) {
-    if (chunk.byteLength === 0) {
-      callback(null)
-      return
-    }
-
-    assert(!this.#timeout)
-
-    this.#chunk = chunk
-    this.#encoding = encoding
-    this.#callback = callback
-    this._writeSome()
-  }
-
-  _final(callback) {
-    this.#chunk = Buffer.allocUnsafe(0)
-    this.#encoding = null
-    this.#callback = callback
-    this._writeSome()
-  }
-
-  _writeSome = () => {
-    this.#timeout = null
-
-    if (this.#writer.tryWrite(this.#chunk.byteLength, this._doWrite)) {
-      const callback = this.#callback
-      this.#retries = 0
-      this.#chunk = null
-      this.#encoding = null
-      this.#callback = null
-      callback(null)
-    } else {
-      this.#retries += 1
-      this.#timeout = setTimeout(this._writeSome, Math.min(10, this.#retries))
-    }
-  }
-
-  _doWrite = (data) => {
-    const written =
-      typeof this.#chunk === 'string'
-        ? data.buffer.write(this.#chunk, data.offset, data.length, this.#encoding)
-        : this.#chunk.copy(data.buffer, data.offset, 0, this.#chunk.length)
-    return data.offset + written
-  }
-
-  _destroy(err, callback) {
-    if (this.#timeout != null) {
-      clearTimeout(this.#timeout)
-      this.#timeout = null
-    }
-    callback(err)
-  }
-}
-
-export class Readable extends stream.Readable {
-  #reader
-  #retries = 0
-  #timeout
-
-  constructor({ state, ...options }) {
-    super(options)
-    this.#reader = reader(state)
-  }
-
-  _read() {
-    assert(!this.#timeout)
-
-    this._readSome()
-  }
-
-  _readSome = () => {
-    this.#timeout = null
-
-    const count = this.#reader.readSome((data) => {
-      if (data.length === 0) {
-        this.push(null)
-        return false
-      }
-
-      const chunk = Buffer.allocUnsafe(data.length)
-      data.buffer.copy(chunk, 0, data.offset, data.offset + data.length)
-      return this.push(chunk)
-    })
-
-    if (count > 0 || this.readableEnded) {
-      this.#retries = 0
-    } else {
-      this.#retries += 1
-      this.#timeout = setTimeout(this._readSome, Math.min(10, this.#retries))
-    }
-  }
-
-  _destroy(err, callback) {
-    if (this.#timeout != null) {
-      clearTimeout(this.#timeout)
-      this.#timeout = null
-    }
-    callback(err)
-  }
-}