tardis-machine 18.0.0 → 18.0.1

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/worker.ts

@@ -1,11 +1,11 @@
-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
 

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "tardis-machine",
-  "version": "18.0.0",
+  "version": "18.0.1",
   "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 .",
@@ -75,42 +76,15 @@
   "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"
+    "tardis-dev": "^18.0.2",
+    "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"
   }
 }

package/src/tardismachine.ts

@@ -1,9 +1,9 @@
 import http from 'node:http'
 import { createRequire } from 'module'
 import { clearCache, init } from 'tardis-dev'
-import { App, DISABLED, TemplatedApp } from 'uWebSockets.js'
 import { healthCheck, replayHttp, replayNormalizedHttp } from './http/index.ts'
 import { replayNormalizedWS, replayWS, streamNormalizedWS } from './ws/index.ts'
+import { MachineWebSocketServer } from './ws/server.ts'
 import { debug } from './debug.ts'
 
 const require = createRequire(import.meta.url)
@@ -11,7 +11,7 @@ const packageJson = require('../package.json') as { version: string }
 
 export class TardisMachine {
   private readonly _httpServer: http.Server
-  private readonly _wsServer: TemplatedApp
+  private readonly _wsServer: MachineWebSocketServer
   private _eventLoopTimerId: NodeJS.Timeout | undefined = undefined
 
   constructor(private readonly options: Options) {
@@ -43,55 +43,33 @@ export class TardisMachine {
     // set timeout to 0 meaning infinite http timout - streaming may take some time expecially for longer date ranges
     this._httpServer.timeout = 0
 
-    const wsRoutes = {
+    this._wsServer = new MachineWebSocketServer({
       '/ws-replay': replayWS,
       '/ws-replay-normalized': replayNormalizedWS,
       '/ws-stream-normalized': streamNormalizedWS
-    } as any
-
-    this._wsServer = App().ws('/*', {
-      compression: DISABLED,
-      maxPayloadLength: 512 * 1024,
-      idleTimeout: 60,
-      maxBackpressure: 5 * 1024 * 1024,
-      closeOnBackpressureLimit: true,
-      upgrade: (res: any, req: any, context: any) => {
-        res.upgrade(
-          { req },
-          req.getHeader('sec-websocket-key'),
-          req.getHeader('sec-websocket-protocol'),
-          req.getHeader('sec-websocket-extensions'),
-          context
-        )
-      },
-      open: (ws: any) => {
-        const path = ws.req.getUrl().toLocaleLowerCase()
-        ws.closed = false
-        const matchingRoute = wsRoutes[path]
-
-        if (matchingRoute !== undefined) {
-          matchingRoute(ws, ws.req)
-        } else {
-          ws.end(1008)
-        }
-      },
-
-      message: (ws: any, message: ArrayBuffer) => {
-        if (ws.onmessage !== undefined) {
-          ws.onmessage(message)
-        }
-      },
-
-      close: (ws: any) => {
-        ws.closed = true
-        if (ws.onclose !== undefined) {
-          ws.onclose()
-        }
-      }
-    } as any)
+    })
   }
 
   public async start(port: number) {
+    if (this.options.clearCache) {
+      await clearCache()
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      this._httpServer.once('error', reject)
+      this._httpServer.listen(port, () => {
+        this._httpServer.removeListener('error', reject)
+        resolve()
+      })
+    })
+
+    try {
+      await this._wsServer.listen(port + 1)
+    } catch (error) {
+      await new Promise<void>((resolve) => this._httpServer.close(() => resolve()))
+      throw error
+    }
+
     let start = process.hrtime()
     const interval = 500
 
@@ -108,30 +86,11 @@ export class TardisMachine {
 
       start = process.hrtime()
     }, interval)
-
-    if (this.options.clearCache) {
-      await clearCache()
-    }
-
-    await new Promise<void>((resolve, reject) => {
-      try {
-        this._httpServer.on('error', reject)
-        this._httpServer.listen(port, () => {
-          this._wsServer.listen(port + 1, (listenSocket) => {
-            if (listenSocket) {
-              resolve()
-            } else {
-              reject(new Error('ws server did not start'))
-            }
-          })
-        })
-      } catch (e) {
-        reject(e)
-      }
-    })
   }
 
   public async stop() {
+    await this._wsServer.close()
+
     await new Promise<void>((resolve, reject) => {
       this._httpServer.close((err) => {
         err ? reject(err) : resolve()

package/src/ws/replay.ts

@@ -1,15 +1,15 @@
 import { decode } from 'node:querystring'
 import { combine, Exchange, replay, ReplayOptions } from 'tardis-dev'
-import type { HttpRequest } from 'uWebSockets.js'
 import { debug } from '../debug.ts'
 import { wait } from '../helpers.ts'
+import type { MachineWebSocket } from './server.ts'
 import { SubscriptionMapper, subscriptionsMappers } from './subscriptionsmappers.ts'
 
 const replaySessions: { [sessionKey: string]: ReplaySession | undefined } = {}
 let sessionsCounter = 0
 
-export function replayWS(ws: any, req: HttpRequest) {
-  const parsedQuery = decode(req.getQuery())
+export function replayWS(ws: MachineWebSocket, query: string) {
+  const parsedQuery = decode(query)
   const from = parsedQuery['from'] as string
   const to = parsedQuery['to'] as string
   const exchange = parsedQuery['exchange'] as Exchange
@@ -94,10 +94,12 @@ class ReplaySession {
         })
 
         for await (const { message } of messages) {
+          if (connection.ws.closed) break
+
           const success = connection.ws.send(message)
           // handle backpressure in case of slow clients
           if (!success) {
-            while (connection.ws.getBufferedAmount() > 0) {
+            while (!connection.ws.closed && connection.ws.getBufferedAmount() > 0) {
               await wait(1)
             }
           }
@@ -122,10 +124,13 @@ class ReplaySession {
         })
 
         for await (const { ws, message } of combine(...messagesWithConnections)) {
+          if (this._connections.every((connection) => connection.ws.closed)) break
+          if (ws.closed) continue
+
           const success = ws.send(message)
           // handle backpressure in case of slow clients
           if (!success) {
-            while (ws.getBufferedAmount() > 0) {
+            while (!ws.closed && ws.getBufferedAmount() > 0) {
               await wait(1)
             }
           }
@@ -155,7 +160,7 @@ class ReplaySession {
       }
 
       // let's wait until buffer is empty before closing normal connections
-      while (!error && connection.ws.getBufferedAmount() > 0) {
+      while (!error && !connection.ws.closed && connection.ws.getBufferedAmount() > 0) {
         await wait(100)
       }
 
@@ -174,7 +179,7 @@ class WebsocketConnection {
   public subscriptionsCount = 0
 
   constructor(
-    public readonly ws: any,
+    public readonly ws: MachineWebSocket,
     exchange: Exchange,
     from: string,
     to: string
@@ -212,7 +217,7 @@ class WebsocketConnection {
     return `${JSON.stringify(this.replayOptions)}`
   }
 
-  private _convertSubscribeRequestToFilter(messageRaw: ArrayBuffer) {
+  private _convertSubscribeRequestToFilter(messageRaw: Buffer) {
     const message = Buffer.from(messageRaw).toString()
     try {
       const messageDeserialized = JSON.parse(message)

package/src/ws/replaynormalized.ts

@@ -1,14 +1,14 @@
 import { decode } from 'node:querystring'
 import { combine, compute, replayNormalized } from 'tardis-dev'
-import type { HttpRequest } from 'uWebSockets.js'
 import { debug } from '../debug.ts'
 import { constructDataTypeFilter, getComputables, getNormalizers, ReplayNormalizedRequestOptions, wait } from '../helpers.ts'
+import type { MachineWebSocket } from './server.ts'
 
-export async function replayNormalizedWS(ws: any, req: HttpRequest) {
+export async function replayNormalizedWS(ws: MachineWebSocket, query: string) {
   let messages: AsyncIterableIterator<any> | undefined
   try {
     const startTimestamp = new Date().getTime()
-    const parsedQuery = decode(req.getQuery())
+    const parsedQuery = decode(query)
     const optionsString = parsedQuery['options'] as string
     const replayNormalizedOptions = JSON.parse(optionsString) as ReplayNormalizedRequestOptions
 
@@ -34,6 +34,8 @@ export async function replayNormalizedWS(ws: any, req: HttpRequest) {
     messages = messagesIterables.length === 1 ? messagesIterables[0] : combine(...messagesIterables)
 
     for await (const message of messages) {
+      if (ws.closed) return
+
       if (!filterByDataType(message)) {
         continue
       }
@@ -41,13 +43,13 @@ export async function replayNormalizedWS(ws: any, req: HttpRequest) {
       const success = ws.send(JSON.stringify(message))
       // handle backpressure in case of slow clients
       if (!success) {
-        while (ws.getBufferedAmount() > 0) {
+        while (!ws.closed && ws.getBufferedAmount() > 0) {
           await wait(1)
         }
       }
     }
 
-    while (ws.getBufferedAmount() > 0) {
+    while (!ws.closed && ws.getBufferedAmount() > 0) {
       await wait(100)
     }
 
@@ -63,7 +65,7 @@ export async function replayNormalizedWS(ws: any, req: HttpRequest) {
   } catch (e: any) {
     // this will underlying open WS connections
     if (messages !== undefined) {
-      messages!.return!()
+      await messages.return?.()
     }
     if (!ws.closed) {
       ws.end(1011, e.toString())

package/src/ws/server.ts

@@ -0,0 +1,173 @@
+import http from 'node:http'
+import WebSocket, { WebSocketServer } from 'ws'
+
+const IDLE_TIMEOUT_MS = 60_000
+const HEARTBEAT_INTERVAL_MS = IDLE_TIMEOUT_MS / 2
+const MAX_HEADER_BYTES = 20_000
+const MAX_PAYLOAD_BYTES = 512 * 1024
+const MAX_BACKPRESSURE_BYTES = 5 * 1024 * 1024
+const MAX_CLOSE_REASON_BYTES = 123
+
+export type MachineWebSocket = {
+  closed: boolean
+  onmessage?: (message: Buffer) => void
+  send(message: string | ArrayBuffer | Buffer): boolean
+  getBufferedAmount(): number
+  end(code?: number, reason?: string): void
+}
+
+export type MachineWebSocketRoute = (socket: MachineWebSocket, query: string) => void | Promise<void>
+
+export class MachineWebSocketServer {
+  private readonly httpServer = http.createServer({ maxHeaderSize: MAX_HEADER_BYTES }, (_, response) => {
+    response.writeHead(426).end()
+  })
+  private readonly server = new WebSocketServer({
+    server: this.httpServer,
+    perMessageDeflate: false,
+    maxPayload: MAX_PAYLOAD_BYTES
+  })
+  private readonly connections = new Set<MachineWebSocketConnection>()
+  private heartbeatTimer: NodeJS.Timeout | undefined
+
+  constructor(private readonly routes: Record<string, MachineWebSocketRoute>) {
+    // `ws` re-emits errors from the supplied HTTP server; `listen` reports the same error to its caller.
+    this.server.on('error', () => {})
+    this.server.on('connection', (webSocket, request) => this.connect(webSocket, request.url))
+  }
+
+  public async listen(port: number) {
+    await new Promise<void>((resolve, reject) => {
+      this.httpServer.once('error', reject)
+      this.httpServer.listen(port, () => {
+        this.httpServer.removeListener('error', reject)
+        resolve()
+      })
+    })
+
+    this.heartbeatTimer = setInterval(() => {
+      for (const connection of this.connections) connection.checkHeartbeat()
+    }, HEARTBEAT_INTERVAL_MS)
+  }
+
+  public async close() {
+    if (this.heartbeatTimer !== undefined) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = undefined
+    }
+    for (const connection of this.connections) connection.terminate()
+
+    await Promise.all([
+      new Promise<void>((resolve, reject) => {
+        this.server.close((error) => (error === undefined ? resolve() : reject(error)))
+      }),
+      new Promise<void>((resolve, reject) => {
+        this.httpServer.close((error) => (error === undefined ? resolve() : reject(error)))
+      })
+    ])
+  }
+
+  private connect(webSocket: WebSocket, requestUrl: string | undefined) {
+    const connection = new MachineWebSocketConnection(webSocket, () => this.connections.delete(connection))
+    this.connections.add(connection)
+
+    let url: URL
+    try {
+      url = new URL(requestUrl ?? '/', 'http://localhost')
+    } catch {
+      connection.end(1008)
+      return
+    }
+
+    const route = this.routes[url.pathname.toLowerCase()]
+    if (route === undefined) {
+      connection.end(1008)
+      return
+    }
+
+    try {
+      const result = route(connection, url.search.slice(1))
+      if (result !== undefined) void result.catch((error) => connection.end(1011, String(error)))
+    } catch (error) {
+      connection.end(1011, String(error))
+    }
+  }
+}
+
+class MachineWebSocketConnection implements MachineWebSocket {
+  public closed = false
+  public onmessage: ((message: Buffer) => void) | undefined
+  private receivedHeartbeat = true
+
+  constructor(
+    private readonly socket: WebSocket,
+    private readonly remove: () => void
+  ) {
+    socket.on('message', (message) => {
+      this.receivedHeartbeat = true
+      this.onmessage?.(Buffer.isBuffer(message) ? message : Buffer.from(message as ArrayBuffer))
+    })
+    socket.on('pong', () => (this.receivedHeartbeat = true))
+    // `ws` closes the connection after protocol and transport errors; cleanup happens in `close`.
+    socket.on('error', () => {})
+    socket.on('close', () => {
+      this.closed = true
+      this.remove()
+    })
+  }
+
+  public send(message: string | ArrayBuffer | Buffer) {
+    if (this.socket.readyState !== WebSocket.OPEN) return false
+
+    try {
+      // uWebSockets.js sent replay payload buffers as text frames by default.
+      this.socket.send(message, { binary: false, compress: false })
+    } catch {
+      this.terminate()
+      return false
+    }
+
+    if (this.socket.bufferedAmount > MAX_BACKPRESSURE_BYTES) {
+      this.end(1008, 'Too much backpressure')
+      return false
+    }
+
+    return this.socket.bufferedAmount === 0
+  }
+
+  public getBufferedAmount() {
+    return this.socket.bufferedAmount
+  }
+
+  public end(code = 1000, reason = '') {
+    if (this.socket.readyState !== WebSocket.OPEN) return
+
+    try {
+      this.socket.close(code, truncateCloseReason(reason))
+    } catch {
+      this.terminate()
+    }
+  }
+
+  public checkHeartbeat() {
+    if (!this.receivedHeartbeat) {
+      this.terminate()
+      return
+    }
+
+    this.receivedHeartbeat = false
+    if (this.socket.readyState === WebSocket.OPEN) this.socket.ping()
+  }
+
+  public terminate() {
+    if (this.socket.readyState !== WebSocket.CLOSED) this.socket.terminate()
+  }
+}
+
+function truncateCloseReason(reason: string) {
+  const encodedReason = Buffer.from(reason)
+  if (encodedReason.length <= MAX_CLOSE_REASON_BYTES) return reason
+
+  // Leave room for the UTF-8 replacement character if truncation splits a code point.
+  return encodedReason.subarray(0, MAX_CLOSE_REASON_BYTES - 3).toString()
+}

package/src/ws/streamnormalized.ts

@@ -1,15 +1,15 @@
 import { decode } from 'node:querystring'
 import { combine, compute, Exchange, streamNormalized } from 'tardis-dev'
-import type { HttpRequest } from 'uWebSockets.js'
 import { debug } from '../debug.ts'
 import { constructDataTypeFilter, getComputables, getNormalizers, StreamNormalizedRequestOptions, wait } from '../helpers.ts'
+import type { MachineWebSocket } from './server.ts'
 
-export async function streamNormalizedWS(ws: any, req: HttpRequest) {
+export async function streamNormalizedWS(ws: MachineWebSocket, query: string) {
   let messages: AsyncIterableIterator<any> | undefined
 
   try {
     const startTimestamp = new Date().getTime()
-    const parsedQuery = decode(req.getQuery())
+    const parsedQuery = decode(query)
     const optionsString = parsedQuery['options'] as string
     const streamNormalizedOptions = JSON.parse(optionsString) as StreamNormalizedRequestOptions
 
@@ -84,7 +84,7 @@ export async function streamNormalizedWS(ws: any, req: HttpRequest) {
       retries = 0
       bufferedAmount = 0
       // handle backpressure in case of slow clients
-      while ((bufferedAmount = ws.getBufferedAmount()) > 0) {
+      while (!ws.closed && (bufferedAmount = ws.getBufferedAmount()) > 0) {
         retries += 1
         const isState = new Date().valueOf() - message.localTimestamp.valueOf() >= 6
 
@@ -101,6 +101,8 @@ export async function streamNormalizedWS(ws: any, req: HttpRequest) {
         await wait(3 * retries)
       }
 
+      if (ws.closed) return
+
       ws.send(JSON.stringify(message))
 
       if (message.type !== 'disconnect') {
@@ -108,7 +110,7 @@ export async function streamNormalizedWS(ws: any, req: HttpRequest) {
       }
     }
 
-    while (ws.getBufferedAmount() > 0) {
+    while (!ws.closed && ws.getBufferedAmount() > 0) {
       await wait(100)
     }
 
@@ -131,7 +133,7 @@ export async function streamNormalizedWS(ws: any, req: HttpRequest) {
   } finally {
     // this will close underlying open WS connections
     if (messages !== undefined) {
-      messages!.return!()
+      await messages.return?.()
     }
   }
 }

package/src/ws/subscriptionsmappers.ts

@@ -1,4 +1,4 @@
-import { Exchange, Filter } from 'tardis-dev'
+import type { Exchange, Filter } from 'tardis-dev'
 
 // https://www.bitmex.com/app/wsAPI
 const bitmexMapper: SubscriptionMapper = {

package/node_modules/follow-redirects/LICENSE

@@ -1,18 +0,0 @@
-Copyright 2014–present Olivier Lalonde <olalonde@gmail.com>, James Talmage <james@talmage.io>, Ruben Verborgh
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.