@encharm/cws 4.8.4 → 4.11.0

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { WebSocketServer } from './server';
 import { SocketAddress, ServerConfigs } from './index';
+import { PreparedMessage } from './prepared';
 export declare class WebSocket {
     url: string;
     private options;
@@ -28,9 +29,10 @@ export declare class WebSocket {
     on(event: 'error', listener: (err: Error) => void): void;
     on(event: 'message', listener: (message: string | any) => void): void;
     on(event: 'close', listener: (code?: number, reason?: string) => void): void;
-    send(message: string | Buffer, options?: {
+    send(message: string | Buffer | ArrayBufferView | PreparedMessage, options?: {
         binary?: boolean;
         compress?: boolean;
+        prefix?: string | Buffer | ArrayBufferView;
     }, cb?: (err?: Error) => void): void;
     ping(message?: string | Buffer): void;
     close(code?: number, reason?: string): void;

package/dist/client.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocket = void 0;
 const server_1 = require("./server");
 const shared_1 = require("./shared");
+const prepared_1 = require("./prepared");
 const clientGroup = shared_1.native.client.group.create(0, shared_1.DEFAULT_PAYLOAD_LIMIT);
 function messageByteLength(message) {
     if (typeof message === 'string') {
@@ -78,6 +79,7 @@ class WebSocket {
     }
     send(message, options, cb) {
         if (this.external) {
+            const prepared = message instanceof prepared_1.PreparedMessage;
             let opCode = typeof message === 'string' ? shared_1.OPCODE_TEXT : shared_1.OPCODE_BINARY;
             if (options && options.binary === false) {
                 opCode = shared_1.OPCODE_TEXT;
@@ -90,9 +92,15 @@ class WebSocket {
                 compress = !!options.compress;
             }
             else if (this.compressThreshold !== undefined) {
-                compress = messageByteLength(message) >= this.compressThreshold;
+                compress = messageByteLength(message) + (options && options.prefix ? messageByteLength(options.prefix) : 0) >= this.compressThreshold;
+            }
+            const callback = cb ? () => process.nextTick(cb) : null;
+            if (prepared) {
+                this.nativeApi.sendShared(this.external, options && options.prefix, message.external, opCode, callback, compress);
+            }
+            else {
+                this.nativeApi.send(this.external, message, opCode, callback, compress);
             }
-            this.nativeApi.send(this.external, message, opCode, cb ? () => process.nextTick(cb) : null, compress);
         }
         else if (cb) {
             cb(new Error('Socket not connected'));

package/dist/index.d.ts

@@ -30,6 +30,7 @@ export declare type ServerConfigs = {
     verifyClient?: (info: ConnectionInfo, next: VerifyClientNext) => void;
 };
 export { WebSocket } from './client';
+export { PreparedMessage } from './prepared';
 export { WebSocketServer } from './server';
 export declare const secureProtocol: string;
-export { zlibBackend } from './shared';
+export { zlibBackend, sendThread } from './shared';

package/dist/index.js

@@ -3,8 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.secureProtocol = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "WebSocket", { enumerable: true, get: function () { return client_1.WebSocket; } });
+var prepared_1 = require("./prepared");
+Object.defineProperty(exports, "PreparedMessage", { enumerable: true, get: function () { return prepared_1.PreparedMessage; } });
 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; } });
+Object.defineProperty(exports, "sendThread", { enumerable: true, get: function () { return shared_1.sendThread; } });

package/dist/prepared.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare class PreparedMessage {
+    readonly byteLength: number;
+    readonly external: any;
+    constructor(data: Buffer | ArrayBufferView | ArrayBuffer);
+}

package/dist/prepared.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreparedMessage = void 0;
+const shared_1 = require("./shared");
+const preparedRegistry = typeof global.FinalizationRegistry === 'function'
+    ? new global.FinalizationRegistry((external) => shared_1.native.server.releaseShared(external))
+    : undefined;
+class PreparedMessage {
+    constructor(data) {
+        this.byteLength = data.byteLength;
+        this.external = shared_1.native.server.prepareShared(data);
+        if (preparedRegistry) {
+            preparedRegistry.register(this, this.external);
+        }
+    }
+}
+exports.PreparedMessage = PreparedMessage;

package/dist/shared.d.ts

@@ -10,4 +10,5 @@ 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 const sendThread: 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.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;
+exports.setupNative = exports.sendThread = 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;
@@ -20,6 +20,7 @@ exports.native = (() => {
     }
 })();
 exports.zlibBackend = exports.native.zlibBackend;
+exports.sendThread = exports.native.sendThread;
 function setupNative(group, type, wsServer) {
     exports.native.setNoop(exports.noop);
     exports.native[type].group.onConnection(group, (external) => {

package/package.json

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

package/src/Addon.cpp

@@ -24,6 +24,8 @@ void Initialize(Local<Object> exports) {
                String::NewFromUtf8(isolate, cWS::zlib::backend()).ToLocalChecked()).Check();
   hub.getNodeData()->corkState->enabled = corkEnabledFromEnv();
   registerCheck(isolate);
+  exports->Set(isolate->GetCurrentContext(), String::NewFromUtf8(isolate, "sendThread").ToLocalChecked(),
+               String::NewFromUtf8(isolate, cS::SendWorker::status()).ToLocalChecked()).Check();
 }
 
 NODE_MODULE(addon, Initialize)

package/src/Addon.h

@@ -6,6 +6,7 @@
 #include <openssl/ssl.h>
 #include <uv.h>
 #include <cstring>
+#include "SendWorker.h"
 
 #define NODE_WANT_INTERNALS 1
 
@@ -97,6 +98,11 @@ void registerCheck(Isolate *isolate) {
   });
   uv_unref((uv_handle_t *)&check);
 
+  // Send worker thread: only meaningful with corking, whose end-of-tick flush feeds it.
+  if (hub.getNodeData()->corkState->enabled) {
+    cS::SendWorker::init((uv_loop_t *)hub.getLoop());
+  }
+
   uv_prepare_init((uv_loop_t *)hub.getLoop(), &corkPrepare);
   uv_prepare_start(&corkPrepare, [](uv_prepare_t *) {
     cS::Socket::flushCorked(hub.getNodeData());
@@ -638,6 +644,44 @@ void sendPrepared(const FunctionCallbackInfo<Value> &args) {
               ->Value());
 }
 
+template <bool isServer>
+void prepareShared(const FunctionCallbackInfo<Value> &args) {
+  NativeString nativeString(args.GetIsolate(), args[0]);
+  args.GetReturnValue().Set(External::New(
+      args.GetIsolate(),
+      cWS::WebSocket<isServer>::prepareShared(nativeString.getData(),
+                                              nativeString.getLength())));
+}
+
+template <bool isServer>
+void releaseShared(const FunctionCallbackInfo<Value> &args) {
+  cWS::SharedPayload::unref(
+      (cWS::SharedPayload *)args[0].As<External>()->Value());
+}
+
+// (socket, prefix, payload, opCode, callback, compress)
+template <bool isServer>
+void sendShared(const FunctionCallbackInfo<Value> &args) {
+  NativeString prefix(args.GetIsolate(), args[1]);
+  cWS::SharedPayload *payload =
+      (cWS::SharedPayload *)args[2].As<External>()->Value();
+  cWS::OpCode opCode = (cWS::OpCode)args[3].As<Integer>()->Value();
+
+  SendCallbackData *sc = nullptr;
+  void (*callback)(cWS::WebSocket<isServer> *, void *, bool, void *) = nullptr;
+  if (args[4]->IsFunction()) {
+    callback = sendCallback;
+    sc = new SendCallbackData;
+    sc->jsCallback.Reset(args.GetIsolate(), Local<Function>::Cast(args[4]));
+    sc->isolate = args.GetIsolate();
+  }
+  bool compress = args[5].As<Boolean>()->Value();
+
+  unwrapSocket<isServer>(args[0].As<External>())
+      ->sendShared(prefix.getData(), prefix.getLength(), payload, opCode,
+                   compress, callback, sc);
+}
+
 template <bool isServer>
 void finalizeMessage(const FunctionCallbackInfo<Value> &args) {
   cWS::WebSocket<isServer>::finalizeMessage(
@@ -717,6 +761,9 @@ struct Namespace {
     NODE_SET_METHOD(object, "prepareMessage", prepareMessage<isServer>);
     NODE_SET_METHOD(object, "sendPrepared", sendPrepared<isServer>);
     NODE_SET_METHOD(object, "finalizeMessage", finalizeMessage<isServer>);
+    NODE_SET_METHOD(object, "prepareShared", prepareShared<isServer>);
+    NODE_SET_METHOD(object, "sendShared", sendShared<isServer>);
+    NODE_SET_METHOD(object, "releaseShared", releaseShared<isServer>);
 
     Local<Object> group = Object::New(isolate);
     NODE_SET_METHOD(group, "onConnection", onConnection<isServer>);

package/src/Hub.cpp

@@ -15,8 +15,10 @@ zlib::Stream *Hub::allocateDefaultCompressor(int level, int windowBits, int memL
 }
 
 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);
+    if (!slidingDeflateWindow) {
+        return zlib::deflateIndependent(deflationStream, data, length, zlibBuffer, LARGE_BUFFER_SIZE, dynamicZlibBuffer);
+    }
+    return zlib::deflate(slidingDeflateWindow, data, length, zlibBuffer, LARGE_BUFFER_SIZE, dynamicZlibBuffer, false);
 }
 
 char *Hub::inflate(char *data, size_t &length, size_t maxPayload) {

package/src/MicroDeflate.h

@@ -0,0 +1,109 @@
+#ifndef CWS_MICRODEFLATE_H
+#define CWS_MICRODEFLATE_H
+
+// Minimal raw-DEFLATE encoder for independent messages (permessage-deflate without
+// context takeover, i.e. the shared-compressor mode). One fixed-Huffman block, greedy
+// LZ77 over a 4-byte hash, no lazy matching, no stream state, and no per-message table
+// clearing: stale entries are validated by position and content. Output ends the way
+// Z_SYNC_FLUSH ends (empty stored block); the returned length already excludes the
+// trailing 00 00 ff ff, as RFC 7692 requires. Measured on a real BSON RPC stream: same
+// ratio as zlib-ng level 1 at ~1.7x its speed, mostly by skipping the 64 KB hash reset
+// zlib performs per message. Decodes with any inflater.
+//
+// Not for context takeover: matches never reference earlier messages.
+
+#include <cstdint>
+#include <cstring>
+#include <cstddef>
+
+namespace cWS {
+namespace microdeflate {
+
+// Worst case output for `length` input bytes (all literals at 9 bits + block overhead).
+inline size_t bound(size_t length) {
+    return length + length / 8 + 32;
+}
+
+class Encoder {
+    static const int HASH_BITS = 13;
+    uint32_t table[1 << HASH_BITS];
+
+    static const uint16_t *lenBase() { static const uint16_t t[29] = {3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258}; return t; }
+    static const uint8_t *lenExtra() { static const uint8_t t[29] = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; return t; }
+    static const uint16_t *distBase() { static const uint16_t t[30] = {1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577}; return t; }
+    static const uint8_t *distExtra() { static const uint8_t t[30] = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; return t; }
+
+    struct Tables {
+        uint16_t litCode[288]; uint8_t litBits[288];
+        uint8_t lenCode[259];
+        uint8_t distCode[32769];
+        uint8_t distCodeRev[30];
+        static uint32_t rev(uint32_t v, int n) { uint32_t r = 0; for (int i = 0; i < n; i++) { r = (r << 1) | (v & 1); v >>= 1; } return r; }
+        Tables() {
+            for (int i = 0; i < 288; i++) {
+                int bits, code;
+                if (i < 144) { bits = 8; code = 0x30 + i; }
+                else if (i < 256) { bits = 9; code = 0x190 + (i - 144); }
+                else if (i < 280) { bits = 7; code = i - 256; }
+                else { bits = 8; code = 0xC0 + (i - 280); }
+                litCode[i] = (uint16_t) rev(code, bits); litBits[i] = (uint8_t) bits;
+            }
+            for (int c = 0; c < 29; c++) for (int l = lenBase()[c]; l < (c < 28 ? lenBase()[c + 1] : 259); l++) lenCode[l] = (uint8_t) c;
+            for (int c = 0; c < 30; c++) { for (int d = distBase()[c]; d < (c < 29 ? distBase()[c + 1] : 32769); d++) distCode[d] = (uint8_t) c; distCodeRev[c] = (uint8_t) rev(c, 5); }
+        }
+    };
+    static const Tables &tables() { static const Tables t; return t; }
+
+    struct BitWriter {
+        uint8_t *out; size_t pos = 0; uint64_t acc = 0; int n = 0;
+        inline void put(uint32_t v, int bits) { acc |= (uint64_t) v << n; n += bits; while (n >= 8) { out[pos++] = (uint8_t) acc; acc >>= 8; n -= 8; } }
+        inline void flushByte() { if (n) { out[pos++] = (uint8_t) acc; acc = 0; n = 0; } }
+    };
+
+    static inline uint32_t hash4(const uint8_t *p) { uint32_t v; memcpy(&v, p, 4); return (v * 2654435761u) >> (32 - HASH_BITS); }
+
+public:
+    Encoder() { memset(table, 0xff, sizeof(table)); tables(); }
+
+    // `out` must have room for bound(length) bytes. Returns the compressed length
+    // (without the 4-byte sync-flush tail).
+    size_t compress(const uint8_t *in, size_t length, uint8_t *out) {
+        const Tables &t = tables();
+        BitWriter w{out};
+        w.put(0, 1); w.put(1, 2);                          // BFINAL=0, BTYPE=01 (fixed Huffman)
+        size_t i = 0;
+        const size_t limit = length >= 4 ? length - 4 : 0;
+        while (i < limit) {
+            uint32_t h = hash4(in + i);
+            uint32_t cand = table[h];
+            table[h] = (uint32_t) i;
+            if (cand < i && i - cand <= 32768 && memcmp(in + cand, in + i, 4) == 0) {
+                size_t maxLen = length - i; if (maxLen > 258) maxLen = 258;
+                size_t m = 4;
+                while (m < maxLen && in[cand + m] == in[i + m]) m++;
+                uint32_t dist = (uint32_t) (i - cand);
+                int lc = t.lenCode[m];
+                w.put(t.litCode[257 + lc], t.litBits[257 + lc]);
+                if (lenExtra()[lc]) w.put((uint32_t) (m - lenBase()[lc]), lenExtra()[lc]);
+                int dc = t.distCode[dist];
+                w.put(t.distCodeRev[dc], 5);
+                if (distExtra()[dc]) w.put(dist - distBase()[dc], distExtra()[dc]);
+                if (i + 1 < limit) table[hash4(in + i + 1)] = (uint32_t) (i + 1);
+                i += m;
+            } else {
+                w.put(t.litCode[in[i]], t.litBits[in[i]]);
+                i++;
+            }
+        }
+        for (; i < length; i++) w.put(t.litCode[in[i]], t.litBits[in[i]]);
+        w.put(t.litCode[256], t.litBits[256]);             // end of block
+        w.put(0, 1); w.put(0, 2); w.flushByte();           // empty stored block: BFINAL=0, BTYPE=00, then byte-align
+        out[w.pos++] = 0; out[w.pos++] = 0; out[w.pos++] = 0xff; out[w.pos++] = 0xff;
+        return w.pos - 4;
+    }
+};
+
+}
+}
+
+#endif // CWS_MICRODEFLATE_H

package/src/Networking.h

@@ -34,8 +34,11 @@
 #define be64toh(x) __builtin_bswap64(x)
 #else
 #define __thread __declspec(thread)
-#define htobe64(x) htonll(x)
-#define be64toh(x) ntohll(x)
+// Windows is little-endian; the intrinsic avoids depending on WinSock's htonll/ntohll,
+// whose declaration depends on SDK version macros that not every translation unit sets.
+#include <stdlib.h>
+#define htobe64(x) _byteswap_uint64(x)
+#define be64toh(x) _byteswap_uint64(x)
 #define pthread_t DWORD
 #define pthread_self GetCurrentThreadId
 #endif

package/src/SendWorker.cpp

@@ -0,0 +1,229 @@
+#include "SendWorker.h"
+#include "Socket.h"
+#include "Zlib.h"
+#include "cWS.h"
+#include "readerwriterqueue.h"
+#include <thread>
+#include <cstdlib>
+#include <cstring>
+#include <cerrno>
+#include <cctype>
+#include <string>
+
+namespace cS {
+
+namespace {
+    bool workerActive = false;
+    const char *workerStatus = "not initialised";
+    moodycamel::BlockingReaderWriterQueue<Socket::SendOp *> *toWorker = nullptr;
+    moodycamel::ReaderWriterQueue<Socket::SendOp *> *toMain = nullptr;
+    uv_async_t mainWake;
+
+    void onMainWake(uv_async_t *) {
+        Socket::SendOp *op;
+        while (toMain->try_dequeue(op)) {
+            Socket::sendComplete(op);
+        }
+    }
+
+    void workerLoop() {
+        Socket::SendOp *op;
+        for (;;) {
+            toWorker->wait_dequeue(op);
+            Socket::performSend(op);
+            toMain->enqueue(op);
+            uv_async_send(&mainWake);
+        }
+    }
+}
+
+bool SendWorker::init(uv_loop_t *loop) {
+    const char *disabled = getenv("CWS_SEND_THREAD");
+    std::string value = disabled ? disabled : "";
+    for (char &c : value) c = (char) tolower((unsigned char) c);
+    if (value == "0" || value == "false" || value == "off" || value == "no") {
+        workerStatus = "disabled by CWS_SEND_THREAD";
+        return false;
+    }
+    toWorker = new moodycamel::BlockingReaderWriterQueue<Socket::SendOp *>(4096);
+    toMain = new moodycamel::ReaderWriterQueue<Socket::SendOp *>(4096);
+    uv_async_init(loop, &mainWake, onMainWake);
+    uv_unref((uv_handle_t *) &mainWake); // completions alone must not keep the process alive
+    std::thread(workerLoop).detach();
+    workerActive = true;
+    workerStatus = "active";
+    return true;
+}
+
+bool SendWorker::active() { return workerActive; }
+const char *SendWorker::status() { return workerStatus; }
+
+bool SendWorker::submit(void *op) {
+    // try_enqueue never allocates; a full queue means "send it yourself this tick".
+    return toWorker->try_enqueue((Socket::SendOp *) op);
+}
+
+// ---- Socket side (needs Socket internals) ----
+
+// Deflates a pending message with the given stream and replaces its raw payload with a
+// framed compressed message. Shared between the worker (its own compressor) and the
+// main-thread materialize path (the hub's).
+static void deflateAndFrame(Socket::Queue::Message *m, cWS::zlib::Stream *stream, bool resetAfter, char *buffer, size_t bufferSize, std::string &dynamic) {
+    size_t compressedLength = m->length;
+    // resetAfter == independent message (no context takeover): microdeflate; else the socket's window
+    char *deflated = resetAfter ? cWS::zlib::deflateIndependent(stream, (char *) m->data, compressedLength, buffer, bufferSize, dynamic)
+                                : cWS::zlib::deflate(stream, (char *) m->data, compressedLength, buffer, bufferSize, dynamic, false);
+    const size_t HEADER = cWS::WebSocketProtocol<true, cWS::WebSocket<true>>::LONG_MESSAGE_HEADER;
+    char *frame = new char[compressedLength + HEADER];
+    size_t frameLength = cWS::WebSocketProtocol<true, cWS::WebSocket<true>>::formatMessage(frame, deflated, compressedLength, (cWS::OpCode) m->opCode, compressedLength, true);
+    delete [] (char *) m->data;
+    m->data = frame;
+    m->length = frameLength;
+    m->ownsData = true;
+    m->compressPending = false;
+}
+
+namespace {
+    // worker-thread compression state: its own shared compressor and scratch buffers
+    cWS::zlib::Stream *workerDeflate = nullptr;
+    const size_t WORKER_BUFFER = 300 * 1024;
+    char *workerBuffer = nullptr;
+    std::string workerDynamic;
+}
+
+void Socket::materializeOnMain(Socket *s, Queue::Message *m, cWS::zlib::Stream *stream, bool resetAfter, char *buffer, size_t bufferSize, std::string &dynamic) {
+    deflateAndFrame(m, stream, resetAfter, buffer, bufferSize, dynamic);
+}
+
+void Socket::performSend(SendOp *op) {
+    if (!workerDeflate) {
+        workerDeflate = cWS::zlib::createDeflate(1, 15, 8);
+        workerBuffer = new char[WORKER_BUFFER];
+    }
+    // 1. deflate + frame anything still pending, with this socket's window or the shared one
+    cWS::zlib::Stream *stream = op->deflateWindow ? (cWS::zlib::Stream *) op->deflateWindow : workerDeflate;
+    for (Queue::Message *m = op->head; m; m = m->nextMessage) {
+        if (m->compressPending) {
+            deflateAndFrame(m, stream, !op->deflateWindow, workerBuffer, WORKER_BUFFER, workerDynamic);
+        }
+    }
+    // 2. gather
+    op->count = 0;
+    op->bytes = 0;
+    for (Queue::Message *m = op->head; m; m = m->nextMessage) {
+#ifdef _WIN32
+        op->bufs[op->count].buf = (CHAR *) m->data;
+        op->bufs[op->count].len = (ULONG) m->length;
+#else
+        op->iov[op->count].iov_base = (void *) m->data;
+        op->iov[op->count].iov_len = m->length;
+#endif
+        op->bytes += m->length;
+        op->count++;
+    }
+#ifdef _WIN32
+    DWORD sent = 0;
+    if (WSASend(op->fd, op->bufs, (DWORD) op->count, &sent, 0, nullptr, nullptr) == SOCKET_ERROR) {
+        op->result = -1;
+        op->error = WSAGetLastError();
+    } else {
+        op->result = (ssize_t) sent;
+        op->error = 0;
+    }
+#else
+    msghdr msg = {};
+    msg.msg_iov = op->iov;
+    msg.msg_iovlen = op->count;
+    op->result = ::sendmsg(op->fd, &msg, MSG_NOSIGNAL);
+    op->error = op->result < 0 ? errno : 0;
+#endif
+}
+
+static bool sendWouldBlock(int error) {
+#ifdef _WIN32
+    return error == WSAEWOULDBLOCK;
+#else
+    return error == EWOULDBLOCK || error == EAGAIN;
+#endif
+}
+
+void Socket::sendComplete(SendOp *op) {
+    Socket *s = op->socket;
+    if (!s) {
+        // socket closed while the op was in flight: release its messages, then the fd we kept open
+        for (Queue::Message *m = op->head; m;) {
+            Queue::Message *next = m->nextMessage;
+            if (m->callback) {
+                m->callback(nullptr, m->callbackData, true, m->reserved);
+            }
+            Queue::release(op->nodeData, m);
+            m = next;
+        }
+        if (op->closeFd) {
+            op->nodeData->netContext->closeSocket(op->fd);
+        }
+        if (op->destroyWindow) {
+            cWS::zlib::destroy((cWS::zlib::Stream *) op->destroyWindow);
+        }
+        delete op;
+        return;
+    }
+    s->sendOp = nullptr;
+
+    ssize_t res = op->result;
+    if (res < 0) {
+        if (sendWouldBlock(op->error)) {
+            res = 0;
+        } else {
+            s->requeueFront(op);
+            delete op;
+            if (s->endCb) {
+                s->endCb(s);
+            }
+            return;
+        }
+    }
+
+    std::vector<PendingCallback> callbacks;
+    size_t sent = (size_t) res, opBytes = op->bytes;
+    while (sent > 0 && op->head) {
+        Queue::Message *m = op->head;
+        if (sent >= m->length) {
+            sent -= m->length;
+            op->bytes -= m->length;
+            if (m->callback) {
+                callbacks.push_back({m->callback, m->callbackData, m->reserved});
+            }
+            op->head = m->nextMessage;
+            Queue::release(op->nodeData, m);
+        } else {
+            m->length -= sent;
+            m->data += sent;
+            op->bytes -= sent;
+            sent = 0;
+        }
+    }
+    if (!op->head) {
+        op->tail = nullptr;
+    }
+    bool complete = (size_t) res == opBytes;
+    s->requeueFront(op);
+    delete op;
+
+    if (!s->messageQueue.empty()) {
+        if (complete) {
+            s->submitToWorker();                  // more arrived while in flight
+        } else if ((s->getPoll() & UV_WRITABLE) == 0) {
+            s->setPoll(s->getPoll() | UV_WRITABLE); // kernel buffer full: the drain loop resumes when writable
+            s->changePoll(s);
+        }
+    }
+    for (PendingCallback &c : callbacks) {
+        c.callback(s, c.callbackData, false, c.reserved);
+        if (s->isClosed()) {
+            break;
+        }
+    }
+}
+
+}

package/src/SendWorker.h

@@ -0,0 +1,25 @@
+#ifndef CWS_SEND_WORKER_H
+#define CWS_SEND_WORKER_H
+
+// Send worker thread. The end-of-tick flush hands each socket's queued frames to
+// one worker thread as an op; the worker does the gathered send syscall (the
+// kernel's TCP work is charged to it, not to the JS thread) and posts the op back.
+// Both directions are single-producer/single-consumer lock-free queues
+// (deps/readerwriterqueue); the worker parks on a semaphore when idle and the main
+// thread is woken through a uv_async. Disabled with CWS_SEND_THREAD=0.
+
+#include <uv.h>
+
+namespace cS {
+
+struct SendWorker {
+    static bool init(uv_loop_t *loop);
+    static bool active();
+    static const char *status();   // "active", or why not
+    // Main thread only. Returns false if the queue is full; the caller then sends synchronously.
+    static bool submit(void *op);
+};
+
+}
+
+#endif // CWS_SEND_WORKER_H