websocket-text-relay 1.1.7 → 1.1.9

package/biome.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.4.8/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "includes": ["src/**/*"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "lineWidth": 110
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "semicolons": "asNeeded"
+    }
+  },
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  }
+}

package/changelog.md

@@ -1,3 +1,17 @@
+## 1.1.9 - 2026/03/22
+
+### Dependencies Update
+
+- Separate out dev dependencies.
+
+## 1.1.8 - 2026/03/22
+
+### Dependencies Update
+
+- Switch to Biome for formatting and linting.
+- Switch to native nodejs test runner
+- Remove all old dependencies
+
 ## 1.1.7 - 2025/12/19
 
 ### UI Update

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "websocket-text-relay",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "An LSP server for sending live file updates from your text editor to the front end via websockets.",
   "bin": {
     "websocket-text-relay": "./start.js"
   },
   "scripts": {
-    "format": "prettier src --write",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
-    "test": "npm run lint && vitest run --coverage",
-    "test:ui": "vitest --ui"
+    "format": "biome check --write",
+    "lint": "biome check",
+    "test:run": "node --test",
+    "test:coverage": "node --test --experimental-test-coverage",
+    "test:watch": "node --test --watch",
+    "test": "npm run lint && npm run test:run"
   },
   "type": "module",
   "main": "./src/index.js",
@@ -35,16 +36,12 @@
     "url": "https://github.com/niels4/websocket-text-relay/issues"
   },
   "homepage": "https://github.com/niels4/websocket-text-relay#readme",
-  "devDependencies": {
-    "@eslint/js": "9.39.2",
-    "@vitest/coverage-v8": "4.0.16",
-    "@vitest/ui": "4.0.16",
-    "eslint": "9.39.2",
-    "globals": "16.5.0",
-    "prettier": "3.7.4",
-    "vitest": "4.0.16"
-  },
   "dependencies": {
     "ws": "8.18.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.8",
+    "@types/node": "25.5.0",
+    "typescript": "5.9.3"
   }
 }

package/src/index.js

