NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
npm
npm, #2395 most downloaded on npm
Realtime application framework client
Latest stable
4.8.4
Last release 1 months ago
25 Sep 2026
Release timing varies
gaps range from 8 days to 1.2 years
Nearly every release is documented
notes for 60 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
15 years old
132 releases · first in 2011
Drag across the ruler to compare, or tap a release to open it.
types: export ExtendedError for connect_error event
engine.io-client@~6.6.1 (no change)ws@~8.21.0 (diff)There were some minor bug fixes on the server side, which mandate a client bump.
There were some minor bug fixes on the server side, which mandate a client bump.
engine.io-client@~6.6.1 (no change)ws@~8.18.3 (diff)Your coding agent can read these notes before it upgrades. Set up the MCP server →
bundle: do not mangle the "_placeholder" attribute (bis)
engine.io-client@~6.6.1 (no change)ws@~8.17.1 (no change)bundle: do not mangle the "_placeholder" attribute
engine.io-client@~6.6.1 (no change)ws@~8.17.1 (no change)The transports option now accepts an array of transport implementations:
The transports option now accepts an array of transport implementations:
import { io } from "socket.io-client";
import { XHR, WebSocket } from "engine.io-client";
const socket = io({
transports: [XHR, WebSocket]
});
Here is the list of provided implementations:
| Transport | Description |
|---|---|
Fetch |
HTTP long-polling based on the built-in fetch() method. |
NodeXHR |
HTTP long-polling based on the XMLHttpRequest object provided by the xmlhttprequest-ssl package. |
XHR |
HTTP long-polling based on the built-in XMLHttpRequest object. |
NodeWebSocket |
WebSocket transport based on the WebSocket object provided by the ws package. |
WebSocket |
WebSocket transport based on the built-in WebSocket object. |
WebTransport |
WebTransport transport based on the built-in WebTransport object. |
Usage:
| Transport | browser | Node.js | Deno | Bun |
|---|---|---|---|---|
Fetch |
:white_check_mark: | :white_check_mark: (1) | :white_check_mark: | :white_check_mark: |
NodeXHR |
:white_check_mark: | :white_check_mark: | :white_check_mark: | |
XHR |
:white_check_mark: | |||
NodeWebSocket |
:white_check_mark: | :white_check_mark: | :white_check_mark: | |
WebSocket |
:white_check_mark: | :white_check_mark: (2) | :white_check_mark: | :white_check_mark: |
WebTransport |
:white_check_mark: | :white_check_mark: |
(1) since v18.0.0 (2) since v21.0.0
When setting the tryAllTransports option to true, if the first transport (usually, HTTP long-polling) fails, then the other transports will be tested too:
import { io } from "socket.io-client";
const socket = io({
tryAllTransports: true
});
This feature is useful in two cases:
transports: ["websocket", "polling"])The only potential downside is that the connection attempt could take more time in case of failure, as there have been reports of WebSocket connection errors taking several seconds before being detected (that's one reason for using HTTP long-polling first). That's why the option defaults to false for now.
Added in 579b243.
engine.io-client@~6.6.1 (diff and diff)ws@~8.17.1 (diff)close the adapters when the server is closed
engine.io@~6.5.2 (no change)ws@~8.11.0 (no change)engine.io-client@~6.5.2 (no change)ws@~8.11.0 (no change)typings: calling io.emit with no arguments incorrectly errored (cb6d2e0), closes #4914
engine.io@~6.5.2 (no change)ws@~8.11.0 (no change)There were some minor bug fixes on the server side, which mandate a client bump.
engine.io-client@~6.5.2 (no change)ws@~8.11.0 (no change)return the first response when broadcasting to a single socket
engine.io@~6.5.2 (no change)ws@~8.11.0 (no change)engine.io-client@~6.5.2 (no change)ws@~8.11.0 (no change)clean up child namespace when client is rejected in middleware
engine.io@~6.5.2 (diff)ws@~8.11.0 (no change)Some bug fixes are included from the engine.io-client package:
engine.io-client@~6.5.2 (diff)ws@~8.11.0 (no change)The client bundle contains a few fixes regarding the WebTransport support.
The client bundle contains a few fixes regarding the WebTransport support.
engine.io@~6.5.0 (no change)ws@~8.11.0 (no change)Some bug fixes are included from the engine.io-client package:
engine.io-client@~6.5.1 (diff)ws@~8.11.0 (no change)remove the Partial modifier from the socket.data type
The Socket.IO server can now use WebTransport as the underlying transport.
WebTransport is a web API that uses the HTTP/3 protocol as a bidirectional transport. It's intended for two-way communications between a web client and an HTTP/3 server.
References:
Until WebTransport support lands in Node.js, you can use the @fails-components/webtransport package:
import { readFileSync } from "fs";
import { createServer } from "https";
import { Server } from "socket.io";
import { Http3Server } from "@fails-components/webtransport";
// WARNING: the total length of the validity period MUST NOT exceed two weeks (https://w3c.github.io/webtransport/#custom-certificate-requirements)
const cert = readFileSync("/path/to/my/cert.pem");
const key = readFileSync("/path/to/my/key.pem");
const httpsServer = createServer({
key,
cert
});
httpsServer.listen(3000);
const io = new Server(httpsServer, {
transports: ["polling", "websocket", "webtransport"] // WebTransport is not enabled by default
});
const h3Server = new Http3Server({
port: 3000,
host: "0.0.0.0",
secret: "changeit",
cert,
privKey: key,
});
(async () => {
const stream = await h3Server.sessionStream("/socket.io/");
const sessionReader = stream.getReader();
while (true) {
const { done, value } = await sessionReader.read();
if (done) {
break;
}
io.engine.onWebTransportSession(value);
}
})();
h3Server.startServer();
Added in 123b68c.
The bundles will now have the right Access-Control-Allow-xxx headers.
Added in 63f181c.
engine.io@~6.5.0 (diff)ws@~8.11.0 (no change)The Engine.IO client can now use WebTransport as the underlying transport.
WebTransport is a web API that uses the HTTP/3 protocol as a bidirectional transport. It's intended for two-way communications between a web client and an HTTP/3 server.
References:
For Node.js clients: until WebTransport support lands in Node.js, you can use the @fails-components/webtransport package:
import { WebTransport } from "@fails-components/webtransport";
global.WebTransport = WebTransport;
Added in 7195c0f.
When setting the withCredentials option to true, the Node.js client will now include the cookies in the HTTP requests, making it easier to use it with cookie-based sticky sessions.
import { io } from "socket.io-client";
const socket = io("https://example.com", {
withCredentials: true
});
Added in 5fc88a6.
By default, the ESM build does not include the debug package in the browser environments, because it increases the bundle size (see 16b6569).
Which means that, unfortunately, debug logs are not available in the devtools console, even when setting the localStorage.debug = ... attribute.
You can now import the build which includes the debug packages with a conditional import. Example with vite:
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
export default defineConfig({
plugins: [react()],
server: {
port: 4000
},
resolve: {
conditions: ["development"]
}
})
Reference: https://v2.vitejs.dev/config/#resolve-conditions
Added in 781d753.
engine.io-client@~6.5.0 (diff)ws@~8.11.0 (no change)exports: move types condition to the top
engine.io@~6.4.2 (diff)ws@~8.11.0 (no change)properly handle manually created dynamic namespaces
engine.io@~6.4.1 (diff)ws@~8.11.0 (no change)engine.io-client@~6.4.0 (no change)ws@~8.11.0 (no change)add timeout method to remote socket
This commit adds some syntactic sugar around acknowledgements:
emitWithAck()try {
const responses = await io.timeout(1000).emitWithAck("some-event");
console.log(responses); // one response per client
} catch (e) {
// some clients did not acknowledge the event in the given delay
}
io.on("connection", async (socket) => {
// without timeout
const response = await socket.emitWithAck("hello", "world");
// with a specific timeout
try {
const response = await socket.timeout(1000).emitWithAck("hello", "world");
} catch (err) {
// the client did not acknowledge the event in the given delay
}
});
serverSideEmitWithAck()try {
const responses = await io.timeout(1000).serverSideEmitWithAck("some-event");
console.log(responses); // one response per server (except itself)
} catch (e) {
// some servers did not acknowledge the event in the given delay
}
Added in 184f3cf.
This feature allows a client to reconnect after a temporary disconnection and restore its state:
Usage:
import { Server } from "socket.io";
const io = new Server({
connectionStateRecovery: {
// default values
maxDisconnectionDuration: 2 * 60 * 1000,
skipMiddlewares: true,
},
});
io.on("connection", (socket) => {
console.log(socket.recovered); // whether the state was recovered or not
});
Here's how it works:
id attribute, which is public and can be freely shared)The in-memory adapter already supports this feature, and we will soon update the Postgres and MongoDB adapters. We will also create a new adapter based on Redis Streams, which will support this feature.
Added in 54d5ee0.
This feature implements middlewares at the Engine.IO level, because Socket.IO middlewares are meant for namespace authorization and are not executed during a classic HTTP request/response cycle.
Syntax:
io.engine.use((req, res, next) => {
// do something
next();
});
// with express-session
import session from "express-session";
io.engine.use(session({
secret: "keyboard cat",
resave: false,
saveUninitialized: true,
cookie: { secure: true }
}));
// with helmet
import helmet from "helmet";
io.engine.use(helmet());
A workaround was possible by using the allowRequest option and the "headers" event, but this feels way cleaner and works with upgrade requests too.
Added in 24786e7.
The disconnect event will now contain additional details about the disconnection reason.
io.on("connection", (socket) => {
socket.on("disconnect", (reason, description) => {
console.log(description);
});
});
Added in 8aa9499.
This commit adds a new option, "cleanupEmptyChildNamespaces". With this option enabled (disabled by default), when a socket disconnects from a dynamic namespace and if there are no other sockets connected to it then the namespace will be cleaned up and its adapter will be closed.
import { createServer } from "node:http";
import { Server } from "socket.io";
const httpServer = createServer();
const io = new Server(httpServer, {
cleanupEmptyChildNamespaces: true
});
Added in 5d9220b.
The trailing slash which was added by default can now be disabled:
import { createServer } from "node:http";
import { Server } from "socket.io";
const httpServer = createServer();
const io = new Server(httpServer, {
addTrailingSlash: false
});
In the example above, the clients can omit the trailing slash and use /socket.io instead of /socket.io/.
Added in d0fd474.
engine.io@~6.4.0 (diff)ws@~8.11.0 (diff)The trailing slash which was added by default can now be disabled:
import { io } from "socket.io-client";
const socket = io("https://example.com", {
addTrailingSlash: false
});
In the example above, the request URL will be https://example.com/socket.io instead of https://example.com/socket.io/.
Added in 21a6e12.
This commit adds some syntactic sugar around acknowledgements:
// without timeout
const response = await socket.emitWithAck("hello", "world");
// with a specific timeout
try {
const response = await socket.timeout(1000).emitWithAck("hello", "world");
} catch (err) {
// the server did not acknowledge the event in the given delay
}
Note: environments that do not support Promises will need to add a polyfill in order to use this feature.
Added in 47b979d.
This feature allows a client to reconnect after a temporary disconnection and restore its ID and receive any packets that was missed during the disconnection gap. It must be enabled on the server side.
A new boolean attribute named recovered is added on the socket object:
socket.on("connect", () => {
console.log(socket.recovered); // whether the recovery was successful
});
Added in 54d5ee0 (server) and b4e20c5 (client).
Two new options are available:
retries: the maximum number of retries. Above the limit, the packet will be discarded.ackTimeout: the default timeout in milliseconds used when waiting for an acknowledgement (not to be mixed up with the already existing timeout option, which is used by the Manager during the connection)const socket = io({
retries: 3,
ackTimeout: 10000
});
// implicit ack
socket.emit("my-event");
// explicit ack
socket.emit("my-event", (err, val) => { /* ... */ });
// custom timeout (in that case the ackTimeout is optional)
socket.timeout(5000).emit("my-event", (err, val) => { /* ... */ });
In all examples above, "my-event" will be sent up to 4 times (1 + 3), until the server sends an acknowledgement.
Assigning a unique ID to each packet is the duty of the user, in order to allow deduplication on the server side.
Added in 655dce9.
Nothing published for this version
Nothing published for this version
engine.io in order to fix CVE-2022-41940
This release contains a bump of:
engine.io in order to fix CVE-2022-41940socket.io-parser in order to fix CVE-2022-2421.engine.io@~6.2.1 (diff)ws@~8.2.3This release contains a bump of the socket.io-parser dependency, in order to fix CVE-2022-2421.
engine.io-client@~6.2.3 (no change)ws@~8.2.3 (no change)typings: accept an HTTP2 server in the constructor
engine.io-client@~6.2.3 (https://github.com/socketio/engine.io-client/compare/6.2.1...6.2.3)ws@~8.2.3 (no change)prevent the socket from joining a room after disconnection
engine.io-client@~6.2.1 (no change)ws@~8.2.3 (no change)engine.io-client@~3.5.0 (no change)ws@~7.4.2 (no change)forward the local flag to the adapter when using fetchSockets()
There were some minor bug fixes on the server side, which mandate a client bump.
engine.io-client@~6.2.1 (no change)ws@~8.2.3 (no change)The "disconnect" event will now include additional details to help debugging if anything has gone wrong.
Example when a payload is over the maxHttpBufferSize value in HTTP long-polling mode:
socket.on("disconnect", (reason, details) => {
console.log(reason); // "transport error"
// in that case, details is an error object
console.log(details.message); "xhr post error"
console.log(details.description); // 413 (the HTTP status of the response)
// details.context refers to the XMLHttpRequest object
console.log(details.context.status); // 413
console.log(details.context.responseText); // ""
});
Added in b862924.
This is similar to onAny(), but for outgoing packets.
Syntax:
socket.onAnyOutgoing((event, ...args) => {
console.log(event);
});
Added in 74e3e60.
The server will now include a "maxPayload" field in the handshake details, allowing the clients to decide how many packets they have to send to stay under the maxHttpBufferSize value.
Added in 46fdc2f.
engine.io-client@~6.2.1 (https://github.com/socketio/engine.io-client/compare/6.1.1...6.2.1)ws@~8.2.3 (no change)typings: ensure compatibility with TypeScript 3.x
This is similar to onAny(), but for outgoing packets.
Syntax:
socket.onAnyOutgoing((event, ...args) => {
console.log(event);
});
Syntax:
io.timeout(1000).emit("some-event", (err, responses) => {
// ...
});
So that clients in HTTP long-polling can decide how many packets they have to send to stay under the maxHttpBufferSize value.
This is a backward compatible change which should not mandate a new major revision of the protocol (we stay in v4), as we only add a field in the JSON-encoded handshake data:
0{"sid":"lv_VI97HAXpY6yYWAAAC","upgrades":["websocket"],"pingInterval":25000,"pingTimeout":5000,"maxPayload":1000000}
types: make RemoteSocket.data type safe
socket.disconnect().connect() usage (99c2cb8)socket.timeout(5000).emit("my-event", (err) => {
if (err) {
// the server did not acknowledge the event in the given delay
}
});
only set 'connected' to true after middleware execution
const { App } = require("uWebSockets.js");
const { Server } = require("socket.io");
const app = new App();
const io = new Server();
io.attachApp(app);
io.on("connection", (socket) => {
// ...
});
app.listen(3000, (token) => {
if (!token) {
console.warn("port already in use");
}
});
socket.timeout(5000).emit("my-event", (err) => {
if (err) {
// the client did not acknowledge the event in the given delay
}
});
interface SocketData {
name: string;
age: number;
}
const io = new Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>();
io.on("connection", (socket) => {
socket.data.name = "john";
socket.data.age = 42;
});
fix race condition in dynamic namespaces
Diff: https://github.com/socketio/socket.io/compare/4.3.0...4.3.1
An ESM bundle is now provided:
<script type="module">
import { io } from "https://cdn.socket.io/4.3.0/socket.io.esm.min.js";
const socket = io();
socket.emit("hello", "world");
</script>
For this release, most of the work was done on the client side, see here.
typings: allow async listener in typed events
Diff: https://github.com/socketio/socket.io/compare/4.1.2...4.1.3
typings: ensure compatibility with TypeScript 3.x
typings: properly type server-side events
There were some minor bug fixes on the server side, which mandate a client bump.
engine.io-client)Blog post: https://socket.io/blog/socket-io-4-1-0/
Blog post: https://socket.io/blog/socket-io-4-1-0/
engine.io)engine.io)~5.1.0~7.4.2typings: make "engine" attribute public
typings: add fallback to untyped event listener
Blog post: https://socket.io/blog/socket-io-4-release/ Migration guide: https://socket.io/docs/v3/migrating-from-3-x-to-4-0/
Blog post: https://socket.io/blog/socket-io-4-release/ Migration guide: https://socket.io/docs/v3/migrating-from-3-x-to-4-0/
io.to(...) now returns an immutable operatorPreviously, broadcasting to a given room (by calling io.to()) would mutate the io instance, which could lead to surprising behaviors, like:
io.to("room1");
io.to("room2").emit(/* ... */); // also sent to room1
// or with async/await
io.to("room3").emit("details", await fetchDetails()); // random behavior: maybe in room3, maybe to all clients
Calling io.to() (or any other broadcast modifier) will now return an immutable instance.
~5.0.0~7.4.2The major bump is due to some breaking changes on the server side.
ignore packets received after disconnection
properly parse the CONNECT packet in v2 compatibility mode
~4.1.0~7.4.2In order to ease the migration to Socket.IO v3, the v3 server is now able to communicate with v2 clients:
In order to ease the migration to Socket.IO v3, the v3 server is now able to communicate with v2 clients:
const io = require("socket.io")({
allowEIO3: true // false by default
});
Note: the allowEIO3 refers to the version 3 of the Engine.IO protocol which is used in Socket.IO v2
~4.1.0~7.4.2properly clear timeout on connection failure
The minor bump is matching the bump of the server, but there is no new feature in this release.
Diff: https://github.com/socketio/socket.io/compare/3.0.3...3.0.4
~4.0.0^7.1.2Diff: https://github.com/socketio/socket.io/compare/3.0.2...3.0.3
~4.0.0^7.1.2Diff: https://github.com/socketio/socket.io/compare/3.0.1...3.0.2
export ServerOptions and Namespace types
// before
socket.on("error", () => {});
// after
socket.on("connect_error", () => {});
the Socket#binary() method is removed, as this use case is now covered by the ability to provide your own parser.
the Socket instance will no longer forward the events of its Manager
Those events can still be accessed on the Manager instance though:
socket.io.on("reconnect", () => {
// ...
});
// before
socket.on("error", () => {});
// after
socket.on("connect_error", () => {});
Those events can still be accessed on the Manager instance though:
socket.io.on("reconnect", () => {
// ...
});
More details about this release in the blog post: https://socket.io/blog/socket-io-3-release/
More details about this release in the blog post: https://socket.io/blog/socket-io-3-release/
Dedicated migration guide: https://socket.io/docs/migrating-from-2-x-to-3-0/
the Socket#use() method is removed (see 5c73733)
Socket#join() and Socket#leave() do not accept a callback argument anymore.
Before:
socket.join("room1", () => {
io.to("room1").emit("hello");
});
After:
socket.join("room1");
io.to("room1").emit("hello");
// or await socket.join("room1"); for custom adapters
Before:
new Server(3000, {
origins: ["https://example.com"]
});
The 'origins' option was used in the allowRequest method, in order to determine whether the request should pass or not. And the Engine.IO server would implicitly add the necessary Access-Control-Allow-xxx headers.
After:
new Server(3000, {
cors: {
origin: "https://example.com",
methods: ["GET", "POST"],
allowedHeaders: ["content-type"]
}
});
The already existing 'allowRequest' option can be used for validation:
new Server(3000, {
allowRequest: (req, callback) => {
callback(null, req.headers.referer.startsWith("https://example.com"));
}
});
Socket#rooms is now a Set instead of an object
Namespace#connected is now a Map instead of an object
there is no more implicit connection to the default namespace:
// client-side
const socket = io("/admin");
// server-side
io.on("connect", socket => {
// not triggered anymore
})
io.use((socket, next) => {
// not triggered anymore
});
io.of("/admin").use((socket, next) => {
// triggered
});
This method was kept for backward-compatibility with pre-1.0 versions.
~4.0.0^7.1.2emit an Error object upon middleware error
add support for catch-all listeners
the Socket#use() method is removed (see 5c73733)
Socket#join() and Socket#leave() do not accept a callback argument anymore.
Before:
socket.join("room1", () => {
io.to("room1").emit("hello");
});
After:
socket.join("room1");
io.to("room1").emit("hello");
// or await socket.join("room1"); for custom adapters
close clients with no namespace
remove the implicit connection to the default namespace
Before:
new Server(3000, {
origins: ["https://example.com"]
});
The 'origins' option was used in the allowRequest method, in order to determine whether the request should pass or not. And the Engine.IO server would implicitly add the necessary Access-Control-Allow-xxx headers.
After:
new Server(3000, {
cors: {
origin: "https://example.com",
methods: ["GET", "POST"],
allowedHeaders: ["content-type"]
}
});
The already existing 'allowRequest' option can be used for validation:
new Server(3000, {
allowRequest: (req, callback) => {
callback(null, req.headers.referer.startsWith("https://example.com"));
}
});
Socket#rooms is now a Set instead of an object
Namespace#connected is now a Map instead of an object
there is no more implicit connection to the default namespace:
// client-side
const socket = io("/admin");
// server-side
io.on("connect", socket => {
// not triggered anymore
})
io.use((socket, next) => {
// not triggered anymore
});
io.of("/admin").use((socket, next) => {
// triggered
});
Server#set() method was removedThis method was kept for backward-compatibility with pre-1.0 versions.
The default value of the maxHttpBufferSize option has been decreased from 100 MB to 1 MB, in order to prevent attacks by denial of service.
:warning: WARNING :warning:
The default value of the maxHttpBufferSize option has been decreased from 100 MB to 1 MB, in order to prevent attacks by denial of service.
Security advisory: https://github.com/advisories/GHSA-j4f2-536g-r55m
:warning: BREAKING CHANGE :warning:
Related blog post: https://socket.io/blog/socket-io-2-4-0/
:warning: BREAKING CHANGE :warning:
Previously, CORS was enabled by default, which meant that a Socket.IO server sent the necessary CORS headers (Access-Control-Allow-xxx) to any domain. This will not be the case anymore, and you now have to explicitly enable it.
Please note that you are not impacted if:
origins option to restrict the list of allowed domainsThis commit also removes the support for '*' matchers and protocol-less URL:
io.origins('https://example.com:443'); => io.origins(['https://example.com']);
io.origins('localhost:3000'); => io.origins(['http://localhost:3000']);
io.origins('http://localhost:*'); => io.origins(['http://localhost:3000']);
io.origins('*:3000'); => io.origins(['http://localhost:3000']);
To restore the previous behavior (please use with caution):
io.origins((_, callback) => {
callback(null, true);
});
See also:
Thanks a lot to @ni8walk3r for the security report.
The debug dependency has been reverted to ~3.1.0, as the newer versions contains ES6 syntax which breaks in IE browsers.
The debug dependency has been reverted to ~3.1.0, as the newer versions contains ES6 syntax which breaks in IE
browsers.
Please note that this only applied to users that bundle the Socket.IO client in their application, with webpack for example, as the "official" bundles (in the dist/ folder) were already transpiled with babel.
For webpack users, you can also take a look at the webpack-remove-debug plugin.
The minor bump is matching the bump of the server, but there is no new feature in this release.
global variable (related: https://github.com/socketio/socket.io-client/issues/1166)This release mainly contains a bump of the engine.io and ws packages, but no additional features.
This release mainly contains a bump of the engine.io and ws packages, but no additional features.
add cache-control header when serving the client source
add local flag to the socket object
socket.local.to('room101').emit(/* */);
(client) fire an error event on middleware failure for non-root namespace (https://github.com/socketio/socket.io-client/pull/1202)
// by default, the object is recursively scanned to check whether it contains some binary data
// in the following example, the check is skipped in order to improve performance
socket.binary(false).emit('plain-object', object);
There are two non-breaking changes that are somehow quite important:
// by default, the object is recursively scanned to check whether it contains some binary data
// in the following example, the check is skipped in order to improve performance
socket.binary(false).emit('plain-object', object);
// it also works at the namespace level
io.binary(false).emit('plain-object', object);
io.of(/^\/dynamic-\d+$/).on('connect', (socket) => {
// socket.nsp.name = '/dynamic-101'
});
// client-side
const client = require('socket.io-client')('/dynamic-101');
There are two non-breaking changes that are somehow quite important:
ws was reverted as the default wsEngine (https://github.com/socketio/engine.io/pull/550), as there was several blocking issues with uws. You can still use uws by running npm install uws --save in your project and using the wsEngine option:var engine = require('engine.io');
var server = engine.listen(3000, {
wsEngine: 'uws'
});
pingTimeout now defaults to 5 seconds (instead of 60 seconds): https://github.com/socketio/engine.io/pull/551do not throw when receiving an unhandled error packet
engine.io: -ws: -reset rooms object before broadcasting
engine.io: -ws: -fix timing issues with middleware
engine.io: -ws: -## Bug fixes - update path of client file (#2934) #### Links: - Milestone: 2.0.1 - Diff: 2.0.0...2.0.1 - Client release: 2.0.1 - Diff engine.io: - - D
- update path of client file (#2934)
engine.io: -ws: -a breaking change related to utf-8 encoding in engine.io-parser
This major release brings several performance improvements:
uws is now the default Websocket engine. It should bring significant improvement in performance (particularly in terms of memory consumption) (https://github.com/socketio/engine.io/releases/tag/2.0.0)
the Engine.IO and Socket.IO handshake packets were merged, reducing the number of roundtrips necessary to establish a connection. (#2833)
it is now possible to provide a custom parser according to the needs of your application (#2829). Please take a look at the example for more information.
Please note that this release is not backward-compatible, due to:
Please also note that if you are using a self-signed certificate, rejectUnauthorized now defaults to true (https://github.com/socketio/engine.io-client/pull/558).
Finally, the API documentation is now in the repository (here), and the content of the website here. Do not hesitate if you see something wrong or missing!
The full list of changes:
local flag (#2816)clients method in the API documentation (#2812)Besides, we are proud to announce that Socket.IO is now a part of open collective: https://opencollective.com/socketio. More on that later.
One column per quarter.