chore(release): engine.io@6.6.5

Diff: https://github.com/socketio/socket.io/compare/engine.io@6.6.4...engine.io@6.6.5

.github/workflows/ci.yml

@@ -20,9 +20,9 @@ jobs:
       fail-fast: false
       matrix:
         node-version:
-          - 18
           - 20
-          - 22.17.1 # experimental TS type striping in 22.18.0 breaks the build
+          - 22
+          - 24
 
     services:
       redis:

.github/workflows/publish.yml

@@ -19,10 +19,10 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
-      - name: Use Node.js 20
+      - name: Use Node.js 24
         uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 24
           registry-url: 'https://registry.npmjs.org'
 
       - name: Install dependencies

package-lock.json

@@ -77,7 +77,7 @@
         "tsd": "^0.31.1",
         "tsx": "~4.20.6",
         "typescript": "^5.5.3",
-        "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.48.0",
+        "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.56.0",
         "wdio-geckodriver-service": "^5.0.2"
       }
     },
@@ -2277,25 +2277,27 @@
       }
     },
     "node_modules/@fails-components/webtransport": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/@fails-components/webtransport/-/webtransport-1.1.4.tgz",
-      "integrity": "sha512-cFc9XhEREi+afRRl9S9c/xNQ3KVi9dZkaIRVq3xPGwjjezgX5QMQ1pJKG6iZffSwboOOjk1VrDwlvPjuVwtGwQ==",
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/@fails-components/webtransport/-/webtransport-1.5.1.tgz",
+      "integrity": "sha512-WB6ZnnunU+pzkl7MtguVCf5K6h7nE7ulHpQMQM+sjZoE77GEtjUfBKSwH0z30fN+H+7caMbXSmPyAOD/WA0QAQ==",
       "dev": true,
+      "license": "BSD-3-Clause",
       "dependencies": {
         "@types/debug": "^4.1.7",
         "bindings": "^1.5.0",
         "debug": "^4.3.4"
       },
       "engines": {
-        "node": ">=16.5"
+        "node": ">=20"
       }
     },
     "node_modules/@fails-components/webtransport-transport-http3-quiche": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/@fails-components/webtransport-transport-http3-quiche/-/webtransport-transport-http3-quiche-1.1.4.tgz",
-      "integrity": "sha512-/tkuAJMSU641c+LrOmHpw8ZtZOQjrHX9O/kg/8iIhnqycNPyFBlzW8EWrmUfSTOran6QmTtQHRks+A1BqMEZeQ==",
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/@fails-components/webtransport-transport-http3-quiche/-/webtransport-transport-http3-quiche-1.5.1.tgz",
+      "integrity": "sha512-70FoQURf5KxByC7reVjgGDbRUqbMaFhqkvUc1LisLXw+PD6fIcE7Ua3eAnfsXG3izpV+YNMvucDM2qnCMn8dFg==",
       "dev": true,
       "hasInstallScript": true,
+      "license": "BSD-3-Clause",
       "dependencies": {
         "@types/debug": "^4.1.7",
         "bindings": "^1.5.0",
@@ -2305,7 +2307,7 @@
         "prebuild-install": "^7.1.1"
       },
       "engines": {
-        "node": ">=16.5"
+        "node": ">=20"
       }
     },
     "node_modules/@ioredis/commands": {
@@ -15157,8 +15159,8 @@
       }
     },
     "node_modules/uWebSockets.js": {
-      "version": "20.48.0",
-      "resolved": "git+ssh://git@github.com/uNetworking/uWebSockets.js.git#51ae1d1fd92dff77cbbdc7c431021f85578da1a6",
+      "version": "20.56.0",
+      "resolved": "git+ssh://git@github.com/uNetworking/uWebSockets.js.git#d04e707a1292928d50163ff7545e45c3e84c5ec3",
       "dev": true,
       "license": "Apache-2.0"
     },
@@ -16183,7 +16185,7 @@
     },
     "packages/socket.io-redis-streams-emitter": {
       "name": "@socket.io/redis-streams-emitter",
-      "version": "0.0.1",
+      "version": "0.1.1",
       "license": "MIT",
       "dependencies": {
         "@msgpack/msgpack": "~2.8.0",

package.json

@@ -78,7 +78,7 @@
     "tsd": "^0.31.1",
     "tsx": "~4.20.6",
     "typescript": "^5.5.3",
-    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.48.0",
+    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.56.0",
     "wdio-geckodriver-service": "^5.0.2"
   }
 }