@@ -7,8 +7,8 @@ const resolvePort = (portParam) => {
   if (portParam != null) {
     return portParam
   }
-  if (process.env["websocket_text_relay_port"] != null) {
-    return process.env["websocket_text_relay_port"]
+  if (process.env.websocket_text_relay_port != null) {
+    return process.env.websocket_text_relay_port
   }
   return DEFAULT_WS_PORT
 }

package/src/language-server/JsonRpcInterface.js

@@ -1,6 +1,4 @@
 import { EventEmitter } from "node:events"
-import { LspReader } from "./LspReader.js"
-import { writeNotification, writeRequest, writeResponse } from "./LspWriter.js"
 import {
   invalidRequestErrorCode,
   invalidRequestErrorMessage,
@@ -11,6 +9,8 @@ import {
   unexpectedRequestErrorCode,
   unexpectedRequestErrorMessage,
 } from "./constants.js"
+import { LspReader } from "./LspReader.js"
+import { writeNotification, writeRequest, writeResponse } from "./LspWriter.js"
 
 export class JsonRpcInterface {
   constructor({ inputStream, outputStream }) {
@@ -34,7 +34,7 @@ export class JsonRpcInterface {
   onNotification(method, handler) {
     if (this.notificationHandlers.has(method)) {
       throw new Error(
-        "Can only register one notification handler at a time. Duplicate method handlers for " + method,
+        `Can only register one notification handler at a time. Duplicate method handlers for ${method}`,
       )
     }
     this.notificationHandlers.set(method, handler)
@@ -47,7 +47,7 @@ export class JsonRpcInterface {
   onRequest(method, handler) {
     if (this.requestHandlers.has(method)) {
       throw new Error(
-        "Can only register one request handler at a time. Duplicate method handlers for " + method,
+        `Can only register one request handler at a time. Duplicate method handlers for ${method}`,
       )
     }
     this.requestHandlers.set(method, handler)

package/src/language-server/JsonRpcInterface.test.js

@@ -1,7 +1,6 @@
-import { describe, it, expect, beforeAll } from "vitest"
+import assert from "node:assert/strict"
 import { PassThrough, Writable } from "node:stream"
-import { JsonRpcInterface } from "./JsonRpcInterface.js"
-import { TESTONLY_resetRequestId } from "./LspWriter.js"
+import { before as beforeAll, describe, it } from "node:test"
 import {
   invalidRequestErrorCode,
   invalidRequestErrorMessage,
@@ -12,6 +11,8 @@ import {
   unexpectedRequestErrorCode,
   unexpectedRequestErrorMessage,
 } from "./constants.js"
+import { JsonRpcInterface } from "./JsonRpcInterface.js"
+import { TESTONLY_resetRequestId } from "./LspWriter.js"
 
 describe("JsonRpcInterface", () => {
   describe("onNotification", () => {
@@ -34,14 +35,14 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call the handler with the correct params", () => {
-        expect(actualParams).to.deep.equal(expectedParams)
+        assert.deepStrictEqual(actualParams, expectedParams)
       })
     })
 
     describe("when attempting to register duplicate onNotification handlers ", () => {
       let inputStream, outputStream, jsonRpc
-      let f1 = () => {}
-      let f2 = () => {}
+      const f1 = () => {}
+      const f2 = () => {}
 
       beforeAll(() => {
         inputStream = new PassThrough()
@@ -52,9 +53,7 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should throw an error if we try to register the same method twice (without first removing the handler)", () => {
-        expect(() => jsonRpc.onNotification("test/test-method", f2)).to.toThrowError(
-          /duplicate method handlers/i,
-        )
+        assert.throws(() => jsonRpc.onNotification("test/test-method", f2), /duplicate method handlers/i)
       })
     })
 
@@ -63,8 +62,8 @@ describe("JsonRpcInterface", () => {
       const incomingMessage = `Content-Length: 64\r\n\r\n{"jsonrpc":"2.0","method":"test/test-method","params":{"a":"1"}}`
       let f1Fired = false
       let f2Fired = false
-      let f1 = () => (f1Fired = true)
-      let f2 = () => (f2Fired = true)
+      const f1 = () => (f1Fired = true)
+      const f2 = () => (f2Fired = true)
 
       beforeAll(() => {
         inputStream = new PassThrough()
@@ -79,8 +78,8 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call function f2 instead of f1", () => {
-        expect(f1Fired).to.equal(false)
-        expect(f2Fired).to.equal(true)
+        assert.strictEqual(f1Fired, false)
+        assert.strictEqual(f2Fired, true)
       })
     })
 
@@ -111,7 +110,7 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should fire the notification-error event with the correct error data", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
     })
 
@@ -138,7 +137,7 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should fire the notification-error event with the correct error data", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
     })
   })
@@ -170,11 +169,11 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call the handler with the correct params", () => {
-        expect(actualParams).to.deep.equal(expectedParams)
+        assert.deepStrictEqual(actualParams, expectedParams)
       })
 
       it("should write the response to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
     })
 
@@ -207,23 +206,23 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call the handler with the correct params", () => {
-        expect(actualParams).to.deep.equal(expectedParams)
+        assert.deepStrictEqual(actualParams, expectedParams)
       })
 
       it("should not write the response until the promise resolves", () => {
-        expect(actualOutput).toEqual("")
+        assert.deepStrictEqual(actualOutput, "")
       })
 
       it("should write the response after the async function resolves with the result", async () => {
         await new Promise((resolve) => setTimeout(resolve, 1))
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
     })
 
     describe("when attempting to register duplicate onRequest handlers ", () => {
       let inputStream, outputStream, jsonRpc
-      let f1 = () => {}
-      let f2 = () => {}
+      const f1 = () => {}
+      const f2 = () => {}
 
       beforeAll(() => {
         inputStream = new PassThrough()
@@ -234,7 +233,7 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should throw an error if we try to register the same method twice (without first removing the handler)", () => {
-        expect(() => jsonRpc.onRequest("test/test-method", f2)).to.toThrowError(/duplicate method handlers/i)
+        assert.throws(() => jsonRpc.onRequest("test/test-method", f2), /duplicate method handlers/i)
       })
     })
 
