tardis-machine 18.0.0 → 18.1.0

package/node_modules/tardis-dev/src/realtimefeeds/mexcprotobuf.ts

@@ -0,0 +1,364 @@
+const textDecoder = new TextDecoder()
+
+// Decodes only the current MEXC real-time channels supported by MexcRealTimeFeed.
+// Field numbers mirror the official schemas at commit 7b8ac7a6681f28551612a5a7cefbb7e09b56bb85:
+// https://github.com/mexcdevelop/websocket-proto/tree/7b8ac7a6681f28551612a5a7cefbb7e09b56bb85
+// int64 values remain decimal strings and repeated fields remain empty arrays when absent,
+// preserving the output shape previously produced by protobufjs.
+export function decodeMexcProtobufMessage(data: Uint8Array) {
+  const reader = new ProtobufReader(data)
+  const message: {
+    channel?: string
+    symbol?: string
+    symbolId?: string
+    createTime?: string
+    sendTime?: string
+    publicAggreDepths?: ReturnType<typeof decodeDepths>
+    publicAggreDeals?: ReturnType<typeof decodeDeals>
+    publicAggreBookTicker?: ReturnType<typeof decodeBookTicker>
+  } = {}
+
+  while (reader.done === false) {
+    const { fieldNumber, wireType } = reader.readTag()
+
+    switch (fieldNumber) {
+      case 1:
+        message.channel = reader.readString(wireType)
+        break
+      case 3:
+        message.symbol = reader.readString(wireType)
+        break
+      case 4:
+        message.symbolId = reader.readString(wireType)
+        break
+      case 5:
+        message.createTime = reader.readInt64String(wireType)
+        break
+      case 6:
+        message.sendTime = reader.readInt64String(wireType)
+        break
+      case 313:
+        message.publicAggreDepths = decodeDepths(reader.readBytes(wireType))
+        break
+      case 314:
+        message.publicAggreDeals = decodeDeals(reader.readBytes(wireType))
+        break
+      case 315:
+        message.publicAggreBookTicker = decodeBookTicker(reader.readBytes(wireType))
+        break
+      default:
+        reader.skipField(wireType)
+    }
+  }
+
+  return message
+}
+
+function decodeDeals(data: Uint8Array) {
+  const reader = new ProtobufReader(data)
+  const message: { deals: ReturnType<typeof decodeTrade>[]; eventType?: string } = { deals: [] }
+
+  while (reader.done === false) {
+    const { fieldNumber, wireType } = reader.readTag()
+
+    switch (fieldNumber) {
+      case 1:
+        message.deals.push(decodeTrade(reader.readBytes(wireType)))
+        break
+      case 2:
+        message.eventType = reader.readString(wireType)
+        break
+      default:
+        reader.skipField(wireType)
+    }
+  }
+
+  return message
+}
+
+function decodeTrade(data: Uint8Array) {
+  const reader = new ProtobufReader(data)
+  const message: { price?: string; quantity?: string; tradeType?: number; time?: string; tradeId?: string } = {}
+
+  while (reader.done === false) {
+    const { fieldNumber, wireType } = reader.readTag()
+
+    switch (fieldNumber) {
+      case 1:
+        message.price = reader.readString(wireType)
+        break
+      case 2:
+        message.quantity = reader.readString(wireType)
+        break
+      case 3:
+        message.tradeType = reader.readInt32(wireType)
+        break
+      case 4:
+        message.time = reader.readInt64String(wireType)
+        break
+      case 5:
+        message.tradeId = reader.readString(wireType)
+        break
+      default:
+        reader.skipField(wireType)
+    }
+  }
+
+  return message
+}
+
+function decodeDepths(data: Uint8Array) {
+  const reader = new ProtobufReader(data)
+  const message: {
+    asks: ReturnType<typeof decodePriceLevel>[]
+    bids: ReturnType<typeof decodePriceLevel>[]
+    eventType?: string
+    fromVersion?: string
+    toVersion?: string
+    lastOrderCreateTime?: string
+  } = { asks: [], bids: [] }
+
+  while (reader.done === false) {
+    const { fieldNumber, wireType } = reader.readTag()
+
+    switch (fieldNumber) {
+      case 1:
+        message.asks.push(decodePriceLevel(reader.readBytes(wireType)))
+        break
+      case 2:
+        message.bids.push(decodePriceLevel(reader.readBytes(wireType)))
+        break
+      case 3:
+        message.eventType = reader.readString(wireType)
+        break
+      case 4:
+        message.fromVersion = reader.readString(wireType)
+        break
+      case 5:
+        message.toVersion = reader.readString(wireType)
+        break
+      case 6:
+        message.lastOrderCreateTime = reader.readInt64String(wireType)
+        break
+      default:
+        reader.skipField(wireType)
+    }
+  }
+
+  return message
+}
+
+function decodePriceLevel(data: Uint8Array) {
+  const reader = new ProtobufReader(data)
+  const message: { price?: string; quantity?: string } = {}
+
+  while (reader.done === false) {
+    const { fieldNumber, wireType } = reader.readTag()
+
+    switch (fieldNumber) {
+      case 1:
+        message.price = reader.readString(wireType)
+        break
+      case 2:
+        message.quantity = reader.readString(wireType)
+        break
+      default:
+        reader.skipField(wireType)
+    }
+  }
+
+  return message
+}
+
+function decodeBookTicker(data: Uint8Array) {
+  const reader = new ProtobufReader(data)
+  const message: {
+    bidPrice?: string
+    bidQuantity?: string
+    askPrice?: string
+    askQuantity?: string
+    version?: string
+    lastOrderCreateTime?: string
+  } = {}
+
+  while (reader.done === false) {
+    const { fieldNumber, wireType } = reader.readTag()
+
+    switch (fieldNumber) {
+      case 1:
+        message.bidPrice = reader.readString(wireType)
+        break
+      case 2:
+        message.bidQuantity = reader.readString(wireType)
+        break
+      case 3:
+        message.askPrice = reader.readString(wireType)
+        break
+      case 4:
+        message.askQuantity = reader.readString(wireType)
+        break
+      case 5:
+        message.version = reader.readString(wireType)
+        break
+      case 6:
+        message.lastOrderCreateTime = reader.readInt64String(wireType)
+        break
+      default:
+        reader.skipField(wireType)
+    }
+  }
+
+  return message
+}
+
+class ProtobufReader {
+  private offset = 0
+
+  constructor(private readonly data: Uint8Array) {}
+
+  get done() {
+    return this.offset === this.data.length
+  }
+
+  readTag() {
+    const tag = this.readVarint()
+    if (typeof tag === 'bigint' || tag > 0xffffffff) {
+      throw new Error('Invalid protobuf tag')
+    }
+
+    const fieldNumber = tag >>> 3
+    const wireType = tag & 7
+
+    if (fieldNumber === 0) {
+      throw new Error('Invalid protobuf field number 0')
+    }
+
+    return { fieldNumber, wireType }
+  }
+
+  readString(wireType: number) {
+    this.expectWireType(wireType, 2)
+    const length = this.readLength()
+    const start = this.offset
+    const end = start + length
+
+    if (end > this.data.length) {
+      throw new Error('Invalid protobuf message length')
+    }
+
+    this.offset = end
+    return Buffer.isBuffer(this.data) ? this.data.toString('utf8', start, end) : textDecoder.decode(this.data.subarray(start, end))
+  }
+
+  readBytes(wireType: number) {
+    this.expectWireType(wireType, 2)
+    const length = this.readLength()
+    const end = this.offset + length
+
+    if (end > this.data.length) {
+      throw new Error('Invalid protobuf message length')
+    }
+
+    const value = this.data.subarray(this.offset, end)
+    this.offset = end
+    return value
+  }
+
+  readInt32(wireType: number) {
+    this.expectWireType(wireType, 0)
+    const value = this.readVarint()
+    return typeof value === 'number' ? value | 0 : Number(BigInt.asIntN(32, value))
+  }
+
+  readInt64String(wireType: number) {
+    this.expectWireType(wireType, 0)
+    const value = this.readVarint()
+    return typeof value === 'number' ? value.toString() : BigInt.asIntN(64, value).toString()
+  }
+
+  skipField(wireType: number): void {
+    switch (wireType) {
+      case 0:
+        this.skipVarint()
+        return
+      case 1:
+        this.skipBytes(8)
+        return
+      case 2:
+        this.skipBytes(this.readLength())
+        return
+      case 5:
+        this.skipBytes(4)
+        return
+      default:
+        throw new Error(`Unsupported protobuf wire type ${wireType}`)
+    }
+  }
+
+  private readVarint() {
+    let value = 0
+    let multiplier = 1
+
+    // Seven base-128 digits use at most 49 bits, so they remain exact and fast as a number.
+    for (let index = 0; index < 7; index++) {
+      const byte = this.readByte()
+      value += (byte & 0x7f) * multiplier
+
+      if ((byte & 0x80) === 0) {
+        return value
+      }
+      multiplier *= 0x80
+    }
+
+    // Larger int64 values need BigInt to preserve every bit before converting them to strings.
+    let bigValue = BigInt(value)
+    for (let index = 7; index < 10; index++) {
+      const byte = this.readByte()
+      bigValue |= BigInt(byte & 0x7f) << BigInt(index * 7)
+
+      if ((byte & 0x80) === 0) {
+        return bigValue
+      }
+    }
+
+    throw new Error('Invalid protobuf varint')
+  }
+
+  private readLength() {
+    const length = this.readVarint()
+    if (typeof length === 'bigint' || Number.isSafeInteger(length) === false) {
+      throw new Error('Invalid protobuf message length')
+    }
+    return length
+  }
+
+  private skipVarint() {
+    for (let index = 0; index < 10; index++) {
+      if ((this.readByte() & 0x80) === 0) {
+        return
+      }
+    }
+    throw new Error('Invalid protobuf varint')
+  }
+
+  private readByte() {
+    if (this.offset >= this.data.length) {
+      throw new Error('Unexpected end of protobuf message')
+    }
+    return this.data[this.offset++]!
+  }
+
+  private skipBytes(length: number) {
+    const end = this.offset + length
+    if (Number.isSafeInteger(length) === false || end > this.data.length) {
+      throw new Error('Invalid protobuf message length')
+    }
+    this.offset = end
+  }
+
+  private expectWireType(actual: number, expected: number) {
+    if (actual !== expected) {
+      throw new Error(`Invalid protobuf wire type ${actual}, expected ${expected}`)
+    }
+  }
+}

