@encharm/cws 4.6.0 → 4.8.3

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## Released 4.8.3
+* Corked sends up to 1 KB use the per-loop block pool instead of malloc/free per message; queued messages remember their pool block. Also initialise the `reserved` callback argument, which was passed uninitialised for messages that hit the write queue.
+* JS: resolve the native namespace once per socket instead of on every `send`/`close`/`ping`.
+
+## Released 4.8.2
+* Accept compressed messages that end with a BFINAL=1 DEFLATE block (RFC 7692 section 7.2.3.4). Such clients (libdeflate-based and some non-zlib implementations) were disconnected on their first compressed message.
+
+## Released 4.8.1
+* Skip the kernel-level cork/uncork (two `setsockopt` calls) around every socket read when write corking is active; those writes leave in the end-of-tick gathered write anyway. Saves 1-2 us of server CPU per read.
+
+## Released 4.8.0
+* Prebuilt bindings now compress with zlib-ng 2.2.4 (vendored in `deps/zlib-ng`, statically linked, native `zng_` API so it cannot collide with Node's zlib). Measured on a real RPC stream: level 1 costs 2.2-2.5 us/KB vs 5.6-8 us/KB with zlib. The node-gyp fallback build keeps using Node's zlib through the same `src/Zlib.cpp` wrapper.
+* New `perMessageDeflate.level` option (default 2) and a `zlibBackend` export naming the compiled-in implementation.
+* Fix the node-gyp fallback build (`npm install` on a platform without a prebuilt binding): it lacked the vendored Node header include path, `HAVE_OPENSSL`/`NODE_WANT_INTERNALS`, and a macOS 10.15 deployment target, so it has failed silently since the Node 20 headers were introduced.
+
+## Released 4.7.0
+* permessage-deflate: messages are now compressed by default once negotiated (previously only `send(..., { compress: true })` compressed anything). New options `threshold` (minimum size to compress), `windowBits` and `memLevel` (per-socket memory tier for the sliding window, advertised as `server_max_window_bits` when below 15).
+* Remove a leftover debug `console.log` on module load.
+
 ## Released 4.6.0
 * Add Node 26 support (ABI 147, V8 14.6): vendored `src/headers/26`, `MakeCallback` with explicit `async_context`, tagged internal-field reads via `BaseObject::FromJSObject`.
 * Cork writes per event-loop iteration: sends to the same socket within one tick go out in a single gathered write. Disable with `CWS_CORK=0`.

package/CLAUDE.md

@@ -21,14 +21,15 @@ Tests bind ports 3000 (ws) and 3001 (wss, certs in `tests/certs/`). The test fil
 
 ### Building the release binaries (multi-ABI)
 
-`binding.gyp` is only used by `npm install` for a local build against the running Node. Release binaries are built by the `Makefile` (macOS/Linux) and `make.bat` (Windows), which:
+`binding.gyp` is only used by `npm install` for a local build against the running Node (Node's zlib, no zlib-ng); it must carry the same include path and defines as the Makefile or it fails silently (the install script discards the exit code). Release binaries are built by the `Makefile` (macOS/Linux) and `make.bat` (Windows), which:
 
 1. Download official Node header tarballs for one pinned version per supported major into `targets/` (`VER_115`=Node 20, `VER_127`=Node 22, `VER_137`=Node 24, `VER_147`=Node 26; the number is the Node ABI / `process.versions.modules`).
 2. Compile `src/*.cpp` once per ABI with `g++`/`cl` directly, with `-I src/headers/$V` for the matching Node major.
-3. Emit `dist/bindings/cws_<platform>_<arch>_node<ABI>.node`.
+3. Build the vendored zlib-ng (`deps/zlib-ng`, native `zng_` API) once per OS/arch: CMake into `deps/zlib-ng/build-<OS>-<arch>/` on macOS/Linux, `nmake -f win32\Makefile.msc` on Windows. The bindings are compiled with `-DCWS_ZLIB_NG` and link it statically. `src/Zlib.cpp` is the only file that includes a zlib header; without the define (node-gyp fallback) it uses Node's zlib.
+4. Emit `dist/bindings/cws_<platform>_<arch>_node<ABI>.node`.
 
 ```sh
-make                                  # all three ABIs for the host OS/arch (needs curl + g++/clang)
+make                                  # all four ABIs for the host OS/arch (needs curl, cmake, g++/clang)
 ./build-on-docker.sh linux/arm64      # Linux arm64 (native on Apple Silicon, ~1 min)
 ./build-on-docker.sh linux/amd64      # Linux x64 (default; emulated on Apple Silicon, slower)
 make.bat                              # Windows x64; auto-detects VS 2022 (Build Tools or any edition)
@@ -78,4 +79,5 @@ The client side never touches Node sockets: `native.connect(clientGroup, url, ws
 - Every handler, including `message`, is invoked through `node::MakeCallback`, which establishes an async-context scope and drains nextTick/microtasks after the handler returns. Because that drain happens before `onMessage` detaches the binary `ArrayBuffer`, a continuation that resolves within it still sees the bytes; anything that waits on real I/O sees a detached buffer.
 - `shared.ts` currently has a leftover `console.log('log', ...)` printing the binding path on load.
 - The addon exposes one `Group` per server plus a single shared client group; `ws.external` is the C++ `WebSocket*` and is nulled on disconnect, so every native call in `client.ts` guards on it.
+- permessage-deflate: `Group` carries `deflateWindowBits`/`deflateMemLevel` (tier of the per-socket compressor allocated in the `WebSocket` ctor); the negotiator advertises `server_max_window_bits` when below 15 but ignores a smaller value requested by the client. The JS `send` decides `compress` per message: explicit option, else `compressThreshold` from the server config (undefined when deflate is off). Client-to-server inflate is one shared stream reset per message (`client_no_context_takeover` is always offered).
 - Close code defaults to 1005 when the peer sends none (matches `ws`). App-level ping uses the single byte `'9'` (`APP_PING_CODE`) for browser clients that can't see protocol pings.

package/README.md

@@ -14,6 +14,11 @@ This table is true if you run ssl directly with `cws` (`Node.js`). In case if yo
 
 | cWS Version | Node 26 | Node 24  | Node 22 | Node 20 |
 |-------------|---------|----------|---------|----------
+| 4.8.3       |    X    |    X     |    X    |   X     |
+| 4.8.2       |    X    |    X     |    X    |   X     |
+| 4.8.1       |    X    |    X     |    X    |   X     |
+| 4.8.0       |    X    |    X     |    X    |   X     |
+| 4.7.0       |    X    |    X     |    X    |   X     |
 | 4.6.0       |    X    |    X     |    X    |   X     |
 | 4.5.3       |         |    X     |    X    |   X     |
 
@@ -174,7 +179,14 @@ const wsServer = new WebSocket.Server({
    * noDelay?: boolean (set socket no delay)
    * noServer?: boolean (use this when upgrade done outside of cws)
    * maxPayload?: number 
-   * perMessageDeflate?: boolean | { serverNoContextTakeover: boolean;}
+   * perMessageDeflate?: boolean | { serverNoContextTakeover?: boolean; windowBits?: number; memLevel?: number; threshold?: number }
+   *   true = shared compressor, no context takeover. serverNoContextTakeover: false = per-socket
+   *   sliding window (streaming compression; far better on small messages). windowBits 9..15 and
+   *   memLevel 1..9 pick its memory tier: 15/8 = ~256 KB per socket (default), 12/5 = ~32 KB, 10/3 = ~8 KB.
+   *   threshold = minimum message size in bytes to compress (default 0); send(..., { compress }) overrides.
+   *   level 1..9 (default 2): deflate level of the per-socket compressor. The prebuilt bindings use zlib-ng
+   *   (see `zlibBackend` export): level 1 is its very fast "quick" strategy (~3-4x less CPU than zlib
+   *   level 1 for ~8% worse ratio), level 2 matches zlib level 1's ratio.
    * verifyClient?: (info: ConnectionInfo, next: VerifyClientNext) => void (use to allow or decline connections)
    **/ 
  }, () => {

package/binding.gyp

@@ -12,8 +12,14 @@
                 'src/cSNode.cpp',
                 'src/WebSocket.cpp',
                 'src/HTTPSocket.cpp',
-                'src/Socket.cpp'
+                'src/Socket.cpp',
+                'src/Zlib.cpp'
             ],
+            # Node private headers vendored per major (see src/headers/); the Makefile passes the same -I.
+            'include_dirs': [
+                'src/headers/<!(node -p "parseInt(process.versions.node)")'
+            ],
+            'defines': ['HAVE_OPENSSL=1', 'NODE_WANT_INTERNALS=1'],
             'conditions': [
                 ['OS=="linux"', {
                     'cflags_cc': ['-std=c++17', '-DUSE_LIBUV'],
@@ -31,7 +37,7 @@
                 }],
                 ['OS=="mac"', {
                     'xcode_settings': {
-                        'MACOSX_DEPLOYMENT_TARGET': '10.7',
+                        'MACOSX_DEPLOYMENT_TARGET': '10.15',
                         'CLANG_CXX_LANGUAGE_STANDARD': 'c++20',
                         'CLANG_CXX_LIBRARY': 'libc++',
                         'GCC_GENERATE_DEBUGGING_SYMBOLS': 'NO',

package/dist/client.d.ts

@@ -12,6 +12,8 @@ export declare class WebSocket {
     registeredEvents: any;
     private external;
     private socketType;
+    private compressThreshold;
+    private nativeApi;
     constructor(url: string, options?: any);
     get bufferedAmount(): number;
     get _socket(): SocketAddress;

package/dist/client.js

@@ -4,6 +4,12 @@ exports.WebSocket = void 0;
 const server_1 = require("./server");
 const shared_1 = require("./shared");
 const clientGroup = shared_1.native.client.group.create(0, shared_1.DEFAULT_PAYLOAD_LIMIT);
+function messageByteLength(message) {
+    if (typeof message === 'string') {
+        return Buffer.byteLength(message);
+    }
+    return message && typeof message.byteLength === 'number' ? message.byteLength : 0;
+}
 shared_1.setupNative(clientGroup, 'client');
 class WebSocket {
     constructor(url, options = {}) {
@@ -20,9 +26,12 @@ class WebSocket {
             message: shared_1.noop
         };
         this.socketType = 'client';
+        this.nativeApi = shared_1.native.client;
         if (!this.url && this.options.external) {
             this.socketType = 'server';
+            this.nativeApi = shared_1.native.server;
             this.external = this.options.external;
+            this.compressThreshold = this.options.compressThreshold;
         }
         else {
             shared_1.native.connect(clientGroup, url, this);
@@ -76,7 +85,14 @@ class WebSocket {
             if (options && options.binary === true) {
                 opCode = shared_1.OPCODE_BINARY;
             }
-            shared_1.native[this.socketType].send(this.external, message, opCode, cb ? () => process.nextTick(cb) : null, options && options.compress);
+            let compress = false;
+            if (options && options.compress !== undefined) {
+                compress = !!options.compress;
+            }
+            else if (this.compressThreshold !== undefined) {
+                compress = messageByteLength(message) >= this.compressThreshold;
+            }
+            this.nativeApi.send(this.external, message, opCode, cb ? () => process.nextTick(cb) : null, compress);
         }
         else if (cb) {
             cb(new Error('Socket not connected'));
@@ -84,18 +100,18 @@ class WebSocket {
     }
     ping(message) {
         if (this.external) {
-            shared_1.native[this.socketType].send(this.external, message, shared_1.OPCODE_PING);
+            this.nativeApi.send(this.external, message, shared_1.OPCODE_PING);
         }
     }
     close(code = 1000, reason) {
         if (this.external) {
-            shared_1.native[this.socketType].close(this.external, code, reason);
+            this.nativeApi.close(this.external, code, reason);
             this.external = null;
         }
     }
     terminate() {
         if (this.external) {
-            shared_1.native[this.socketType].terminate(this.external);
+            this.nativeApi.terminate(this.external);
             this.external = null;
         }
     }

package/dist/index.d.ts

@@ -21,10 +21,15 @@ export declare type ServerConfigs = {
     noServer?: boolean;
     maxPayload?: number;
     perMessageDeflate?: boolean | {
-        serverNoContextTakeover: boolean;
+        serverNoContextTakeover?: boolean;
+        windowBits?: number;
+        memLevel?: number;
+        level?: number;
+        threshold?: number;
     };
     verifyClient?: (info: ConnectionInfo, next: VerifyClientNext) => void;
 };
 export { WebSocket } from './client';
 export { WebSocketServer } from './server';
 export declare const secureProtocol: string;
+export { zlibBackend } from './shared';

package/dist/index.js

@@ -6,3 +6,5 @@ Object.defineProperty(exports, "WebSocket", { enumerable: true, get: function ()
 var server_1 = require("./server");
 Object.defineProperty(exports, "WebSocketServer", { enumerable: true, get: function () { return server_1.WebSocketServer; } });
 exports.secureProtocol = 'TLSv1_2_method';
+var shared_1 = require("./shared");
+Object.defineProperty(exports, "zlibBackend", { enumerable: true, get: function () { return shared_1.zlibBackend; } });

package/dist/server.d.ts

@@ -7,6 +7,7 @@ export declare class WebSocketServer {
     private options;
     upgradeCb: (ws: WebSocket) => void;
     upgradeReq: HTTP.IncomingMessage;
+    compressThreshold: number | undefined;
     registeredEvents: any;
     private httpServer;
     private serverGroup;

package/dist/server.js

@@ -12,13 +12,27 @@ class WebSocketServer {
             connection: shared_1.noop,
         };
         let nativeOptions = 0;
+        let windowBits = 15;
+        let memLevel = 8;
+        let level = 2;
         if (this.options.perMessageDeflate) {
             nativeOptions |= shared_1.PERMESSAGE_DEFLATE;
-            if (this.options.perMessageDeflate.serverNoContextTakeover === false) {
+            const deflate = typeof this.options.perMessageDeflate === 'object' ? this.options.perMessageDeflate : {};
+            if (deflate.serverNoContextTakeover === false) {
                 nativeOptions |= shared_1.SLIDING_DEFLATE_WINDOW;
             }
+            if (typeof deflate.windowBits === 'number') {
+                windowBits = deflate.windowBits;
+            }
+            if (typeof deflate.memLevel === 'number') {
+                memLevel = deflate.memLevel;
+            }
+            if (typeof deflate.level === 'number') {
+                level = deflate.level;
+            }
+            this.compressThreshold = typeof deflate.threshold === 'number' ? deflate.threshold : 0;
         }
-        this.serverGroup = shared_1.native.server.group.create(nativeOptions, this.options.maxPayload || shared_1.DEFAULT_PAYLOAD_LIMIT);
+        this.serverGroup = shared_1.native.server.group.create(nativeOptions, this.options.maxPayload || shared_1.DEFAULT_PAYLOAD_LIMIT, windowBits, memLevel, level);
         shared_1.setupNative(this.serverGroup, 'server', this);
         if (this.options.noServer) {
             return;

package/dist/shared.d.ts

@@ -9,4 +9,5 @@ export declare const PERMESSAGE_DEFLATE: number;
 export declare const SLIDING_DEFLATE_WINDOW: number;
 export declare const DEFAULT_PAYLOAD_LIMIT: number;
 export declare const native: any;
+export declare const zlibBackend: string;
 export declare function setupNative(group: any, type: string, wsServer?: WebSocketServer): void;

package/dist/shared.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupNative = exports.native = exports.DEFAULT_PAYLOAD_LIMIT = exports.SLIDING_DEFLATE_WINDOW = exports.PERMESSAGE_DEFLATE = exports.APP_PING_CODE = exports.OPCODE_BINARY = exports.OPCODE_PING = exports.OPCODE_TEXT = exports.noop = void 0;
+exports.setupNative = exports.zlibBackend = exports.native = exports.DEFAULT_PAYLOAD_LIMIT = exports.SLIDING_DEFLATE_WINDOW = exports.PERMESSAGE_DEFLATE = exports.APP_PING_CODE = exports.OPCODE_BINARY = exports.OPCODE_PING = exports.OPCODE_TEXT = exports.noop = void 0;
 const client_1 = require("./client");
 exports.noop = () => { };
 exports.OPCODE_TEXT = 1;
@@ -19,11 +19,12 @@ exports.native = (() => {
         throw err;
     }
 })();
+exports.zlibBackend = exports.native.zlibBackend;
 function setupNative(group, type, wsServer) {
     exports.native.setNoop(exports.noop);
     exports.native[type].group.onConnection(group, (external) => {
         if (type === 'server' && wsServer) {
-            const socket = new client_1.WebSocket(null, { external });
+            const socket = new client_1.WebSocket(null, { external, compressThreshold: wsServer.compressThreshold });
             exports.native.setUserData(external, socket);
             if (wsServer.upgradeCb) {
                 wsServer.upgradeCb(socket);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@encharm/cws",
-  "version": "4.6.0",
+  "version": "4.8.3",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "description": "cWS - fast C++ WebSocket implementation for Node.js",

package/src/Addon.cpp

@@ -20,6 +20,8 @@ void Initialize(Local<Object> exports) {
   NODE_SET_METHOD(exports, "upgrade", upgrade);
   NODE_SET_METHOD(exports, "connect", connect);
   NODE_SET_METHOD(exports, "setNoop", setNoop);
+  exports->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "zlibBackend").ToLocalChecked(),
+               String::NewFromUtf8(isolate, cWS::zlib::backend()).ToLocalChecked()).Check();
   hub.getNodeData()->corkState->enabled = corkEnabledFromEnv();
   registerCheck(isolate);
 }

package/src/Addon.h

@@ -185,8 +185,17 @@ struct GroupData {
 
 template <bool isServer>
 void createGroup(const FunctionCallbackInfo<Value> &args) {
+  int windowBits = args.Length() > 2 && args[2]->IsNumber() ? (int) args[2].As<Integer>()->Value() : 15;
+  int memLevel = args.Length() > 3 && args[3]->IsNumber() ? (int) args[3].As<Integer>()->Value() : 8;
+  if (windowBits < 9) windowBits = 9;
+  if (windowBits > 15) windowBits = 15;
+  if (memLevel < 1) memLevel = 1;
+  if (memLevel > 9) memLevel = 9;
+  int level = args.Length() > 4 && args[4]->IsNumber() ? (int) args[4].As<Integer>()->Value() : 1;
+  if (level < 1) level = 1;
+  if (level > 9) level = 9;
   cWS::Group<isServer> *group = hub.createGroup<isServer>(
-      args[0].As<Integer>()->Value(), args[1].As<Integer>()->Value());
+      args[0].As<Integer>()->Value(), args[1].As<Integer>()->Value(), windowBits, memLevel, level);
   group->setUserData(new GroupData);
   args.GetReturnValue().Set(External::New(args.GetIsolate(), group));
 }

package/src/Extensions.cpp

@@ -76,7 +76,7 @@ ExtensionsParser::ExtensionsParser(const char *data, size_t length) {
 }
 
 template <bool isServer>
-ExtensionsNegotiator<isServer>::ExtensionsNegotiator(int wantedOptions) {
+ExtensionsNegotiator<isServer>::ExtensionsNegotiator(int wantedOptions, int serverMaxWindowBits) : serverMaxWindowBits(serverMaxWindowBits) {
     options = wantedOptions;
 }
 
@@ -100,6 +100,12 @@ std::string ExtensionsNegotiator<isServer>::generateOffer() {
         if (options & Options::SERVER_NO_CONTEXT_TAKEOVER) {
             //extensionsOffer += "; server_no_context_takeover";
         }
+
+        // Tell the peer our LZ77 window is smaller than the default so it can
+        // size its inflate window accordingly (RFC 7692 section 7.1.2.1).
+        if (isServer && serverMaxWindowBits < 15) {
+            extensionsOffer += "; server_max_window_bits=" + std::to_string(serverMaxWindowBits);
+        }
     }
 
     return extensionsOffer;

package/src/Extensions.h

@@ -18,8 +18,9 @@ template <bool isServer>
 class ExtensionsNegotiator {
 protected:
     int options;
+    int serverMaxWindowBits;
 public:
-    ExtensionsNegotiator(int wantedOptions);
+    ExtensionsNegotiator(int wantedOptions, int serverMaxWindowBits = 15);
     std::string generateOffer();
     void readOffer(std::string offer);
     int getNegotiatedOptions();

package/src/Group.cpp

@@ -114,7 +114,7 @@ void Group<isServer>::removeWebSocket(WebSocket<isServer> *webSocket) {
 }
 
 template <bool isServer>
-Group<isServer>::Group(int extensionOptions, unsigned int maxPayload, Hub *hub, cS::NodeData *nodeData) : cS::NodeData(*nodeData), maxPayload(maxPayload), hub(hub), extensionOptions(extensionOptions) {
+Group<isServer>::Group(int extensionOptions, unsigned int maxPayload, Hub *hub, cS::NodeData *nodeData, int deflateWindowBits, int deflateMemLevel, int deflateLevel) : cS::NodeData(*nodeData), maxPayload(maxPayload), hub(hub), extensionOptions(extensionOptions), deflateWindowBits(deflateWindowBits), deflateMemLevel(deflateMemLevel), deflateLevel(deflateLevel) {
     connectionHandler = [](WebSocket<isServer> *, HttpRequest) {};
     transferHandler = [](WebSocket<isServer> *) {};
     messageHandler = [](WebSocket<isServer> *, char *, size_t, OpCode) {};

package/src/Group.h

@@ -41,6 +41,9 @@ protected:
     unsigned int maxPayload;
     Hub *hub;
     int extensionOptions;
+    int deflateWindowBits = 15;
+    int deflateMemLevel = 8;
+    int deflateLevel = 1;
     cS::Timer *timer = nullptr, *httpTimer = nullptr;
     const char *userPingMessage;
     size_t userPingMessageLength;
@@ -61,7 +64,7 @@ protected:
     void addHttpSocket(HttpSocket<isServer> *httpSocket);
     void removeHttpSocket(HttpSocket<isServer> *httpSocket);
 
-    Group(int extensionOptions, unsigned int maxPayload, Hub *hub, cS::NodeData *nodeData);
+    Group(int extensionOptions, unsigned int maxPayload, Hub *hub, cS::NodeData *nodeData, int deflateWindowBits = 15, int deflateMemLevel = 8, int deflateLevel = 1);
     void stopListening();
 
 public:

package/src/HTTPSocket.cpp

@@ -210,7 +210,7 @@ void HttpSocket<isServer>::upgrade(const char *secKey, const char *extensions, s
         std::string extensionsResponse;
         if (extensionsLength) {
             Group<isServer> *group = Group<isServer>::from(this);
-            ExtensionsNegotiator<cWS::SERVER> extensionsNegotiator(group->extensionOptions);
+            ExtensionsNegotiator<cWS::SERVER> extensionsNegotiator(group->extensionOptions, group->deflateWindowBits);
             extensionsNegotiator.readOffer(std::string(extensions, extensionsLength));
             extensionsResponse = extensionsNegotiator.generateOffer();
             if (extensionsNegotiator.getNegotiatedOptions() & PERMESSAGE_DEFLATE) {
@@ -289,7 +289,7 @@ void HttpSocket<isServer>::onEnd(cS::Socket *s) {
         if (message->callback) {
             message->callback(nullptr, message->callbackData, true, nullptr);
         }
-        httpSocket->messageQueue.pop();
+        httpSocket->messageQueue.pop(httpSocket->nodeData);
     }
 
     while (httpSocket->outstandingResponsesHead) {

package/src/Hub.cpp

@@ -5,87 +5,22 @@
 
 namespace cWS {
 
-z_stream *Hub::allocateDefaultCompressor(z_stream *zStream) {
-    deflateInit2(zStream, 1, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
-    return zStream;
+// windowBits 9..15 and memLevel 1..9 select the per-socket memory tier (zlib uses
+// about 4x the window plus a 2^(memLevel+9) byte hash table): 15/8 = ~256 KB,
+// 12/5 = ~32 KB, 10/3 = ~8 KB, 9/2 = ~4 KB. Smaller tiers trade ratio for memory.
+// level 1..9: with zlib-ng level 1 is the very fast "quick" strategy (~8% worse
+// ratio than zlib level 1), level 2 matches zlib level 1's ratio at higher speed.
+zlib::Stream *Hub::allocateDefaultCompressor(int level, int windowBits, int memLevel) {
+    return zlib::createDeflate(level, windowBits, memLevel);
 }
 
-char *Hub::deflate(char *data, size_t &length, z_stream *slidingDeflateWindow) {
-    dynamicZlibBuffer.clear();
-
-    z_stream *compressor = slidingDeflateWindow ? slidingDeflateWindow : &deflationStream;
-
-    compressor->next_in = (Bytef *) data;
-    compressor->avail_in = (unsigned int) length;
-
-    // note: zlib requires more than 6 bytes with Z_SYNC_FLUSH
-    const int DEFLATE_OUTPUT_CHUNK = LARGE_BUFFER_SIZE;
-
-    int err;
-    do {
-        compressor->next_out = (Bytef *) zlibBuffer;
-        compressor->avail_out = DEFLATE_OUTPUT_CHUNK;
-
-        err = ::deflate(compressor, Z_SYNC_FLUSH);
-        if (Z_OK == err && compressor->avail_out == 0) {
-            dynamicZlibBuffer.append(zlibBuffer, DEFLATE_OUTPUT_CHUNK - compressor->avail_out);
-            continue;
-        } else {
-            break;
-        }
-    } while (true);
-
-    // note: should not change avail_out
-    if (!slidingDeflateWindow) {
-        deflateReset(compressor);
-    }
-
-    if (dynamicZlibBuffer.length()) {
-        dynamicZlibBuffer.append(zlibBuffer, DEFLATE_OUTPUT_CHUNK - compressor->avail_out);
-
-        length = dynamicZlibBuffer.length() - 4;
-        return (char *) dynamicZlibBuffer.data();
-    }
-
-    length = DEFLATE_OUTPUT_CHUNK - compressor->avail_out - 4;
-    return zlibBuffer;
+char *Hub::deflate(char *data, size_t &length, zlib::Stream *slidingDeflateWindow) {
+    zlib::Stream *compressor = slidingDeflateWindow ? slidingDeflateWindow : deflationStream;
+    return zlib::deflate(compressor, data, length, zlibBuffer, LARGE_BUFFER_SIZE, dynamicZlibBuffer, !slidingDeflateWindow);
 }
 
-// todo: let's go through this code once more some time!
 char *Hub::inflate(char *data, size_t &length, size_t maxPayload) {
-    dynamicZlibBuffer.clear();
-
-    inflationStream.next_in = (Bytef *) data;
-    inflationStream.avail_in = (unsigned int) length;
-
-    int err;
-    do {
-        inflationStream.next_out = (Bytef *) zlibBuffer;
-        inflationStream.avail_out = LARGE_BUFFER_SIZE;
-        err = ::inflate(&inflationStream, Z_FINISH);
-        if (!inflationStream.avail_in) {
-            break;
-        }
-
-        dynamicZlibBuffer.append(zlibBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out);
-    } while (err == Z_BUF_ERROR && dynamicZlibBuffer.length() <= maxPayload);
-
-    inflateReset(&inflationStream);
-
-    if ((err != Z_BUF_ERROR && err != Z_OK) || dynamicZlibBuffer.length() > maxPayload) {
-        length = 0;
-        return nullptr;
-    }
-
-    if (dynamicZlibBuffer.length()) {
-        dynamicZlibBuffer.append(zlibBuffer, LARGE_BUFFER_SIZE - inflationStream.avail_out);
-
-        length = dynamicZlibBuffer.length();
-        return (char *) dynamicZlibBuffer.data();
-    }
-
-    length = LARGE_BUFFER_SIZE - inflationStream.avail_out;
-    return zlibBuffer;
+    return zlib::inflate(inflationStream, data, length, maxPayload, zlibBuffer, LARGE_BUFFER_SIZE, dynamicZlibBuffer);
 }
 
 void Hub::onServerAccept(cS::Socket *s) {

package/src/Hub.h

@@ -4,7 +4,7 @@
 #include "Group.h"
 #include "cSNode.h"
 #include <string>
-#include <zlib.h>
+#include "Zlib.h"
 #include <mutex>
 #include <map>
 
@@ -18,10 +18,10 @@ protected:
         Group<CLIENT> *group;
     };
 
-    static z_stream *allocateDefaultCompressor(z_stream *zStream);
+    static zlib::Stream *allocateDefaultCompressor(int level = 1, int windowBits = 15, int memLevel = 8);
 
-    z_stream inflationStream = {}, deflationStream = {};
-    char *deflate(char *data, size_t &length, z_stream *slidingDeflateWindow);
+    zlib::Stream *inflationStream = nullptr, *deflationStream = nullptr;
+    char *deflate(char *data, size_t &length, zlib::Stream *slidingDeflateWindow);
     char *inflate(char *data, size_t &length, size_t maxPayload);
     char *zlibBuffer;
     std::string dynamicZlibBuffer;
@@ -32,8 +32,8 @@ protected:
 
 public:
     template <bool isServer>
-    Group<isServer> *createGroup(int extensionOptions = 0, unsigned int maxPayload = 16777216) {
-        return new Group<isServer>(extensionOptions, maxPayload, this, nodeData);
+    Group<isServer> *createGroup(int extensionOptions = 0, unsigned int maxPayload = 16777216, int deflateWindowBits = 15, int deflateMemLevel = 8, int deflateLevel = 1) {
+        return new Group<isServer>(extensionOptions, maxPayload, this, nodeData, deflateWindowBits, deflateMemLevel, deflateLevel);
     }
 
     template <bool isServer>
@@ -48,10 +48,11 @@ public:
 
     Hub(int extensionOptions = 0, bool useDefaultLoop = false, unsigned int maxPayload = 16777216) : cS::Node(LARGE_BUFFER_SIZE, WebSocketProtocol<SERVER, WebSocket<SERVER>>::CONSUME_PRE_PADDING, WebSocketProtocol<SERVER, WebSocket<SERVER>>::CONSUME_POST_PADDING, useDefaultLoop),
                                              Group<SERVER>(extensionOptions, maxPayload, this, nodeData), Group<CLIENT>(0, maxPayload, this, nodeData) {
-        inflateInit2(&inflationStream, -15);
+        inflationStream = zlib::createInflate(15);
         zlibBuffer = new char[LARGE_BUFFER_SIZE];
 
-        allocateDefaultCompressor(&deflationStream);
+        // shared compressor for groups without a per-socket sliding window
+        deflationStream = allocateDefaultCompressor();
 
 #ifdef CWS_THREADSAFE
         getLoop()->preCbData = nodeData;
@@ -67,8 +68,8 @@ public:
     }
 
     ~Hub() {
-        inflateEnd(&inflationStream);
-        deflateEnd(&deflationStream);
+        zlib::destroy(inflationStream);
+        zlib::destroy(deflationStream);
         delete [] zlibBuffer;
     }
 

package/src/Socket.h

@@ -50,20 +50,32 @@ protected:
             Message *nextMessage = nullptr;
             void (*callback)(void *socket, void *data, bool cancelled, void *reserved) = nullptr;
             void *callbackData = nullptr, *reserved = nullptr;
+            // >= 0: block came from NodeData's small-block pool (index for freeSmallMemoryBlock);
+            // -1: heap (new char[]). Messages are allocated as raw char arrays, so every
+            // allocation site must set this explicitly (the initializers above never run).
+            int poolIndex = -1;
         };
 
         Message *head = nullptr, *tail = nullptr;
         size_t totalLength = 0;
 
-        void pop()
+        static void release(NodeData *nodeData, Message *message) {
+            if (message->poolIndex >= 0) {
+                nodeData->freeSmallMemoryBlock((char *) message, message->poolIndex);
+            } else {
+                delete [] (char *) message;
+            }
+        }
+
+        void pop(NodeData *nodeData)
         {
             Message *nextMessage;
             if ((nextMessage = head->nextMessage)) {
                 totalLength -= head->length;
-                delete [] (char *) head;
+                release(nodeData, head);
                 head = nextMessage;
             } else {
-                delete [] (char *) head;
+                release(nodeData, head);
                 head = tail = nullptr;
                 totalLength = 0;
             }
@@ -174,7 +186,7 @@ protected:
                     // which frees the queue (use-after-free otherwise).
                     auto callback = messagePtr->callback;
                     void *callbackData = messagePtr->callbackData, *reserved = messagePtr->reserved;
-                    socket->messageQueue.pop();
+                    socket->messageQueue.pop(socket->nodeData);
                     if (callback) {
                         callback(p, callbackData, false, reserved);
                         if (socket->isClosed()) {
@@ -256,7 +268,7 @@ protected:
                         // which frees the queue (use-after-free otherwise).
                         auto callback = messagePtr->callback;
                         void *callbackData = messagePtr->callbackData, *reserved = messagePtr->reserved;
-                        socket->messageQueue.pop();
+                        socket->messageQueue.pop(socket->nodeData);
                         if (callback) {
                             callback(p, callbackData, false, reserved);
                             if (socket->isClosed()) {
@@ -318,6 +330,10 @@ protected:
         messagePtr->length = length;
         messagePtr->data = ((char *) messagePtr) + sizeof(Queue::Message);
         messagePtr->nextMessage = nullptr;
+        messagePtr->callback = nullptr;
+        messagePtr->callbackData = nullptr;
+        messagePtr->reserved = nullptr;
+        messagePtr->poolIndex = -1;
 
         if (data) {
             memcpy((char *) messagePtr->data, data, messagePtr->length);
@@ -385,10 +401,21 @@ protected:
         if (corkActive()) {
             // Frame now, write later: everything sent to this socket during the
             // current loop iteration goes out in one gathered write (uncork()).
-            Queue::Message *messagePtr = allocMessage(estimatedLength - sizeof(Queue::Message));
+            // Small messages come from the per-loop block pool (pop() returns them).
+            Queue::Message *messagePtr;
+            if (estimatedLength <= cS::NodeData::preAllocMaxSize) {
+                int memoryIndex = nodeData->getMemoryBlockIndex((int) estimatedLength);
+                messagePtr = (Queue::Message *) nodeData->getSmallMemoryBlock(memoryIndex);
+                messagePtr->data = ((char *) messagePtr) + sizeof(Queue::Message);
+                messagePtr->poolIndex = memoryIndex;
+            } else {
+                messagePtr = allocMessage(estimatedLength - sizeof(Queue::Message));
+            }
             messagePtr->length = T::transform(message, (char *) messagePtr->data, length, transformData);
+            messagePtr->nextMessage = nullptr;
             messagePtr->callback = callback;
             messagePtr->callbackData = callbackData;
+            messagePtr->reserved = nullptr;
             enqueue(messagePtr);
             if (!corkPending) {
                 corkPending = true;
@@ -405,6 +432,9 @@ protected:
                 Queue::Message *messagePtr = (Queue::Message *) nodeData->getSmallMemoryBlock(memoryIndex);
                 messagePtr->data = ((char *) messagePtr) + sizeof(Queue::Message);
                 messagePtr->length = T::transform(message, (char *) messagePtr->data, length, transformData);
+                messagePtr->nextMessage = nullptr;
+                messagePtr->reserved = nullptr;
+                messagePtr->poolIndex = memoryIndex;
 
                 bool wasTransferred;
                 if (write(messagePtr, wasTransferred)) {
@@ -589,7 +619,7 @@ public:
                 if (callbacks && m->callback) {
                     callbacks->push_back({m->callback, m->callbackData, m->reserved});
                 }
-                messageQueue.pop();
+                messageQueue.pop(nodeData);
             } else {
                 m->length -= sent;
                 m->data += sent;

package/src/WebSocket.cpp

@@ -11,7 +11,8 @@ WebSocket<isServer>::WebSocket(bool perMessageDeflate, cS::Socket *socket) : cS:
 
     // if we are created in a group with sliding deflate window allocate it here
     if (Group<isServer>::from(this)->extensionOptions & SLIDING_DEFLATE_WINDOW) {
-        slidingDeflateWindow = Hub::allocateDefaultCompressor(new z_stream{});
+        Group<isServer> *group = Group<isServer>::from(this);
+        slidingDeflateWindow = Hub::allocateDefaultCompressor(group->deflateLevel, group->deflateWindowBits, group->deflateMemLevel);
     }
 }
 
@@ -52,7 +53,7 @@ void WebSocket<isServer>::send(const char *message, size_t length, OpCode opCode
 
         static size_t transform(const char *src, char *dst, size_t length, TransformData transformData) {
             if (transformData.compress) {
-                char *deflated = Group<isServer>::from(transformData.s)->hub->deflate((char *) src, length, (z_stream *) transformData.s->slidingDeflateWindow);
+                char *deflated = Group<isServer>::from(transformData.s)->hub->deflate((char *) src, length, (zlib::Stream *) transformData.s->slidingDeflateWindow);
                 return WebSocketProtocol<isServer, WebSocket<isServer>>::formatMessage(dst, deflated, length, transformData.opCode, length, true);
             }
 
@@ -150,6 +151,9 @@ void WebSocket<isServer>::sendPrepared(typename WebSocket<isServer>::PreparedMes
     Queue::Message *messagePtr = (Queue::Message *) nodeData->getSmallMemoryBlock(memoryIndex);
     messagePtr->data = preparedMessage->buffer;
     messagePtr->length = preparedMessage->length;
+    messagePtr->nextMessage = nullptr;
+    messagePtr->reserved = nullptr;
+    messagePtr->poolIndex = memoryIndex;
 
     bool wasTransferred;
     if (write(messagePtr, wasTransferred)) {
@@ -194,9 +198,15 @@ cS::Socket *WebSocket<isServer>::onData(cS::Socket *s, char *data, size_t length
 
     webSocket->hasOutstandingPong = false;
     if (!webSocket->isShuttingDown()) {
-        webSocket->cork(true);
+        // The kernel-level cork (TCP_CORK/TCP_NOPUSH) around a read only helps when
+        // replies are written immediately; with write corking they leave in one gathered
+        // write at the end of the tick, so skip the two setsockopt calls per read.
+        bool kernelCork = !webSocket->corkActive();
+        if (kernelCork) {
+            webSocket->cork(true);
+        }
         WebSocketProtocol<isServer, WebSocket<isServer>>::consume(data, (unsigned int) length, webSocket);
-        if (!webSocket->isClosed()) {
+        if (kernelCork && !webSocket->isClosed()) {
             webSocket->cork(false);
         }
     }
@@ -305,7 +315,7 @@ void WebSocket<isServer>::onEnd(cS::Socket *s) {
         if (message->callback) {
             message->callback(nullptr, message->callbackData, true, nullptr);
         }
-        webSocket->messageQueue.pop();
+        webSocket->messageQueue.pop(webSocket->nodeData);
     }
 
     webSocket->nodeData->clearPendingPollChanges(webSocket);
@@ -313,8 +323,7 @@ void WebSocket<isServer>::onEnd(cS::Socket *s) {
     // remove any per-websocket zlib memory
     if (webSocket->slidingDeflateWindow) {
         // this relates to Hub::allocateDefaultCompressor
-        deflateEnd((z_stream *) webSocket->slidingDeflateWindow);
-        delete (z_stream *) webSocket->slidingDeflateWindow;
+        zlib::destroy((zlib::Stream *) webSocket->slidingDeflateWindow);
         webSocket->slidingDeflateWindow = nullptr;
     }
 }

package/src/Zlib.cpp

@@ -0,0 +1,141 @@
+#include "Zlib.h"
+
+#ifdef CWS_ZLIB_NG
+#include "zlib-ng.h"
+typedef zng_stream ZStream;
+#define ZFN(name) zng_##name
+#define CWS_ZLIB_BACKEND "zlib-ng " ZLIBNG_VERSION
+#else
+#include <zlib.h>
+typedef z_stream ZStream;
+#define ZFN(name) name
+#define CWS_ZLIB_BACKEND "zlib " ZLIB_VERSION
+#endif
+
+namespace cWS {
+namespace zlib {
+
+struct Stream {
+    ZStream zs;
+    bool isDeflate;
+};
+
+typedef decltype(ZStream::next_in) InPtr;
+typedef decltype(ZStream::next_out) OutPtr;
+
+Stream *createDeflate(int level, int windowBits, int memLevel) {
+    Stream *stream = new Stream();
+    stream->isDeflate = true;
+    ZFN(deflateInit2)(&stream->zs, level, Z_DEFLATED, -windowBits, memLevel, Z_DEFAULT_STRATEGY);
+    return stream;
+}
+
+Stream *createInflate(int windowBits) {
+    Stream *stream = new Stream();
+    stream->isDeflate = false;
+    ZFN(inflateInit2)(&stream->zs, -windowBits);
+    return stream;
+}
+
+void reset(Stream *stream) {
+    if (stream->isDeflate) {
+        ZFN(deflateReset)(&stream->zs);
+    } else {
+        ZFN(inflateReset)(&stream->zs);
+    }
+}
+
+void destroy(Stream *stream) {
+    if (!stream) {
+        return;
+    }
+    if (stream->isDeflate) {
+        ZFN(deflateEnd)(&stream->zs);
+    } else {
+        ZFN(inflateEnd)(&stream->zs);
+    }
+    delete stream;
+}
+
+char *deflate(Stream *stream, char *data, size_t &length, char *buffer, size_t bufferSize, std::string &dynamic, bool resetAfter) {
+    ZStream &zs = stream->zs;
+    dynamic.clear();
+
+    zs.next_in = (InPtr) data;
+    zs.avail_in = (unsigned int) length;
+
+    // note: zlib requires more than 6 bytes of output space with Z_SYNC_FLUSH
+    int err;
+    do {
+        zs.next_out = (OutPtr) buffer;
+        zs.avail_out = (unsigned int) bufferSize;
+
+        err = ZFN(deflate)(&zs, Z_SYNC_FLUSH);
+        if (Z_OK == err && zs.avail_out == 0) {
+            dynamic.append(buffer, bufferSize - zs.avail_out);
+            continue;
+        } else {
+            break;
+        }
+    } while (true);
+
+    // note: must not change avail_out
+    if (resetAfter) {
+        ZFN(deflateReset)(&zs);
+    }
+
+    if (dynamic.length()) {
+        dynamic.append(buffer, bufferSize - zs.avail_out);
+        length = dynamic.length() - 4;
+        return (char *) dynamic.data();
+    }
+
+    length = bufferSize - zs.avail_out - 4;
+    return buffer;
+}
+
+char *inflate(Stream *stream, char *data, size_t &length, size_t maxPayload, char *buffer, size_t bufferSize, std::string &dynamic) {
+    ZStream &zs = stream->zs;
+    dynamic.clear();
+
+    zs.next_in = (InPtr) data;
+    zs.avail_in = (unsigned int) length;
+
+    int err;
+    do {
+        zs.next_out = (OutPtr) buffer;
+        zs.avail_out = (unsigned int) bufferSize;
+        err = ZFN(inflate)(&zs, Z_FINISH);
+        // Z_STREAM_END: the sender ended the message with a BFINAL=1 block, which
+        // RFC 7692 section 7.2.3.4 permits (libdeflate and some non-zlib clients do
+        // this); anything left in the input is the 4-byte tail and is ignored.
+        if (!zs.avail_in || err == Z_STREAM_END) {
+            break;
+        }
+
+        dynamic.append(buffer, bufferSize - zs.avail_out);
+    } while (err == Z_BUF_ERROR && dynamic.length() <= maxPayload);
+
+    ZFN(inflateReset)(&zs);
+
+    if ((err != Z_BUF_ERROR && err != Z_OK && err != Z_STREAM_END) || dynamic.length() > maxPayload) {
+        length = 0;
+        return nullptr;
+    }
+
+    if (dynamic.length()) {
+        dynamic.append(buffer, bufferSize - zs.avail_out);
+        length = dynamic.length();
+        return (char *) dynamic.data();
+    }
+
+    length = bufferSize - zs.avail_out;
+    return buffer;
+}
+
+const char *backend() {
+    return CWS_ZLIB_BACKEND;
+}
+
+}
+}

package/src/Zlib.h

@@ -0,0 +1,38 @@
+#ifndef CWS_ZLIB_H
+#define CWS_ZLIB_H
+
+#include <cstddef>
+#include <string>
+
+// Thin backend-neutral wrapper around the DEFLATE library. Built with
+// -DCWS_ZLIB_NG (the prebuilt bindings) it uses the vendored zlib-ng through
+// its native zng_ API, so nothing collides with the zlib inside Node; without
+// the define (node-gyp fallback) it uses zlib.h from the Node headers. Zlib.cpp
+// is the only translation unit that includes either header.
+namespace cWS {
+namespace zlib {
+
+struct Stream;
+
+Stream *createDeflate(int level, int windowBits, int memLevel);
+Stream *createInflate(int windowBits = 15);
+void reset(Stream *stream);
+void destroy(Stream *stream);
+
+// Deflates one message with a sync flush. Output lands in `buffer` (bufferSize
+// bytes) or, when it does not fit, is accumulated in `dynamic`. Returns the output
+// pointer and sets `length` to its size minus the 4-byte sync-flush tail
+// (RFC 7692). With `resetAfter` the stream forgets the message (no context takeover).
+char *deflate(Stream *stream, char *data, size_t &length, char *buffer, size_t bufferSize, std::string &dynamic, bool resetAfter);
+
+// Inflates one message (the 4-byte tail must already be appended). Returns nullptr
+// and length 0 on error or when the output would exceed maxPayload. Always resets.
+char *inflate(Stream *stream, char *data, size_t &length, size_t maxPayload, char *buffer, size_t bufferSize, std::string &dynamic);
+
+// e.g. "zlib-ng 2.2.4" or "zlib 1.3.1"
+const char *backend();
+
+}
+}
+
+#endif // CWS_ZLIB_H