@@ -242,8 +241,8 @@ describe("JsonRpcInterface", () => {
       const incomingMessage = `Content-Length: 73\r\n\r\n{"jsonrpc":"2.0","id":"0","method":"test/test-method","params":{"a":"1"}}`
       let f1Fired = false
       let f2Fired = false
-      let f1 = () => (f1Fired = true)
-      let f2 = () => (f2Fired = true)
+      const f1 = () => (f1Fired = true)
+      const f2 = () => (f2Fired = true)
 
       beforeAll(() => {
         const inputStream = new PassThrough()
@@ -258,8 +257,8 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should call function f2 instead of f1", () => {
-        expect(f1Fired).to.equal(false)
-        expect(f2Fired).to.equal(true)
+        assert.strictEqual(f1Fired, false)
+        assert.strictEqual(f2Fired, true)
       })
     })
 
@@ -299,11 +298,11 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should fire the notification-error event with the correct error data", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
 
       it("should write the error to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
     })
 
@@ -339,11 +338,11 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should fire the notification-error event with the correct error data", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
 
       it("should write the error to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
     })
   })
@@ -367,7 +366,7 @@ describe("JsonRpcInterface", () => {
     })
 
     it("should write a notification message without an ID property on the output stream", () => {
-      expect(actualOutput).toEqual(expectedOutput)
+      assert.deepStrictEqual(actualOutput, expectedOutput)
     })
   })
 
@@ -399,18 +398,18 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should write the request message to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
 
       it("should return an unresolved promise", () => {
-        expect(requestPromise).toBeInstanceOf(Promise)
-        expect(actualResult).toBeNull()
+        assert.strictEqual(requestPromise instanceof Promise, true)
+        assert.strictEqual(actualResult, null)
       })
 
       it("should resolve the promise when the client responds with a result", async () => {
         inputStream.write(clientResponse)
         const result = await requestPromise
-        expect(result).to.deep.equal(expectedResult)
+        assert.deepStrictEqual(result, expectedResult)
       })
     })
 
@@ -441,18 +440,18 @@ describe("JsonRpcInterface", () => {
       })
 
       it("should write the request message to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepStrictEqual(actualOutput, expectedOutput)
       })
 
       it("should return an unresolved promise", () => {
-        expect(requestPromise).toBeInstanceOf(Promise)
-        expect(actualResult).toBeNull()
+        assert.strictEqual(requestPromise instanceof Promise, true)
+        assert.strictEqual(actualResult, null)
       })
 
       it("should reject the promise when the client responds with an error", async () => {
         inputStream.write(clientResponse)
         await requestPromise.catch((error) => {
-          expect(error).to.deep.equal(expectedError)
+          assert.deepStrictEqual(error, expectedError)
         })
       })
     })
@@ -476,7 +475,7 @@ describe("JsonRpcInterface", () => {
     })
 
     it("should write the error to the output stream", () => {
-      expect(actualOutput).toEqual(expectedOutput)
+      assert.deepStrictEqual(actualOutput, expectedOutput)
     })
   })
 
@@ -516,11 +515,11 @@ describe("JsonRpcInterface", () => {
     })
 
     it("should emit an rpc-error event on the events emitter", () => {
-      expect(actualError).to.deep.equal(expectedError)
+      assert.deepStrictEqual(actualError, expectedError)
     })
 
     it("should notify the client that it sent an invalid rpc message", () => {
-      expect(actualOutput).toEqual(expectedOutput)
+      assert.deepStrictEqual(actualOutput, expectedOutput)
     })
   })
 })

package/src/language-server/LspReader.js