package/node_modules/tardis-dev/src/realtimefeeds/realtimefeed.ts

@@ -1,8 +1,8 @@
-import dbg from 'debug'
 import WebSocket, { createWebSocketStream } from 'ws'
 import type { ClientRequestArgs } from 'http'
 import { PassThrough, Writable } from 'stream'
 import { setTimeout as sleep } from 'node:timers/promises'
+import { createDebug, type DebugLogger } from '../debug.ts'
 import { getProxyAgent, ONE_SEC_IN_MS, optimizeFilters } from '../handy.ts'
 import { createManagedRealTimeIterator, mergeRealTime, type ManagedRealTimeIterator } from '../realtimeiterator.ts'
 import { Exchange, Filter } from '../types.ts'
@@ -34,7 +34,7 @@ export abstract class RealTimeFeedBase implements RealTimeFeedIterable {
     return createManagedRealTimeIterator(this._stream(), () => this._close())
   }
 
-  protected readonly debug: dbg.Debugger
+  protected readonly debug: DebugLogger
   protected abstract readonly wssURL: string
   protected readonly throttleSubscribeMS: number = 0
   protected readonly manualSnapshotsBuffer: any[] = []
@@ -53,7 +53,7 @@ export abstract class RealTimeFeedBase implements RealTimeFeedIterable {
     private readonly _onError?: (error: Error) => void
   ) {
     this._filters = optimizeFilters(filters)
-    this.debug = dbg(`tardis-dev:realtime:${_exchange}`)
+    this.debug = createDebug(`tardis-dev:realtime:${_exchange}`)
 
     this._wsClientOptions = {
       headers: {
@@ -479,7 +479,7 @@ export abstract class MultiConnectionRealTimeFeedBase implements RealTimeFeedIte
 }
 
 export abstract class PoolingClientBase implements RealTimeFeedIterable {
-  protected readonly debug: dbg.Debugger
+  protected readonly debug: DebugLogger
   private _tid: NodeJS.Timeout | undefined = undefined
   private _outputStream: PassThrough | undefined
 
@@ -488,7 +488,7 @@ export abstract class PoolingClientBase implements RealTimeFeedIterable {
     private readonly _poolingIntervalSeconds: number,
     protected readonly onError?: (error: Error) => void
   ) {
-    this.debug = dbg(`tardis-dev:pooling-client:${exchange}`)
+    this.debug = createDebug(`tardis-dev:pooling-client:${exchange}`)
   }
 
   [Symbol.asyncIterator](): ManagedRealTimeIterator<any> {

package/node_modules/tardis-dev/src/replay.ts

@@ -2,7 +2,7 @@ import { createReadStream } from 'node:fs'
 import { rm } from 'node:fs/promises'
 import { EventEmitter, once } from 'events'
 import { Worker } from 'worker_threads'
-import { constants, createGunzip, createZstdDecompress } from 'zlib'
+import { constants, createGunzip } from 'zlib'
 import { BinarySplitBatchStream } from './binarysplit.ts'
 import { clearCacheSync } from './clearcache.ts'
 import { EXCHANGES, EXCHANGE_CHANNELS_INFO } from './consts.ts'
@@ -12,6 +12,7 @@ import { Mapper, MapperFactory, normalizeBookChanges } from './mappers/index.ts'
 import { getOptions } from './options.ts'
 import { Disconnect, Exchange, FilterForExchange } from './types.ts'
 import { WorkerJobPayload, WorkerMessage, WorkerSignal } from './worker.ts'
+import { createZstdDecompressionStream } from './zstd.ts'
 
 type MapperOutput<T> = T extends MapperFactory<any, infer U> ? U : never
 type ReplayNormalizedMessage<U extends readonly MapperFactory<any, any>[], Z extends boolean> = Z extends true
@@ -170,9 +171,10 @@ async function* replayLineBatches<T extends Exchange>({
       // response is a path to file on disk let' read it as stream
       const { slicePath: cachedSlicePath, sliceSize } = cachedSlice
       const isZstdSlice = cachedSlicePath.endsWith('.zst')
-      const linesStream = createReadStream(cachedSlicePath, { highWaterMark: CHUNK_SIZE })
-        // decompress it while preserving the on-disk cache in the negotiated wire format
-        .pipe(isZstdSlice ? createZstdDecompress({ chunkSize: CHUNK_SIZE }) : createGunzip(GZIP_OPTIONS))
+      const decompressedStream = isZstdSlice
+        ? createZstdDecompressionStream(cachedSlicePath, CHUNK_SIZE)
+        : createReadStream(cachedSlicePath, { highWaterMark: CHUNK_SIZE }).pipe(createGunzip(GZIP_OPTIONS))
+      const linesStream = decompressedStream
         .on('error', function onDecompressionError(err) {
           debug('%s decompression error %o', isZstdSlice ? 'zstd' : 'gzip', err)
           linesStream.destroy(err)

package/node_modules/tardis-dev/src/worker.ts

@@ -1,13 +1,14 @@
-import dbg from 'debug'
 import { existsSync } from 'node:fs'
 import { isMainThread, parentPort, workerData } from 'worker_threads'
+import { createDebug } from './debug.ts'
 import { forEachConcurrent } from './foreachconcurrent.ts'
 import { addMinutes, download, formatDateToPath, optimizeFilters, sha256, wait, cleanTempFiles } from './handy.ts'
 import type { DataFeedCompression } from './options.ts'
 import { Exchange, Filter } from './types.ts'
-const debug = dbg('tardis-dev')
+const debug = createDebug('tardis-dev')
 
 const DEFAULT_DATA_FEED_SLICE_SIZE = 1
+const DATA_FEED_DOWNLOAD_ATTEMPT_TIMEOUT_MS = 135_000
 
 if (isMainThread) {
   debug('current worker is not meant to run in main thread')
@@ -162,7 +163,8 @@ async function getDataFeedSlice(
     }
   }
 
-  let url = `${endpoint}/data-feeds/${exchange}?from=${fromDate.toISOString()}&offset=${offset}&compression=${dataFeedCompression}`
+  const requestCompression = dataFeedCompression === 'zstd' ? 'zstd-multiframe' : dataFeedCompression
+  let url = `${endpoint}/data-feeds/${exchange}?from=${fromDate.toISOString()}&offset=${offset}&compression=${requestCompression}`
   if (requestedSliceSize > DEFAULT_DATA_FEED_SLICE_SIZE) {
     url += `&sliceSize=${requestedSliceSize}`
   }
@@ -177,7 +179,8 @@ async function getDataFeedSlice(
     url,
     userAgent,
     appendContentEncodingExtension: true,
-    acceptEncoding: dataFeedCompression === 'gzip' ? 'gzip' : 'zstd, gzip'
+    acceptEncoding: dataFeedCompression === 'gzip' ? 'gzip' : 'zstd, gzip',
+    attemptTimeoutMS: DATA_FEED_DOWNLOAD_ATTEMPT_TIMEOUT_MS
   })
   const responseSliceSize = Number(downloadResult.headers['x-slice-size'])
   const suggestedSliceSize = Number(downloadResult.headers['x-suggested-slice-size'] ?? DEFAULT_DATA_FEED_SLICE_SIZE)

package/node_modules/tardis-dev/src/zstd.ts

@@ -0,0 +1,139 @@
+import { once } from 'node:events'
+import { open, type FileHandle } from 'node:fs/promises'
+import { Readable } from 'node:stream'
+import { createZstdDecompress } from 'node:zlib'
+
+const ZSTD_FRAME_MAGIC = 0xfd2fb528
+const DICTIONARY_ID_SIZES = [0, 1, 2, 4]
+
+export function createZstdDecompressionStream(path: string, chunkSize: number) {
+  return Readable.from(decompressZstdFrames(path, chunkSize), { objectMode: false })
+}
+
+async function* decompressZstdFrames(path: string, chunkSize: number) {
+  const file = await open(path, 'r')
+  try {
+    const fileSize = (await file.stat()).size
+    const frames = await findZstdFrames(file, path, fileSize)
+
+    for (const frame of frames) {
+      const source = Readable.from(readFileRange(file, frame.offset, frame.length, chunkSize), { objectMode: false })
+      const decompressor = createZstdDecompress({ chunkSize })
+      source.on('error', (error) => decompressor.destroy(error))
+      source.pipe(decompressor)
+
+      try {
+        for await (const chunk of decompressor) {
+          yield chunk
+        }
+
+        if (decompressor.bytesWritten !== frame.length) {
+          throw new Error(
+            `Zstd decoder consumed ${decompressor.bytesWritten} of ${frame.length} bytes at offset ${frame.offset} in ${path}`
+          )
+        }
+      } finally {
+        source.unpipe(decompressor)
+        source.destroy()
+        decompressor.destroy()
+        if (!source.closed) {
+          await once(source, 'close')
+        }
+      }
+    }
+  } finally {
+    await file.close()
+  }
+}
+
+async function findZstdFrames(file: FileHandle, path: string, fileSize: number) {
+  if (fileSize === 0) {
+    throw new Error(`Empty zstd file: ${path}`)
+  }
+
+  const bytes = Buffer.allocUnsafe(4)
+  const frames: { offset: number; length: number }[] = []
+  let offset = 0
+
+  while (offset < fileSize) {
+    const frameStart = offset
+    await readExactly(file, bytes, 4, offset, fileSize, path)
+    if (bytes.readUInt32LE(0) !== ZSTD_FRAME_MAGIC) {
+      throw new Error(`Invalid zstd frame magic at offset ${offset} in ${path}`)
+    }
+    offset += 4
+
+    await readExactly(file, bytes, 1, offset, fileSize, path)
+    const descriptor = bytes[0]
+    if ((descriptor & 0x08) !== 0) {
+      throw new Error(`Unsupported reserved zstd frame descriptor bit at offset ${offset} in ${path}`)
+    }
+    offset++
+
+    const singleSegment = (descriptor & 0x20) !== 0
+    const contentChecksum = (descriptor & 0x04) !== 0
+    const dictionaryIdSize = DICTIONARY_ID_SIZES[descriptor & 0x03]
+    const contentSizeFlag = descriptor >>> 6
+    const contentSizeSize = contentSizeFlag === 0 ? (singleSegment ? 1 : 0) : 1 << contentSizeFlag
+    const windowDescriptorSize = singleSegment ? 0 : 1
+    offset += windowDescriptorSize + dictionaryIdSize + contentSizeSize
+    ensureAvailable(offset, 0, fileSize, path)
+
+    let lastBlock = false
+    while (!lastBlock) {
+      await readExactly(file, bytes, 3, offset, fileSize, path)
+      const blockHeader = bytes.readUIntLE(0, 3)
+      offset += 3
+      lastBlock = (blockHeader & 1) !== 0
+      const blockType = (blockHeader >>> 1) & 3
+      if (blockType === 3) {
+        throw new Error(`Invalid reserved zstd block type at offset ${offset - 3} in ${path}`)
+      }
+
+      const blockSize = blockHeader >>> 3
+      // RLE blocks store one repeated byte; other block types store blockSize bytes.
+      offset += blockType === 1 ? 1 : blockSize
+      ensureAvailable(offset, 0, fileSize, path)
+    }
+
+    if (contentChecksum) {
+      offset += 4
+      ensureAvailable(offset, 0, fileSize, path)
+    }
+    frames.push({ offset: frameStart, length: offset - frameStart })
+  }
+
+  return frames
+}
+
+async function* readFileRange(file: FileHandle, position: number, length: number, chunkSize: number) {
+  let bytesRemaining = length
+  while (bytesRemaining > 0) {
+    const buffer = Buffer.allocUnsafe(Math.min(bytesRemaining, chunkSize))
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, position)
+    if (bytesRead === 0) {
+      throw new Error(`Expected ${length} compressed bytes, read ${length - bytesRemaining}`)
+    }
+    yield bytesRead === buffer.length ? buffer : buffer.subarray(0, bytesRead)
+    position += bytesRead
+    bytesRemaining -= bytesRead
+  }
+}
+
+async function readExactly(file: FileHandle, buffer: Buffer, length: number, position: number, fileSize: number, path: string) {
+  ensureAvailable(position, length, fileSize, path)
+  let bytesRead = 0
+  while (bytesRead < length) {
+    const result = await file.read(buffer, bytesRead, length - bytesRead, position + bytesRead)
+    if (result.bytesRead === 0) {
+      throw new Error(`Truncated zstd frame at offset ${position + bytesRead} in ${path}`)
+    }
+    bytesRead += result.bytesRead
+  }
+}
+
+function ensureAvailable(position: number, length: number, fileSize: number, path: string) {
+  if (position < 0 || length < 0 || position > fileSize - length) {
+    throw new Error(`Truncated zstd frame at offset ${position} in ${path}`)
+  }
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "tardis-machine",
-  "version": "18.0.0",
+  "version": "18.1.0",
   "engines": {
-    "node": ">=24.5"
+    "node": ">=24.19"
   },
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": "^24.15.0 || >=26.0.0"
+      "version": "^24.19.0 || >=26.0.0"
     },
     "packageManager": {
       "name": "npm",
@@ -31,7 +31,8 @@
   "homepage": "https://github.com/tardis-dev/tardis-machine",
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && cross-env UWS_HTTP_MAX_HEADERS_SIZE=20000 node --experimental-vm-modules ./node_modules/jest/bin/jest.js --forceExit --runInBand",
+    "test": "npm run build && tsc -p test/tsconfig.json && node --test test/*.test.ts",
+    "test:update-snapshots": "npm run build && tsc -p test/tsconfig.json && node --test --test-update-snapshots test/*.test.ts",
     "prepare": "npm run build",
     "format": "prettier --write .",
     "check-format": "prettier --check .",
@@ -74,43 +75,16 @@
   ],
   "license": "MPL-2.0",
   "dependencies": {
-    "debug": "^4.4.1",
-    "tardis-dev": "^18.0.1",
-    "uWebSockets.js": "git+https://github.com/uNetworking/uWebSockets.js.git#dddd8ffd1b2c28a66022160923ca92f064cdacb4"
+    "debug": "^4.4.3",
+    "tardis-dev": "^18.1.0",
+    "ws": "^8.21.1"
   },
   "bundleDependencies": true,
   "devDependencies": {
     "@types/debug": "^4.1.12",
-    "@types/jest": "^30.0.0",
     "@types/node": "^26.1.2",
-    "@types/node-fetch": "^2.6.13",
-    "@types/split2": "^4.2.3",
     "@types/ws": "^8.18.1",
-    "cross-env": "^10.1.0",
-    "jest": "^30.0.5",
-    "node-fetch": "^2.6.1",
     "prettier": "^3.8.3",
-    "split2": "^4.2.0",
-    "ts-jest": "^29.4.0",
-    "typescript": "^5.9.2",
-    "ws": "^8.18.3"
-  },
-  "jest": {
-    "extensionsToTreatAsEsm": [
-      ".ts"
-    ],
-    "moduleNameMapper": {
-      "^(\\.{1,2}/.*)\\.js$": "$1"
-    },
-    "transform": {
-      "\\.(ts|tsx)?$": [
-        "ts-jest",
-        {
-          "useESM": true,
-          "tsconfig": "./test/tsconfig.json"
-        }
-      ]
-    },
-    "testEnvironment": "node"
+    "typescript": "^6.0.3"
   }
 }