packages/engine.io-client/test/webtransport.mjs

@@ -53,6 +53,26 @@ async function setup(opts, cb) {
   cb({ engine, h3Server, certificate });
 }
 
+function createHttpServer(port) {
+  const httpServer = createServer();
+
+  let retryCount = 0;
+
+  return new Promise((resolve, reject) => {
+    httpServer.listen(port, () => resolve(httpServer));
+
+    httpServer.on("error", (e) => {
+      if (e.code === "EADDRINUSE" && ++retryCount <= 3) {
+        console.warn("port already in use, retrying...");
+        setTimeout(() => {
+          httpServer.listen(port, () => resolve(httpServer));
+        }, 100);
+      }
+      reject(e);
+    });
+  });
+}
+
 function success(engine, h3server, done) {
   engine.close();
   h3server.stopServer();
@@ -98,10 +118,9 @@ describe("WebTransport", () => {
       {
         transports: ["polling", "webtransport"],
       },
-      ({ engine, h3Server, certificate }) => {
-        const httpServer = createServer();
+      async ({ engine, h3Server, certificate }) => {
+        const httpServer = await createHttpServer(h3Server.port);
         engine.attach(httpServer);
-        httpServer.listen(h3Server.port);
 
         const socket = createSocket(h3Server.port, certificate, {
           transports: ["polling", "webtransport"],
@@ -120,10 +139,9 @@ describe("WebTransport", () => {
       {
         transports: ["polling", "websocket", "webtransport"],
       },
-      ({ engine, h3Server, certificate }) => {
-        const httpServer = createServer();
+      async ({ engine, h3Server, certificate }) => {
+        const httpServer = await createHttpServer(h3Server.port);
         engine.attach(httpServer);
-        httpServer.listen(h3Server.port);
 
         const socket = createSocket(h3Server.port, certificate, {
           transports: ["polling", "websocket", "webtransport"],

packages/engine.io-parser/package.json

@@ -13,7 +13,7 @@
   "scripts": {
     "compile": "rimraf ./build && tsc && tsc -p tsconfig.esm.json && ./postcompile.sh",
     "test": "npm run format:check && npm run compile && if test \"$BROWSERS\" = \"1\" ; then npm run test:browser; else npm run test:node; fi",
-    "test:node": "nyc mocha -r ts-node/register test/index.ts",
+    "test:node": "nyc mocha --import=tsx test/index.ts",
     "test:browser": "zuul test/index.ts --no-coverage",
     "format:check": "prettier --check 'lib/**/*.ts' 'test/**/*.ts'",
     "format:fix": "prettier --write 'lib/**/*.ts' 'test/**/*.ts'",

packages/engine.io/CHANGELOG.md

@@ -1,7 +1,8 @@
-# History
+# Changelog
 
 | Version                                                                                              | Release date   |
 |------------------------------------------------------------------------------------------------------|----------------|
+| [6.6.5](#665-2025-12-22)                                                                             | December 2025  |
 | [6.6.4](#664-2025-01-28)                                                                             | January 2025   |
 | [6.6.3](#663-2025-01-23)                                                                             | January 2025   |
 | [6.6.2](#662-2024-10-09)                                                                             | October 2024   |
@@ -47,7 +48,16 @@
 | [3.4.1](#341-2020-04-17)                                                                             | April 2020     |
 
 
-# Release notes
+## [6.6.5](https://github.com/socketio/socket.io/compare/engine.io@6.6.4...engine.io@6.6.5) (2025-12-22)
+
+The `url.parse()` function is now deprecated and has been replaced by `new URL()` (see [e08293b](https://github.com/socketio/socket.io/commit/e08293bc3735de5b824b347383e86e0b8ab9fbd5b).
+
+
+### Dependencies
+
+- [`ws@~8.18.3`](https://github.com/websockets/ws/releases/tag/8.18.3) ([diff](https://github.com/websockets/ws/compare/8.17.1...8.18.3))
+
+
 
 ## [6.6.4](https://github.com/socketio/socket.io/compare/engine.io@6.6.3...engine.io@6.6.4) (2025-01-28)
 

packages/engine.io/lib/server.ts

@@ -1,5 +1,3 @@
-import * as qs from "querystring";
-import { parse } from "url";
 import * as base64id from "base64id";
 import transports from "./transports";
 import { EventEmitter } from "events";
@@ -736,9 +734,8 @@ export class Server extends BaseServer {
   private prepare(req: EngineRequest) {
     // try to leverage pre-existing `req._query` (e.g: from connect)
     if (!req._query) {
-      req._query = (
-        ~req.url.indexOf("?") ? qs.parse(parse(req.url).query) : {}
-      ) as Record<string, string>;
+      const url = new URL(req.url, "https://socket.io");
+      req._query = Object.fromEntries(url.searchParams.entries());
     }
   }
 

packages/engine.io/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engine.io",
-  "version": "6.6.4",
+  "version": "6.6.5",
   "description": "The realtime engine behind Socket.IO. Provides the foundation of a bidirectional connection between client and server",
   "type": "commonjs",
   "main": "./build/engine.io.js",

packages/engine.io/test/common.js

@@ -1,5 +1,6 @@
-if (process.env.EIO_CLIENT === "3" && process.versions.node.startsWith("22")) {
-  // FIXME WebSocket error with engine.io-client@3
+if (process.env.EIO_CLIENT === "3") {
+  // we need the WebSocket object provided by the "ws" library to test the SSL certs and HTTP headers so we hide the now built-in WebSocket constructor
+  // ref: https://nodejs.org/api/globals.html#class-websocket
   global.WebSocket = null;
 }
 

packages/engine.io/test/webtransport.mjs

@@ -99,6 +99,26 @@ function setup(opts, cb) {
   });
 }
 
+function createHttpServer(port) {
+  const httpServer = createServer();
+
+  let retryCount = 0;
+
+  return new Promise((resolve, reject) => {
+    httpServer.listen(port, () => resolve(httpServer));
+
+    httpServer.on("error", (e) => {
+      if (e.code === "EADDRINUSE" && ++retryCount <= 3) {
+        console.warn("port already in use, retrying...");
+        setTimeout(() => {
+          httpServer.listen(port, () => resolve(httpServer));
+        }, 100);
+      }
+      reject(e);
+    });
+  });
+}
+
 describe("WebTransport", () => {
   it("should allow to connect with WebTransport directly", (done) => {
     setupServer({}, async ({ engine, h3Server, certificate }) => {
@@ -154,9 +174,8 @@ describe("WebTransport", () => {
         transports: ["polling", "websocket", "webtransport"],
       },
       async ({ engine, h3Server, certificate }) => {
-        const httpServer = createServer();
+        const httpServer = await createHttpServer(h3Server.port);
         engine.attach(httpServer);
-        httpServer.listen(h3Server.port);
 
         const partialDone = createPartialDone(() => {
           httpServer.close();

packages/socket.io-adapter/package.json

@@ -22,7 +22,7 @@
   },
   "scripts": {
     "compile": "rimraf ./dist && tsc",
-    "test": "npm run format:check && npm run compile && nyc mocha --require ts-node/register test/*.ts",
+    "test": "npm run format:check && npm run compile && nyc mocha --import=tsx test/*.ts",
     "format:check": "prettier --parser typescript --check 'lib/**/*.ts' 'test/**/*.ts'",
     "format:fix": "prettier --parser typescript --write 'lib/**/*.ts' 'test/**/*.ts'",
     "prepack": "npm run compile"

packages/socket.io-client/package.json

@@ -53,7 +53,7 @@
   "scripts": {
     "compile": "rimraf ./build && tsc && tsc -p tsconfig.esm.json && ./postcompile.sh",
     "test": "npm run format:check && npm run compile && if test \"$BROWSERS\" = \"1\" ; then npm run test:browser; else npm run test:node; fi",
-    "test:node": "mocha --require ts-node/register --require test/support/hooks.ts --exit test/index.ts",
+    "test:node": "mocha --import=tsx --require test/support/hooks.ts --exit test/index.ts",
     "test:browser": "ts-node test/browser-runner.ts",
     "test:types": "tsd",
     "build": "rollup -c support/rollup.config.umd.js && rollup -c support/rollup.config.esm.js && rollup -c support/rollup.config.umd.msgpack.js",

packages/socket.io-client/test/retry.ts

@@ -111,7 +111,7 @@ describe("retry", () => {
     });
   });
 
-  it.only("should not emit a packet twice in the 'connect' handler", () => {
+  it("should not emit a packet twice in the 'connect' handler", () => {
     return wrap((done) => {
       const socket = io(BASE_URL, {
         forceNew: true,

packages/socket.io-cluster-engine/package.json

@@ -26,7 +26,7 @@
   "scripts": {
     "compile": "rimraf ./dist && tsc",
     "test": "npm run format:check && npm run compile && npm run test:unit",
-    "test:unit": "mocha --require ts-node/register test/*.ts",
+    "test:unit": "mocha --import=tsx test/*.ts",
     "format:check": "prettier --check \"lib/**/*.ts\" \"test/**/*.ts\"",
     "format:fix": "prettier --write \"lib/**/*.ts\" \"test/**/*.ts\"",
     "prepack": "npm run compile"

packages/socket.io-postgres-emitter/package.json

@@ -15,7 +15,7 @@
   "types": "./dist/index.d.ts",
   "scripts": {
     "compile": "rimraf ./dist && tsc",
-    "test": "npm run format:check && npm run compile && nyc mocha --require ts-node/register --timeout 5000 test/index.ts",
+    "test": "npm run format:check && npm run compile && nyc mocha --import=tsx --timeout 5000 test/index.ts",
     "format:check": "prettier --parser typescript --check 'lib/**/*.ts' 'test/**/*.ts'",
     "format:fix": "prettier --parser typescript --write 'lib/**/*.ts' 'test/**/*.ts'",
     "prepack": "npm run compile"

packages/socket.io-redis-streams-emitter/package.json

@@ -19,11 +19,11 @@
     "format:fix": "prettier --parser typescript --write 'lib/**/*.ts' 'test/**/*.ts'",
     "prepack": "npm run compile",
     "test": "npm run format:check && npm run compile && npm run test:redis-standalone && npm run test:ioredis-standalone",
-    "test:redis-standalone": "nyc mocha --import=tsx test/**/*.ts",
-    "test:redis-cluster": "REDIS_CLUSTER=1 mocha --import=tsx test/**/*.ts",
-    "test:ioredis-standalone": "REDIS_LIB=ioredis mocha --import=tsx test/**/*.ts",
-    "test:ioredis-cluster": "REDIS_LIB=ioredis REDIS_CLUSTER=1 mocha --import=tsx test/**/*.ts",
-    "test:valkey-standalone": "VALKEY=1 mocha --import=tsx test/**/*.ts"
+    "test:redis-standalone": "tsx --test",
+    "test:redis-cluster": "REDIS_CLUSTER=1 npm run test:redis-standalone",
+    "test:ioredis-standalone": "REDIS_LIB=ioredis npm run test:redis-standalone",
+    "test:ioredis-cluster": "REDIS_LIB=ioredis REDIS_CLUSTER=1 npm run test:redis-standalone",
+    "test:valkey-standalone": "VALKEY=1 npm run test:redis-standalone"
   },
   "dependencies": {
     "@msgpack/msgpack": "~2.8.0",

packages/socket.io-redis-streams-emitter/test/index.ts

@@ -1,15 +1,16 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import * as assert from "node:assert";
 import { type Server, type Socket as ServerSocket } from "socket.io";
 import { type Socket as ClientSocket } from "socket.io-client";
-import expect = require("expect.js");
 import { times, sleep, setup, initRedisClient } from "./util";
 import { Emitter } from "../lib";
 
 const PROPAGATION_DELAY_IN_MS = 100;
 
 describe("@socket.io/redis-streams-emitter", () => {
-  let servers: Server[],
-    serverSockets: ServerSocket[],
-    clientSockets: ClientSocket[],
+  let servers: [Server, Server, Server],
+    serverSockets: [ServerSocket, ServerSocket, ServerSocket],
+    clientSockets: [ClientSocket, ClientSocket, ClientSocket],
     cleanup: () => void,
     emitter: Emitter;
 
@@ -30,80 +31,88 @@ describe("@socket.io/redis-streams-emitter", () => {
   afterEach(() => cleanup());
 
   describe("broadcast", function () {
-    it("broadcasts to all clients", (done) => {
-      const partialDone = times(3, done);
+    it("broadcasts to all clients", () => {
+      return new Promise<void>((resolve) => {
+        const partialResolve = times(3, resolve);
 
-      clientSockets.forEach((clientSocket) => {
-        clientSocket.on("test", (arg1, arg2, arg3) => {
-          expect(arg1).to.eql(1);
-          expect(arg2).to.eql("2");
-          expect(Buffer.isBuffer(arg3)).to.be(true);
-          partialDone();
+        clientSockets.forEach((clientSocket) => {
+          clientSocket.on("test", (arg1, arg2, arg3) => {
+            assert.equal(arg1, 1);
+            assert.equal(arg2, "2");
+            assert.ok(Buffer.isBuffer(arg3));
+            partialResolve();
+          });
         });
-      });
 
-      emitter.emit("test", 1, "2", Buffer.from([3, 4]));
+        emitter.emit("test", 1, "2", Buffer.from([3, 4]));
+      });
     });
 
-    it("broadcasts to all clients in a namespace", (done) => {
-      const partialDone = times(3, () => {
-        servers.forEach((server) => server.of("/custom").adapter.close());
-        done();
-      });
+    it("broadcasts to all clients in a namespace", () => {
+      return new Promise<void>((resolve) => {
+        const partialResolve = times(3, () => {
+          servers.forEach((server) => server.of("/custom").adapter.close());
+          resolve();
+        });
 
-      servers.forEach((server) => server.of("/custom"));
+        servers.forEach((server) => server.of("/custom"));
 
-      const onConnect = times(3, async () => {
-        await sleep(PROPAGATION_DELAY_IN_MS);
+        const onConnect = times(3, async () => {
+          await sleep(PROPAGATION_DELAY_IN_MS);
 
-        emitter.of("/custom").emit("test");
-      });
+          emitter.of("/custom").emit("test");
+        });
 
-      clientSockets.forEach((clientSocket) => {
-        const socket = clientSocket.io.socket("/custom");
-        socket.on("connect", onConnect);
-        socket.on("test", () => {
-          socket.disconnect();
-          partialDone();
+        clientSockets.forEach((clientSocket) => {
+          const socket = clientSocket.io.socket("/custom");
+          socket.on("connect", onConnect);
+          socket.on("test", () => {
+            socket.disconnect();
+            partialResolve();
+          });
         });
       });
     });
 
-    it("broadcasts to all clients in a room", (done) => {
-      serverSockets[1].join("room1");
+    it("broadcasts to all clients in a room", () => {
+      return new Promise<void>((resolve, reject) => {
+        serverSockets[1].join("room1");
 
-      clientSockets[0].on("test", () => {
-        done(new Error("should not happen"));
+        clientSockets[0].on("test", () => {
+          reject("should not happen");
+        });
+
+        clientSockets[1].on("test", () => {
+          resolve();
+        });
+
+        clientSockets[2].on("test", () => {
+          reject("should not happen");
+        });
+
+        emitter.to("room1").emit("test");
       });
-
-      clientSockets[1].on("test", () => {
-        done();
-      });
-
-      clientSockets[2].on("test", () => {
-        done(new Error("should not happen"));
-      });
-
-      emitter.to("room1").emit("test");
     });
 
-    it("broadcasts to all clients except in room", (done) => {
-      const partialDone = times(2, done);
-      serverSockets[1].join("room1");
+    it("broadcasts to all clients except in room", () => {
+      return new Promise<void>((resolve, reject) => {
+        const partialResolve = times(2, resolve);
+        serverSockets[1].join("room1");
 
-      clientSockets[0].on("test", () => {
-        partialDone();
+        clientSockets[0].on("test", () => {
+          partialResolve();
+        });
+
+        clientSockets[1].on("test", () => {
+          reject("should not happen");
+        });
+
+        clientSockets[2].on("test", () => {
+          partialResolve();
+        });
+
+        emitter.of("/").except("room1").emit("test");
       });
-
-      clientSockets[1].on("test", () => {
-        done(new Error("should not happen"));
-      });
-
-      clientSockets[2].on("test", () => {
-        partialDone();
-      });
-
-      emitter.of("/").except("room1").emit("test");
     });
   });
 
@@ -113,9 +122,9 @@ describe("@socket.io/redis-streams-emitter", () => {
 
       await sleep(PROPAGATION_DELAY_IN_MS);
 
-      expect(serverSockets[0].rooms.has("room1")).to.be(true);
-      expect(serverSockets[1].rooms.has("room1")).to.be(true);
-      expect(serverSockets[2].rooms.has("room1")).to.be(true);
+      assert.ok(serverSockets[0].rooms.has("room1"));
+      assert.ok(serverSockets[1].rooms.has("room1"));
+      assert.ok(serverSockets[2].rooms.has("room1"));
     });
 
     it("makes the matching socket instances join the specified room", async () => {
@@ -126,9 +135,9 @@ describe("@socket.io/redis-streams-emitter", () => {
 
       await sleep(PROPAGATION_DELAY_IN_MS);
 
-      expect(serverSockets[0].rooms.has("room2")).to.be(true);
-      expect(serverSockets[1].rooms.has("room2")).to.be(false);
-      expect(serverSockets[2].rooms.has("room2")).to.be(true);
+      assert.ok(serverSockets[0].rooms.has("room2"));
+      assert.ok(serverSockets[1].rooms.has("room2") === false);
+      assert.ok(serverSockets[2].rooms.has("room2"));
     });
 
     it("makes the given socket instance join the specified room", async () => {
@@ -136,9 +145,9 @@ describe("@socket.io/redis-streams-emitter", () => {
 
       await sleep(PROPAGATION_DELAY_IN_MS);
 
-      expect(serverSockets[0].rooms.has("room3")).to.be(false);
-      expect(serverSockets[1].rooms.has("room3")).to.be(true);
-      expect(serverSockets[2].rooms.has("room3")).to.be(false);
+      assert.ok(serverSockets[0].rooms.has("room3") === false);
+      assert.ok(serverSockets[1].rooms.has("room3"));
+      assert.ok(serverSockets[2].rooms.has("room3") === false);
     });
   });
 
@@ -151,9 +160,9 @@ describe("@socket.io/redis-streams-emitter", () => {
 
       await sleep(PROPAGATION_DELAY_IN_MS);
 
-      expect(serverSockets[0].rooms.has("room1")).to.be(false);
-      expect(serverSockets[1].rooms.has("room1")).to.be(false);
-      expect(serverSockets[2].rooms.has("room1")).to.be(false);
+      assert.ok(serverSockets[0].rooms.has("room1") === false);
+      assert.ok(serverSockets[1].rooms.has("room1") === false);
+      assert.ok(serverSockets[2].rooms.has("room1") === false);
     });
 
     it("makes the matching socket instances leave the specified room", async () => {
@@ -165,9 +174,9 @@ describe("@socket.io/redis-streams-emitter", () => {
 
       await sleep(PROPAGATION_DELAY_IN_MS);
 
-      expect(serverSockets[0].rooms.has("room2")).to.be(false);
-      expect(serverSockets[1].rooms.has("room2")).to.be(false);
-      expect(serverSockets[2].rooms.has("room2")).to.be(true);
+      assert.ok(serverSockets[0].rooms.has("room2") === false);
+      assert.ok(serverSockets[1].rooms.has("room2") === false);
+      assert.ok(serverSockets[2].rooms.has("room2"));
     });
 
     it("makes the given socket instance leave the specified room", async () => {
@@ -179,46 +188,50 @@ describe("@socket.io/redis-streams-emitter", () => {
 
       await sleep(PROPAGATION_DELAY_IN_MS);
 
-      expect(serverSockets[0].rooms.has("room3")).to.be(true);
-      expect(serverSockets[1].rooms.has("room3")).to.be(false);
-      expect(serverSockets[2].rooms.has("room3")).to.be(true);
+      assert.ok(serverSockets[0].rooms.has("room3"));
+      assert.ok(serverSockets[1].rooms.has("room1") === false);
+      assert.ok(serverSockets[2].rooms.has("room3"));
     });
   });
 
   describe("disconnectSockets", () => {
-    it("makes all socket instances disconnect", (done) => {
-      const partialDone = times(3, done);
+    it("makes all socket instances disconnect", () => {
+      return new Promise<void>((resolve) => {
+        const partialResolve = times(3, resolve);
 
-      clientSockets.forEach((clientSocket) => {
-        clientSocket.on("disconnect", (reason) => {
-          expect(reason).to.eql("io server disconnect");
-          partialDone();
+        clientSockets.forEach((clientSocket) => {
+          clientSocket.on("disconnect", (reason) => {
+            assert.equal(reason, "io server disconnect");
+            partialResolve();
+          });
         });
-      });
 
-      emitter.disconnectSockets();
+        emitter.disconnectSockets();
+      });
     });
   });
 
   describe("serverSideEmit", () => {
-    it("sends an event to other server instances", (done) => {
-      const partialDone = times(3, done);
+    it("sends an event to other server instances", () => {
+      return new Promise<void>((resolve) => {
+        const partialResolve = times(3, resolve);
 
-      emitter.serverSideEmit("hello", "world", 1, "2");
+        emitter.serverSideEmit("hello", "world", 1, "2");
 
-      servers[0].on("hello", (arg1, arg2, arg3) => {
-        expect(arg1).to.eql("world");
-        expect(arg2).to.eql(1);
-        expect(arg3).to.eql("2");
-        partialDone();
-      });
+        servers[0].on("hello", (arg1, arg2, arg3) => {
+          assert.equal(arg1, "world");
+          assert.equal(arg2, 1);
+          assert.equal(arg3, "2");
+          partialResolve();
+        });
 
-      servers[1].on("hello", (arg1, arg2, arg3) => {
-        partialDone();
-      });
+        servers[1].on("hello", (arg1, arg2, arg3) => {
+          partialResolve();
+        });
 
-      servers[2].of("/").on("hello", () => {
-        partialDone();
+        servers[2].of("/").on("hello", () => {
+          partialResolve();
+        });
       });
     });
   });

packages/socket.io-redis-streams-emitter/test/util.ts

@@ -138,9 +138,17 @@ async function init() {
 export async function setup() {
   const results = await Promise.all([init(), init(), init()]);
 
-  const servers = results.map(({ io }) => io);
-  const serverSockets = results.map(({ socket }) => socket);
-  const clientSockets = results.map(({ clientSocket }) => clientSocket);
+  const servers = results.map(({ io }) => io) as [Server, Server, Server];
+  const serverSockets = results.map(({ socket }) => socket) as [
+    ServerSocket,
+    ServerSocket,
+    ServerSocket,
+  ];
+  const clientSockets = results.map(({ clientSocket }) => clientSocket) as [
+    ClientSocket,
+    ClientSocket,
+    ClientSocket,
+  ];
   const cleanupMethods = results.map(({ cleanup }) => cleanup);
 
   return {

packages/socket.io/package.json

@@ -26,9 +26,12 @@
   "type": "commonjs",
   "main": "./dist/index.js",
   "exports": {
-    "types": "./dist/index.d.ts",
-    "import": "./wrapper.mjs",
-    "require": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./wrapper.mjs",
+      "require": "./dist/index.js"
+     },
+    "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
   "license": "MIT",
@@ -44,7 +47,7 @@
     "compile": "rimraf ./dist && tsc",
     "test": "npm run format:check && npm run compile && npm run test:types && npm run test:unit",
     "test:types": "tsd",
-    "test:unit": "nyc mocha --require ts-node/register --reporter spec --slow 200 --bail --timeout 10000 test/index.ts",
+    "test:unit": "nyc mocha --import=tsx --reporter spec --slow 200 --bail --timeout 10000 test/index.ts",
     "format:check": "prettier --check \"lib/**/*.ts\" \"test/**/*.ts\"",
     "format:fix": "prettier --write \"lib/**/*.ts\" \"test/**/*.ts\"",
     "prepack": "npm run compile"