@@ -23,7 +23,7 @@ const getJsonLength = (data, bufferStartIndex, jsonStartIndex) => {
   if (!match) {
     return null
   }
-  return Number.parseInt(match[1])
+  return Number.parseInt(match[1], 10)
 }
 
 export class LspReader extends Transform {

package/src/language-server/LspReader.test.js

@@ -1,7 +1,8 @@
+import assert from "node:assert/strict"
 import { PassThrough } from "node:stream"
-import { describe, it, expect, beforeAll } from "vitest"
-import { LspReader } from "./LspReader.js"
+import { before as beforeAll, describe, it } from "node:test"
 import { parseErrorCode, parseHeaderErrorMessage, parseJsonErrorMessage } from "./constants.js"
+import { LspReader } from "./LspReader.js"
 
 describe("LspReader", () => {
   describe("simple case", () => {
@@ -26,7 +27,7 @@ describe("LspReader", () => {
       })
 
       it("should parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -51,7 +52,7 @@ describe("LspReader", () => {
       })
 
       it("should parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
   })
@@ -77,11 +78,11 @@ describe("LspReader", () => {
       })
 
       it("should emit an 'parse-error' event with the parse header error message", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
 
       it("should not emit any objects", () => {
-        expect(actualMessageObj).toBeNull()
+        assert.strictEqual(actualMessageObj, null)
       })
     })
 
@@ -97,8 +98,8 @@ describe("LspReader", () => {
         method: "test/test-method",
         params: { b: "2" },
       }
-      let actualMessageObjs = []
-      let actualErrors = []
+      const actualMessageObjs = []
+      const actualErrors = []
 
       beforeAll(() => {
         const inputStream = new PassThrough()
@@ -116,13 +117,13 @@ describe("LspReader", () => {
       })
 
       it("should emit only 1 'parse-error' event with the parse header error message", () => {
-        expect(actualErrors.length).toEqual(1)
-        expect(actualErrors[0]).to.deep.equal(expectedError)
+        assert.strictEqual(actualErrors.length, 1)
+        assert.deepStrictEqual(actualErrors[0], expectedError)
       })
 
       it("should not emit one object from the message with the valid header", () => {
-        expect(actualMessageObjs.length).toEqual(1)
-        expect(actualMessageObjs[0]).to.deep.equal(expectedObject)
+        assert.strictEqual(actualMessageObjs.length, 1)
+        assert.deepStrictEqual(actualMessageObjs[0], expectedObject)
       })
     })
 
@@ -138,8 +139,8 @@ describe("LspReader", () => {
         method: "test/test-method",
         params: { b: "2" },
       }
-      let actualMessageObjs = []
-      let actualErrors = []
+      const actualMessageObjs = []
+      const actualErrors = []
 
       beforeAll(() => {
         const inputStream = new PassThrough()
@@ -157,13 +158,13 @@ describe("LspReader", () => {
       })
 
       it("should emit only 1 'parse-error' event with the parse header error message", () => {
-        expect(actualErrors.length).toEqual(1)
-        expect(actualErrors[0]).to.deep.equal(expectedError)
+        assert.strictEqual(actualErrors.length, 1)
+        assert.deepStrictEqual(actualErrors[0], expectedError)
       })
 
       it("should not emit one object from the message with the valid header", () => {
-        expect(actualMessageObjs.length).toEqual(1)
-        expect(actualMessageObjs[0]).to.deep.equal(expectedObject)
+        assert.strictEqual(actualMessageObjs.length, 1)
+        assert.deepStrictEqual(actualMessageObjs[0], expectedObject)
       })
     })
 
@@ -187,11 +188,11 @@ describe("LspReader", () => {
       })
 
       it("should emit an 'parse-error' event with the parse JSON error message", () => {
-        expect(actualError).to.deep.equal(expectedError)
+        assert.deepStrictEqual(actualError, expectedError)
       })
 
       it("should not emit any objects", () => {
-        expect(actualMessageObj).toBeNull()
+        assert.strictEqual(actualMessageObj, null)
       })
     })
   })
@@ -228,11 +229,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -274,11 +275,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -313,11 +314,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -362,11 +363,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
   })
@@ -396,19 +397,19 @@ describe("LspReader", () => {
       })
 
       it("should construct the lspReader with the passed in initialBufferSize", () => {
-        expect(actualInitialBufferSize).toEqual(10)
+        assert.strictEqual(actualInitialBufferSize, 10)
       })
 
       it("should need to trigger a resize", () => {
-        expect(inputData.length).toBeGreaterThan(actualInitialBufferSize)
+        assert.strictEqual(inputData.length > actualInitialBufferSize, true)
       })
 
       it("should increase the buffer to a size larger than the message chunk", () => {
-        expect(lspReader.buffer.length).toBeGreaterThan(inputData.length)
+        assert.strictEqual(lspReader.buffer.length > inputData.length, true)
       })
 
       it("should parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
 
@@ -446,24 +447,24 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should construct the lspReader with the passed in initialBufferSize", () => {
-        expect(actualInitialBufferSize).toEqual(70)
+        assert.strictEqual(actualInitialBufferSize, 70)
       })
 
       it("should need to trigger a resize after the first buffered message", () => {
-        expect(inputData[0].length).toBeLessThan(actualInitialBufferSize)
-        expect(inputData[1].length).toBeGreaterThan(actualInitialBufferSize)
+        assert.strictEqual(inputData[0].length < actualInitialBufferSize, true)
+        assert.strictEqual(inputData[1].length > actualInitialBufferSize, true)
       })
 
       it("should increase the buffer to a size larger than the combined message chunks", () => {
-        expect(lspReader.buffer.length).toBeGreaterThan(inputData[0].length + inputData[1].length)
+        assert.strictEqual(lspReader.buffer.length > inputData[0].length + inputData[1].length, true)
       })
 
       it("should buffer the data until it can parse the incoming data and emit the json rpc message object", () => {
-        expect(actualMessageObj).to.deep.equal(expectedMessageObj)
+        assert.deepStrictEqual(actualMessageObj, expectedMessageObj)
       })
     })
   })
@@ -480,7 +481,7 @@ describe("LspReader", () => {
       { jsonrpc: "2.0", id: "1", method: "test/test-method", params: { b: "2" } },
       { jsonrpc: "2.0", id: "2", method: "test/test-method", params: { c: "3" } },
     ]
-    let actualMessageObjs = []
+    const actualMessageObjs = []
     let actualError = null
 
     beforeAll(() => {
@@ -500,11 +501,11 @@ describe("LspReader", () => {
     })
 
     it("should not emit an error", () => {
-      expect(actualError).toBeNull()
+      assert.strictEqual(actualError, null)
     })
 
     it("should emit each message in the order it was received", () => {
-      expect(actualMessageObjs).to.deep.equal(expectedMessageObjs)
+      assert.deepStrictEqual(actualMessageObjs, expectedMessageObjs)
     })
   })
 
@@ -521,7 +522,7 @@ describe("LspReader", () => {
       { jsonrpc: "2.0", id: "1", method: "test/test-method", params: { b: "2" } },
       { jsonrpc: "2.0", id: "2", method: "test/test-method", params: { c: "3" } },
     ]
-    let actualMessageObjs = []
+    const actualMessageObjs = []
     let actualError = null
 
     beforeAll(() => {
@@ -539,11 +540,11 @@ describe("LspReader", () => {
     })
 
     it("should not emit an error", () => {
-      expect(actualError).toBeNull()
+      assert.strictEqual(actualError, null)
     })
 
     it("should emit each message in the order it was received", () => {
-      expect(actualMessageObjs).to.deep.equal(expectedMessageObjs)
+      assert.deepStrictEqual(actualMessageObjs, expectedMessageObjs)
     })
   })
 
@@ -559,7 +560,7 @@ describe("LspReader", () => {
         { jsonrpc: "2.0", id: "1", method: "test/test-method", params: { b: "2" } },
         { jsonrpc: "2.0", id: "2", method: "test/test-method", params: { c: "3" } },
       ]
-      let actualMessageObjs = []
+      const actualMessageObjs = []
       let actualError = null
 
       beforeAll(() => {
@@ -579,11 +580,11 @@ describe("LspReader", () => {
       })
 
       it("should not emit an error", () => {
-        expect(actualError).toBeNull()
+        assert.strictEqual(actualError, null)
       })
 
       it("should emit each message in the order it was received", () => {
-        expect(actualMessageObjs).to.deep.equal(expectedMessageObjs)
+        assert.deepStrictEqual(actualMessageObjs, expectedMessageObjs)
       })
     })
   })

package/src/language-server/LspWriter.test.js

@@ -1,8 +1,9 @@
+import assert from "node:assert/strict"
 import { Writable } from "node:stream"
-import { describe, it, expect, beforeAll } from "vitest"
+import { before as beforeAll, describe, it } from "node:test"
 import {
-  TESTONLY_resetRequestId,
   createHeader,
+  TESTONLY_resetRequestId,
   writeNotification,
   writeRequest,
   writeResponse,
@@ -17,7 +18,7 @@ describe("LspWriter", () => {
 
       it("Should create header with correct length", () => {
         const actual = createHeader(JSON.stringify(messageObj))
-        expect(actual).toEqual(expectedHeader)
+        assert.deepStrictEqual(actual, expectedHeader)
       })
     })
 
@@ -27,7 +28,7 @@ describe("LspWriter", () => {
 
       it("Should create header with correct length", () => {
         const actual = createHeader(JSON.stringify(messageObj))
-        expect(actual).toEqual(expectedHeader)
+        assert.deepStrictEqual(actual, expectedHeader)
       })
     })
 
@@ -37,7 +38,7 @@ describe("LspWriter", () => {
 
       it("Should create header with correct byte length, not string length", () => {
         const actual = createHeader(JSON.stringify(messageObj))
-        expect(actual).toEqual(expectedHeader)
+        assert.deepStrictEqual(actual, expectedHeader)
       })
     })
   })
@@ -59,7 +60,7 @@ describe("LspWriter", () => {
       })
 
       it("should stringify the json and add a Content-Length header, then write the head and json to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
   })
@@ -82,7 +83,7 @@ describe("LspWriter", () => {
       })
 
       it("should create a response object with a result property (and no error) and write it to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
 
@@ -103,7 +104,7 @@ describe("LspWriter", () => {
       })
 
       it("should create a response object with an error property (and no result) and write it to the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
   })
@@ -126,7 +127,7 @@ describe("LspWriter", () => {
       })
 
       it("should write a notification message without an ID property on the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
   })
@@ -150,7 +151,7 @@ describe("LspWriter", () => {
       })
 
       it("should write a request message with an ID property on the output stream", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
 
@@ -179,7 +180,7 @@ describe("LspWriter", () => {
       })
 
       it("should write multiple request messages with increasing IDs", () => {
-        expect(actualOutput).toEqual(expectedOutput)
+        assert.deepEqual(actualOutput, expectedOutput)
       })
     })
   })

package/src/ui/index.html

@@ -1,41 +1,44 @@
 <!doctype html>
 <html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 
-    <title>WTR Status</title>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 
-    <link rel="icon" type="image/png" href="favicon.png" />
-    <link rel="stylesheet" href="css/fonts.css" />
-    <style id="main_style"></style>
-    <script type="module" src="js/setup.js" defer></script>
+  <title>WTR Status</title>
 
-    <style>
-      html {
-        height: 100dvh;
-        overscroll-behavior: none;
-      }
+  <link rel="icon" type="image/png" href="favicon.png" />
+  <link rel="stylesheet" href="css/fonts.css" />
+  <style id="main_style"></style>
+  <script type="module" src="js/setup.js" defer></script>
 
-      #svg_root {
-        position: absolute;
-        top: 0;
-        left: 0;
-        height: 100dvh;
-        width: 100dvw;
-      }
-    </style>
-  </head>
+  <style>
+    html {
+      height: 100dvh;
+      overscroll-behavior: none;
+    }
+
+    #svg_root {
+      position: absolute;
+      top: 0;
+      left: 0;
+      height: 100dvh;
+      width: 100dvw;
+    }
+  </style>
+</head>
+
+<body class="base_colors color_theme">
+  <svg id="svg_root" viewBox="-1 -1 2 2" xmlns="http://www.w3.org/2000/svg">
+    <title>Main Svg Canvas</title>
+    <g id="headers_group"></g>
+    <g id="editor_wedges_group" class="wedge_group"></g>
+    <g id="client_wedges_group" class="wedge_group"></g>
+    <g id="activity_time_series_group"></g>
+    <g id="activity_labels_group"></g>
+    <g id="status_ring_group"></g>
+    <g id="footer_status_group"></g>
+  </svg>
+</body>
 
-  <body class="base_colors color_theme">
-    <svg id="svg_root" viewBox="-1 -1 2 2" xmlns="http://www.w3.org/2000/svg">
-      <g id="headers_group"></g>
-      <g id="editor_wedges_group" class="wedge_group"></g>
-      <g id="client_wedges_group" class="wedge_group"></g>
-      <g id="activity_time_series_group"></g>
-      <g id="activity_labels_group"></g>
-      <g id="status_ring_group"></g>
-      <g id="footer_status_group"></g>
-    </svg>
-  </body>
 </html>

package/src/ui/js/data/wtrActivity.js

@@ -66,7 +66,7 @@ function processDataWindow(dataWindow) {
     }
     return `${i},${value}`
   })
-  const path = "M " + coords.join(" L ")
+  const path = `M ${coords.join(" L ")}`
   return { path, maxValue }
 }
 

package/src/ui/js/data/wtrStatus.js

@@ -14,7 +14,7 @@ const currentStatus = {
 }
 
 const wtrStatusEmitter = new EventEmitter()
-wtrStatusEmitter.on = function (event, handler) {
+wtrStatusEmitter.on = (event, handler) => {
   EventEmitter.prototype.on.call(wtrStatusEmitter, event, handler)
   // automatically push the data to the event handler when it initially subscribes
   if (event === "data") {

package/src/ui/js/setup/eventSubscriber.js

@@ -2,6 +2,7 @@ const allCleanupFunctions = new Map()
 
 export const eventSubscriber = (key) => {
   const previousCleanupFunctions = allCleanupFunctions.get(key)
+  // biome-ignore lint/suspicious/useIterableCallbackReturn: Keep the function a 1 liner
   previousCleanupFunctions?.forEach((f) => f())
 
   const cleanupFunctions = []

package/src/ui/js/setup.js

@@ -1,8 +1,8 @@
-import { WebsocketClient } from "./setup/WebsocketClient.js"
-import { getEvalOnChangeFiles, clearEvalOnChangeFiles } from "./setup/evalOnChange.js" // initialize dependencies on the global __WTR__ object
+import { emitActivity } from "./data/wtrActivity.js"
 import { setIsOnline, setSessions } from "./data/wtrStatus.js"
+import { clearEvalOnChangeFiles, getEvalOnChangeFiles } from "./setup/evalOnChange.js" // initialize dependencies on the global __WTR__ object
 import { eventSubscriber } from "./setup/eventSubscriber.js" // make sure the eventSubscriber function is available on the __WTR__ object
-import { emitActivity } from "./data/wtrActivity.js"
+import { WebsocketClient } from "./setup/WebsocketClient.js"
 
 const searchParams = new URLSearchParams(window.location.search)
 
@@ -39,6 +39,7 @@ const handleJs = (contents, jsEndsWith) => {
   // register and clean up event handlers on a per file basis
   window.__WTR__.onEvent = eventSubscriber(jsEndsWith)
   try {
+    // biome-ignore lint/security/noGlobalEval: Live updates requires eval
     eval(contents)
   } catch (e) {
     window._lastEvalError = e

package/src/websocket-interface/WebsocketInterface.js

@@ -1,8 +1,8 @@
+import { EventEmitter } from "node:events"
 import { WebsocketClient } from "./WebsocketClient.js"
 import { WtrSession } from "./WtrSession.js"
 import { apiMethods } from "./websocketApi.js"
 import { createWebsocketServer } from "./websocketServer.js"
-import { EventEmitter } from "node:events"
 
 const watchActiveFilesMessage = { method: "watch-editor-active-files" }
 
@@ -81,7 +81,7 @@ export class WebsocketInterface {
   _sendMessageToServer(message) {
     if (this.serverSession) {
       this.serverSession._handleApiMessage(message)
-    } else if (this.wsClient && this.wsClient.socketOpen) {
+    } else if (this.wsClient?.socketOpen) {
       this.wsClient.sendMessage(message)
     }
   }

package/src/websocket-interface/WtrSession.js

@@ -1,11 +1,11 @@
 import { EventEmitter } from "node:events"
-import { getNextId } from "./util.js"
 import {
-  startSessionStatus,
   endSessionStatus,
-  statusEvents,
   removeWatchedFileLinks,
+  startSessionStatus,
+  statusEvents,
 } from "./sessionManager.js"
+import { getNextId } from "./util.js"
 
 export class WtrSession {
   constructor({ apiMethods, wsConnection, wsInterfaceEmitter }) {
@@ -118,7 +118,7 @@ export class WtrSession {
   }
 
   _handleApiMessage(message) {
-    const method = message && message.method
+    const method = message?.method
     const methodHandler = this.apiMethods.get(method)
     if (!methodHandler) {
       this.emitter.emit("log", { level: "error", text: `unknown ws api method: ${method}` })

package/src/websocket-interface/httpServer.js

@@ -1,9 +1,10 @@
-import { createServer } from "node:http"
-import path from "node:path"
 import { createReadStream } from "node:fs"
 import fs from "node:fs/promises"
+import { createServer } from "node:http"
+import path from "node:path"
 import * as url from "node:url"
 import { isValidOrigin } from "./util.js"
+
 const parentDir = url.fileURLToPath(new URL("..", import.meta.url))
 
 const uiDirName = "ui"
@@ -19,7 +20,7 @@ const allowedFileTypes = new Map([
 ])
 
 const getFilePath = (url) => {
-  url = url === "/" ? "./index.html" : "." + url
+  url = url === "/" ? "./index.html" : `.${url}`
   return path.join(uiDirPath, url)
 }
 

package/src/websocket-interface/websocketApi.js

@@ -1,10 +1,10 @@
 import {
-  triggerStatusUpdate,
-  statusEvents,
+  addOpenedFileLinks,
   addWatchedFileLinks,
-  removeWatchedFileLinks,
   removeOpenedFileLinks,
-  addOpenedFileLinks,
+  removeWatchedFileLinks,
+  statusEvents,
+  triggerStatusUpdate,
 } from "./sessionManager.js"
 
 export const apiMethods = new Map([

package/src/websocket-interface/websocketServer.js

@@ -1,8 +1,8 @@
 import { WebSocketServer } from "ws"
 import { createHttpServer } from "./httpServer.js"
-import { apiMethods } from "./websocketApi.js"
-import { WtrSession } from "./WtrSession.js"
 import { isValidOrigin } from "./util.js"
+import { WtrSession } from "./WtrSession.js"
+import { apiMethods } from "./websocketApi.js"
 
 export const createWebsocketServer = async ({ port, allowedHosts, allowNetworkAccess }) => {
   const httpServer = await createHttpServer({ port, allowedHosts, allowNetworkAccess }) // promise will reject if can't start HTTP server on specified port

package/.prettierignore

@@ -1,3 +0,0 @@
-# Ignore artifacts:
-build
-coverage

package/.prettierrc

@@ -1,4 +0,0 @@
-{
-  "semi": false,
-  "printWidth": 110
-}

package/eslint.config.js

@@ -1,32 +0,0 @@
-import js from "@eslint/js"
-import globals from "globals"
-import { defineConfig } from "eslint/config"
-
-const wtrGlobals = {
-  __WTR__: "readonly",
-}
-
-export default defineConfig([
-  {
-    files: ["**/*.{js,mjs,cjs}"],
-    plugins: { js },
-    extends: ["js/recommended"],
-    languageOptions: { globals: { ...globals.node, ...globals.browser, ...wtrGlobals } },
-  },
-  {
-    rules: {
-      semi: ["error", "never"],
-      indent: ["error", 2],
-      "no-multiple-empty-lines": ["error", { max: 1 }],
-      "no-unused-vars": 1,
-      "no-return-assign": 0,
-      "multiline-ternary": 0,
-      "object-curly-spacing": 0,
-      "object-property-newline": 0,
-      "object-curly-newline": 0,
-      quotes: 0,
-      "quote-props": 0,
-      "import/no-absolute-path": 0,
-    },
-  },
-])