@naeemo/capnp 0.9.1 → 0.9.3

package/dist/{cli-bench-bkR1vGK8.js → cli-bench-BRKmxDEn.js}

@@ -67,6 +67,432 @@ function checkEnvVar() {
 }
 if (checkEnvVar()) debugState.enabled = true;
 
+//#endregion
+//#region node_modules/.pnpm/lz4js@0.2.0/node_modules/lz4js/util.js
+var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.hashU32 = function hashU32(a) {
+		a = a | 0;
+		a = a + 2127912214 + (a << 12) | 0;
+		a = a ^ -949894596 ^ a >>> 19;
+		a = a + 374761393 + (a << 5) | 0;
+		a = a + -744332180 ^ a << 9;
+		a = a + -42973499 + (a << 3) | 0;
+		return a ^ -1252372727 ^ a >>> 16 | 0;
+	};
+	exports.readU64 = function readU64(b, n) {
+		var x = 0;
+		x |= b[n++] << 0;
+		x |= b[n++] << 8;
+		x |= b[n++] << 16;
+		x |= b[n++] << 24;
+		x |= b[n++] << 32;
+		x |= b[n++] << 40;
+		x |= b[n++] << 48;
+		x |= b[n++] << 56;
+		return x;
+	};
+	exports.readU32 = function readU32(b, n) {
+		var x = 0;
+		x |= b[n++] << 0;
+		x |= b[n++] << 8;
+		x |= b[n++] << 16;
+		x |= b[n++] << 24;
+		return x;
+	};
+	exports.writeU32 = function writeU32(b, n, x) {
+		b[n++] = x >> 0 & 255;
+		b[n++] = x >> 8 & 255;
+		b[n++] = x >> 16 & 255;
+		b[n++] = x >> 24 & 255;
+	};
+	exports.imul = function imul(a, b) {
+		var ah = a >>> 16;
+		var al = a & 65535;
+		var bh = b >>> 16;
+		var bl = b & 65535;
+		return al * bl + (ah * bl + al * bh << 16) | 0;
+	};
+}));
+
+//#endregion
+//#region node_modules/.pnpm/lz4js@0.2.0/node_modules/lz4js/xxh32.js
+var require_xxh32 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var util = require_util();
+	var prime1 = 2654435761;
+	var prime2 = 2246822519;
+	var prime3 = 3266489917;
+	var prime4 = 668265263;
+	var prime5 = 374761393;
+	function rotl32(x, r) {
+		x = x | 0;
+		r = r | 0;
+		return x >>> (32 - r | 0) | x << r | 0;
+	}
+	function rotmul32(h, r, m) {
+		h = h | 0;
+		r = r | 0;
+		m = m | 0;
+		return util.imul(h >>> (32 - r | 0) | h << r, m) | 0;
+	}
+	function shiftxor32(h, s) {
+		h = h | 0;
+		s = s | 0;
+		return h >>> s ^ h | 0;
+	}
+	function xxhapply(h, src, m0, s, m1) {
+		return rotmul32(util.imul(src, m0) + h, s, m1);
+	}
+	function xxh1(h, src, index) {
+		return rotmul32(h + util.imul(src[index], prime5), 11, prime1);
+	}
+	function xxh4(h, src, index) {
+		return xxhapply(h, util.readU32(src, index), prime3, 17, prime4);
+	}
+	function xxh16(h, src, index) {
+		return [
+			xxhapply(h[0], util.readU32(src, index + 0), prime2, 13, prime1),
+			xxhapply(h[1], util.readU32(src, index + 4), prime2, 13, prime1),
+			xxhapply(h[2], util.readU32(src, index + 8), prime2, 13, prime1),
+			xxhapply(h[3], util.readU32(src, index + 12), prime2, 13, prime1)
+		];
+	}
+	function xxh32(seed, src, index, len) {
+		var h, l = len;
+		if (len >= 16) {
+			h = [
+				seed + prime1 + prime2,
+				seed + prime2,
+				seed,
+				seed - prime1
+			];
+			while (len >= 16) {
+				h = xxh16(h, src, index);
+				index += 16;
+				len -= 16;
+			}
+			h = rotl32(h[0], 1) + rotl32(h[1], 7) + rotl32(h[2], 12) + rotl32(h[3], 18) + l;
+		} else h = seed + prime5 + len >>> 0;
+		while (len >= 4) {
+			h = xxh4(h, src, index);
+			index += 4;
+			len -= 4;
+		}
+		while (len > 0) {
+			h = xxh1(h, src, index);
+			index++;
+			len--;
+		}
+		h = shiftxor32(util.imul(shiftxor32(util.imul(shiftxor32(h, 15), prime2), 13), prime3), 16);
+		return h >>> 0;
+	}
+	exports.hash = xxh32;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/lz4js@0.2.0/node_modules/lz4js/lz4.js
+var require_lz4 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var xxhash = require_xxh32();
+	var util = require_util();
+	var minMatch = 4;
+	var minLength = 13;
+	var searchLimit = 5;
+	var skipTrigger = 6;
+	var hashSize = 65536;
+	var mlBits = 4;
+	var mlMask = (1 << mlBits) - 1;
+	var runMask = 15;
+	var blockBuf = makeBuffer(5 << 20);
+	var hashTable = makeHashTable();
+	var magicNum = 407708164;
+	var fdContentChksum = 4;
+	var fdContentSize = 8;
+	var fdBlockChksum = 16;
+	var fdVersion = 64;
+	var fdVersionMask = 192;
+	var bsUncompressed = 2147483648;
+	var bsDefault = 7;
+	var bsShift = 4;
+	var bsMask = 7;
+	var bsMap = {
+		4: 65536,
+		5: 262144,
+		6: 1048576,
+		7: 4194304
+	};
+	function makeHashTable() {
+		try {
+			return new Uint32Array(hashSize);
+		} catch (error) {
+			var hashTable = new Array(hashSize);
+			for (var i = 0; i < hashSize; i++) hashTable[i] = 0;
+			return hashTable;
+		}
+	}
+	function clearHashTable(table) {
+		for (var i = 0; i < hashSize; i++) hashTable[i] = 0;
+	}
+	function makeBuffer(size) {
+		try {
+			return new Uint8Array(size);
+		} catch (error) {
+			var buf = new Array(size);
+			for (var i = 0; i < size; i++) buf[i] = 0;
+			return buf;
+		}
+	}
+	function sliceArray(array, start, end) {
+		if (Uint8Array.prototype.slice) return array.slice(start, end);
+		else {
+			var len = array.length;
+			start = start | 0;
+			start = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+			end = end === void 0 ? len : end | 0;
+			end = end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
+			var arraySlice = new Uint8Array(end - start);
+			for (var i = start, n = 0; i < end;) arraySlice[n++] = array[i++];
+			return arraySlice;
+		}
+	}
+	exports.compressBound = function compressBound(n) {
+		return n + n / 255 + 16 | 0;
+	};
+	exports.decompressBound = function decompressBound(src) {
+		var sIndex = 0;
+		if (util.readU32(src, sIndex) !== magicNum) throw new Error("invalid magic number");
+		sIndex += 4;
+		var descriptor = src[sIndex++];
+		if ((descriptor & fdVersionMask) !== fdVersion) throw new Error("incompatible descriptor version " + (descriptor & fdVersionMask));
+		var useBlockSum = (descriptor & fdBlockChksum) !== 0;
+		var useContentSize = (descriptor & fdContentSize) !== 0;
+		var bsIdx = src[sIndex++] >> bsShift & bsMask;
+		if (bsMap[bsIdx] === void 0) throw new Error("invalid block size " + bsIdx);
+		var maxBlockSize = bsMap[bsIdx];
+		if (useContentSize) return util.readU64(src, sIndex);
+		sIndex++;
+		var maxSize = 0;
+		while (true) {
+			var blockSize = util.readU32(src, sIndex);
+			sIndex += 4;
+			if (blockSize & bsUncompressed) {
+				blockSize &= ~bsUncompressed;
+				maxSize += blockSize;
+			} else maxSize += maxBlockSize;
+			if (blockSize === 0) return maxSize;
+			if (useBlockSum) sIndex += 4;
+			sIndex += blockSize;
+		}
+	};
+	exports.makeBuffer = makeBuffer;
+	exports.decompressBlock = function decompressBlock(src, dst, sIndex, sLength, dIndex) {
+		var mLength, mOffset, sEnd = sIndex + sLength, n, i;
+		while (sIndex < sEnd) {
+			var token = src[sIndex++];
+			var literalCount = token >> 4;
+			if (literalCount > 0) {
+				if (literalCount === 15) while (true) {
+					literalCount += src[sIndex];
+					if (src[sIndex++] !== 255) break;
+				}
+				for (n = sIndex + literalCount; sIndex < n;) dst[dIndex++] = src[sIndex++];
+			}
+			if (sIndex >= sEnd) break;
+			mLength = token & 15;
+			mOffset = src[sIndex++] | src[sIndex++] << 8;
+			if (mLength === 15) while (true) {
+				mLength += src[sIndex];
+				if (src[sIndex++] !== 255) break;
+			}
+			mLength += minMatch;
+			for (i = dIndex - mOffset, n = i + mLength; i < n;) dst[dIndex++] = dst[i++] | 0;
+		}
+		return dIndex;
+	};
+	exports.compressBlock = function compressBlock(src, dst, sIndex, sLength, hashTable) {
+		var mIndex, mAnchor, mLength, mOffset, mStep;
+		var literalCount, dIndex = 0, sEnd = sLength + sIndex, n;
+		mAnchor = sIndex;
+		if (sLength >= minLength) {
+			var searchMatchCount = (1 << skipTrigger) + 3;
+			while (sIndex + minMatch < sEnd - searchLimit) {
+				var seq = util.readU32(src, sIndex);
+				var hash = util.hashU32(seq) >>> 0;
+				hash = (hash >> 16 ^ hash) >>> 0 & 65535;
+				mIndex = hashTable[hash] - 1;
+				hashTable[hash] = sIndex + 1;
+				if (mIndex < 0 || sIndex - mIndex >>> 16 > 0 || util.readU32(src, mIndex) !== seq) {
+					mStep = searchMatchCount++ >> skipTrigger;
+					sIndex += mStep;
+					continue;
+				}
+				searchMatchCount = (1 << skipTrigger) + 3;
+				literalCount = sIndex - mAnchor;
+				mOffset = sIndex - mIndex;
+				sIndex += minMatch;
+				mIndex += minMatch;
+				mLength = sIndex;
+				while (sIndex < sEnd - searchLimit && src[sIndex] === src[mIndex]) {
+					sIndex++;
+					mIndex++;
+				}
+				mLength = sIndex - mLength;
+				var token = mLength < mlMask ? mLength : mlMask;
+				if (literalCount >= runMask) {
+					dst[dIndex++] = (runMask << mlBits) + token;
+					for (n = literalCount - runMask; n >= 255; n -= 255) dst[dIndex++] = 255;
+					dst[dIndex++] = n;
+				} else dst[dIndex++] = (literalCount << mlBits) + token;
+				for (var i = 0; i < literalCount; i++) dst[dIndex++] = src[mAnchor + i];
+				dst[dIndex++] = mOffset;
+				dst[dIndex++] = mOffset >> 8;
+				if (mLength >= mlMask) {
+					for (n = mLength - mlMask; n >= 255; n -= 255) dst[dIndex++] = 255;
+					dst[dIndex++] = n;
+				}
+				mAnchor = sIndex;
+			}
+		}
+		if (mAnchor === 0) return 0;
+		literalCount = sEnd - mAnchor;
+		if (literalCount >= runMask) {
+			dst[dIndex++] = runMask << mlBits;
+			for (n = literalCount - runMask; n >= 255; n -= 255) dst[dIndex++] = 255;
+			dst[dIndex++] = n;
+		} else dst[dIndex++] = literalCount << mlBits;
+		sIndex = mAnchor;
+		while (sIndex < sEnd) dst[dIndex++] = src[sIndex++];
+		return dIndex;
+	};
+	exports.decompressFrame = function decompressFrame(src, dst) {
+		var useBlockSum, useContentSum, useContentSize, descriptor;
+		var sIndex = 0;
+		var dIndex = 0;
+		if (util.readU32(src, sIndex) !== magicNum) throw new Error("invalid magic number");
+		sIndex += 4;
+		descriptor = src[sIndex++];
+		if ((descriptor & fdVersionMask) !== fdVersion) throw new Error("incompatible descriptor version");
+		useBlockSum = (descriptor & fdBlockChksum) !== 0;
+		useContentSum = (descriptor & fdContentChksum) !== 0;
+		useContentSize = (descriptor & fdContentSize) !== 0;
+		if (bsMap[src[sIndex++] >> bsShift & bsMask] === void 0) throw new Error("invalid block size");
+		if (useContentSize) sIndex += 8;
+		sIndex++;
+		while (true) {
+			var compSize = util.readU32(src, sIndex);
+			sIndex += 4;
+			if (compSize === 0) break;
+			if (useBlockSum) sIndex += 4;
+			if ((compSize & bsUncompressed) !== 0) {
+				compSize &= ~bsUncompressed;
+				for (var j = 0; j < compSize; j++) dst[dIndex++] = src[sIndex++];
+			} else {
+				dIndex = exports.decompressBlock(src, dst, sIndex, compSize, dIndex);
+				sIndex += compSize;
+			}
+		}
+		if (useContentSum) sIndex += 4;
+		return dIndex;
+	};
+	exports.compressFrame = function compressFrame(src, dst) {
+		var dIndex = 0;
+		util.writeU32(dst, dIndex, magicNum);
+		dIndex += 4;
+		dst[dIndex++] = fdVersion;
+		dst[dIndex++] = bsDefault << bsShift;
+		dst[dIndex] = xxhash.hash(0, dst, 4, dIndex - 4) >> 8;
+		dIndex++;
+		var maxBlockSize = bsMap[bsDefault];
+		var remaining = src.length;
+		var sIndex = 0;
+		clearHashTable(hashTable);
+		while (remaining > 0) {
+			var compSize = 0;
+			var blockSize = remaining > maxBlockSize ? maxBlockSize : remaining;
+			compSize = exports.compressBlock(src, blockBuf, sIndex, blockSize, hashTable);
+			if (compSize > blockSize || compSize === 0) {
+				util.writeU32(dst, dIndex, 2147483648 | blockSize);
+				dIndex += 4;
+				for (var z = sIndex + blockSize; sIndex < z;) dst[dIndex++] = src[sIndex++];
+				remaining -= blockSize;
+			} else {
+				util.writeU32(dst, dIndex, compSize);
+				dIndex += 4;
+				for (var j = 0; j < compSize;) dst[dIndex++] = blockBuf[j++];
+				sIndex += blockSize;
+				remaining -= blockSize;
+			}
+		}
+		util.writeU32(dst, dIndex, 0);
+		dIndex += 4;
+		return dIndex;
+	};
+	exports.decompress = function decompress(src, maxSize) {
+		var dst, size;
+		if (maxSize === void 0) maxSize = exports.decompressBound(src);
+		dst = exports.makeBuffer(maxSize);
+		size = exports.decompressFrame(src, dst);
+		if (size !== maxSize) dst = sliceArray(dst, 0, size);
+		return dst;
+	};
+	exports.compress = function compress(src, maxSize) {
+		var dst, size;
+		if (maxSize === void 0) maxSize = exports.compressBound(src.length);
+		dst = exports.makeBuffer(maxSize);
+		size = exports.compressFrame(src, dst);
+		if (size !== maxSize) dst = sliceArray(dst, 0, size);
+		return dst;
+	};
+}));
+
+//#endregion
+//#region src/compression/lz4.ts
+var import_lz4 = require_lz4();
+/**
+* Default compression options
+*/
+const DEFAULT_COMPRESSION_OPTIONS = {
+	threshold: 1024,
+	acceleration: 1,
+	level: 0
+};
+/**
+* Compress data using LZ4
+* @param data - Data to compress
+* @param options - Compression options
+* @returns Compressed data, or null if compression failed or not beneficial
+*/
+function compress(data, options = {}) {
+	const opts = {
+		...DEFAULT_COMPRESSION_OPTIONS,
+		...options
+	};
+	if (data.length < opts.threshold) return null;
+	try {
+		const compressed = (0, import_lz4.compress)(Array.from(data));
+		if (compressed.length >= data.length) return null;
+		return new Uint8Array(compressed);
+	} catch (_error) {
+		return null;
+	}
+}
+/**
+* Decompress LZ4 compressed data
+* @param data - Compressed data
+* @param originalSize - Original uncompressed size
+* @returns Decompressed data, or null if decompression failed
+*/
+function decompress(data, originalSize) {
+	try {
+		const decompressed = (0, import_lz4.decompress)(Array.from(data), originalSize);
+		return new Uint8Array(decompressed);
+	} catch (_error) {
+		return null;
+	}
+}
+/**
+* Alias for decompress - same function, different name for API compatibility
+*/
+const uncompress = decompress;
+
 //#endregion
 //#region src/debug/index.ts
 /**
@@ -3870,6 +4296,115 @@ var import_sender = /* @__PURE__ */ __toESM(require_sender(), 1);
 var import_websocket = /* @__PURE__ */ __toESM(require_websocket(), 1);
 var import_websocket_server = /* @__PURE__ */ __toESM(require_websocket_server(), 1);
 
+//#endregion
+//#region src/compression/frame.ts
+/**
+* LZ4 Frame Format Module
+*
+* Frame format: Magic(4) + Flags(1) + Length(4) + Payload
+* - Magic: 0x4C5A3401 (LZ4\0\x01)
+* - Flags: compression options and metadata
+* - Length: uncompressed data length (4 bytes, little-endian)
+* - Payload: compressed or uncompressed data
+*/
+/**
+* Frame format constants
+*/
+const LZ4_FRAME_MAGIC = 1280979969;
+const LZ4_FRAME_HEADER_SIZE = 9;
+/**
+* Frame flags
+*/
+let FrameFlags = /* @__PURE__ */ function(FrameFlags) {
+	/** Data is compressed */
+	FrameFlags[FrameFlags["COMPRESSED"] = 1] = "COMPRESSED";
+	/** Reserved for future use */
+	FrameFlags[FrameFlags["RESERVED_1"] = 2] = "RESERVED_1";
+	/** Reserved for future use */
+	FrameFlags[FrameFlags["RESERVED_2"] = 4] = "RESERVED_2";
+	/** Reserved for future use */
+	FrameFlags[FrameFlags["RESERVED_3"] = 8] = "RESERVED_3";
+	/** Reserved for future use */
+	FrameFlags[FrameFlags["RESERVED_4"] = 16] = "RESERVED_4";
+	/** Reserved for future use */
+	FrameFlags[FrameFlags["RESERVED_5"] = 32] = "RESERVED_5";
+	/** Reserved for future use */
+	FrameFlags[FrameFlags["RESERVED_6"] = 64] = "RESERVED_6";
+	/** Reserved for future use */
+	FrameFlags[FrameFlags["RESERVED_7"] = 128] = "RESERVED_7";
+	return FrameFlags;
+}({});
+/**
+* Check if data has LZ4 frame magic header
+*/
+function hasFrameMagic(data) {
+	if (data.length < 4) return false;
+	return new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true) === LZ4_FRAME_MAGIC;
+}
+/**
+* Parse frame header from data
+* @returns FrameHeader if valid, null otherwise
+*/
+function parseFrameHeader(data) {
+	if (data.length < LZ4_FRAME_HEADER_SIZE) return null;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const magic = view.getUint32(0, true);
+	if (magic !== LZ4_FRAME_MAGIC) return null;
+	return {
+		magic,
+		flags: view.getUint8(4),
+		length: view.getUint32(5, true)
+	};
+}
+/**
+* Decompress framed data
+* @param data - Framed data (with or without frame header)
+* @param decompressFn - Decompression function for compressed payloads
+* @returns Decompressed data, or null if invalid
+*/
+function decompressFrame(data, decompressFn) {
+	const header = parseFrameHeader(data);
+	if (!header) return data;
+	const payloadOffset = LZ4_FRAME_HEADER_SIZE;
+	if (data.length - payloadOffset < 0) return null;
+	const payload = data.subarray(payloadOffset);
+	if (header.flags & FrameFlags.COMPRESSED) return decompressFn(payload, header.length);
+	return payload;
+}
+
+//#endregion
+//#region src/compression/index.ts
+/**
+* Create default compression config
+*/
+function createCompressionConfig(config) {
+	return {
+		enabled: false,
+		algorithm: "lz4",
+		threshold: 1024,
+		level: 0,
+		highCompression: false,
+		...config
+	};
+}
+/**
+* Create empty compression stats
+*/
+function createCompressionStats() {
+	return {
+		messagesCompressed: 0,
+		messagesDecompressed: 0,
+		bytesOriginal: 0,
+		bytesCompressed: 0,
+		compressionRatio: 1,
+		savingsPercent: 0
+	};
+}
+/**
+* Default compression configuration
+*/
+const DEFAULT_COMPRESSION_CONFIG = createCompressionConfig();
+
 //#endregion
 //#region src/proxy/websocket-proxy.ts
 /**
@@ -3878,6 +4413,27 @@ var import_websocket_server = /* @__PURE__ */ __toESM(require_websocket_server()
 * Allows browsers to connect to native Cap'n Proto services (C++, etc.)
 * via WebSocket. Handles the protocol bridging between WebSocket (browser)
 * and raw TCP (Cap'n Proto services).
+*
+* Features:
+* - Independent compression configuration for WebSocket and TCP sides
+* - Automatic compression/decompression bridging
+* - Support for different compression settings on each side
+* - Backward compatibility with non-compressed peers
+*/
+/**
+* Convert Buffer to Uint8Array without copying if possible
+*/
+function bufferToUint8Array(buffer) {
+	return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}
+/**
+* Convert Uint8Array to Buffer without copying if possible
+*/
+function uint8ArrayToBuffer(arr) {
+	return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/**
+* Represents a single proxy connection between WebSocket client and TCP server
 */
 var ProxyConnection = class extends EventEmitter {
 	ws;
@@ -3885,16 +4441,22 @@ var ProxyConnection = class extends EventEmitter {
 	stats;
 	options;
 	closed = false;
+	wsCompressionConfig;
+	tcpCompressionConfig;
 	constructor(ws, options) {
 		super();
 		this.ws = ws;
 		this.options = options;
+		this.wsCompressionConfig = createCompressionConfig(options.compression?.ws);
+		this.tcpCompressionConfig = createCompressionConfig(options.compression?.tcp);
 		this.stats = {
 			wsMessagesIn: 0,
 			wsMessagesOut: 0,
 			tcpBytesIn: 0,
 			tcpBytesOut: 0,
-			connectedAt: /* @__PURE__ */ new Date()
+			connectedAt: /* @__PURE__ */ new Date(),
+			wsCompression: createCompressionStats(),
+			tcpCompression: createCompressionStats()
 		};
 		this.setupWebSocket();
 	}
@@ -3922,6 +4484,7 @@ var ProxyConnection = class extends EventEmitter {
 		});
 		this.tcpSocket.on("connect", () => {
 			this.log("Connected to target TCP service");
+			this.log(`Compression - WS: ${this.wsCompressionConfig.enabled ? "enabled" : "disabled"}, TCP: ${this.tcpCompressionConfig.enabled ? "enabled" : "disabled"}`);
 			this.emit("connected");
 		});
 		this.tcpSocket.on("data", (data) => {
@@ -3941,29 +4504,78 @@ var ProxyConnection = class extends EventEmitter {
 			this.close();
 		});
 	}
+	/**
+	* Handle incoming message from WebSocket client
+	* - Decompress if compressed (from browser)
+	* - Re-compress for TCP side if TCP compression is enabled
+	* - Forward to TCP server
+	*/
 	handleWebSocketMessage(data) {
 		if (this.closed) return;
 		const buffer = Buffer.isBuffer(data) ? data : Array.isArray(data) ? Buffer.concat(data) : Buffer.from(data);
 		const maxSize = this.options.maxMessageSize ?? 16 * 1024 * 1024;
-		if (buffer.length > maxSize) {
-			this.log(`Message too large: ${buffer.length} bytes`);
+		const uint8Data = bufferToUint8Array(buffer);
+		const frameInfo = parseFrameHeader(uint8Data);
+		const uncompressedSize = frameInfo ? frameInfo.length : buffer.length;
+		if (uncompressedSize > maxSize) {
+			this.log(`Message too large: ${uncompressedSize} bytes (max: ${maxSize})`);
 			this.close();
 			return;
 		}
 		this.stats.wsMessagesIn++;
-		this.stats.tcpBytesOut += buffer.length;
+		let decompressedData;
+		if (hasFrameMagic(uint8Data)) {
+			const decompressed = decompressFrame(uint8Data, uncompress);
+			if (decompressed !== null) {
+				decompressedData = decompressed;
+				this.log(`Decompressed WS message: ${buffer.length} -> ${decompressedData.length} bytes`);
+			} else decompressedData = uint8Data;
+		} else decompressedData = uint8Data;
+		let dataToSend = decompressedData;
+		if (this.tcpCompressionConfig.enabled) {
+			const compressed = compress(decompressedData, { threshold: this.tcpCompressionConfig.threshold });
+			if (compressed !== null) {
+				dataToSend = compressed;
+				this.log(`Compressed for TCP: ${decompressedData.length} -> ${dataToSend.length} bytes`);
+			}
+		}
+		this.stats.tcpBytesOut += uint8ArrayToBuffer(dataToSend).length;
 		if (this.tcpSocket?.writable) {
-			this.tcpSocket.write(buffer);
-			this.log(`Forwarded ${buffer.length} bytes to TCP`);
+			const bufferToSend = uint8ArrayToBuffer(dataToSend);
+			this.tcpSocket.write(bufferToSend);
+			this.log(`Forwarded ${dataToSend.length} bytes to TCP (original: ${decompressedData.length})`);
 		}
 	}
+	/**
+	* Handle incoming data from TCP server
+	* - Decompress if compressed (from native Cap'n Proto service)
+	* - Re-compress for WebSocket side if WS compression is enabled
+	* - Forward to WebSocket client
+	*/
 	handleTcpData(data) {
 		if (this.closed) return;
 		this.stats.tcpBytesIn += data.length;
+		const uint8Data = bufferToUint8Array(data);
+		let decompressedData;
+		if (hasFrameMagic(uint8Data)) {
+			const decompressed = decompressFrame(uint8Data, uncompress);
+			if (decompressed !== null) {
+				decompressedData = decompressed;
+				this.log(`Decompressed TCP message: ${data.length} -> ${decompressedData.length} bytes`);
+			} else decompressedData = uint8Data;
+		} else decompressedData = uint8Data;
+		let dataToSend = decompressedData;
+		if (this.wsCompressionConfig.enabled) {
+			const compressed = compress(decompressedData, { threshold: this.wsCompressionConfig.threshold });
+			if (compressed !== null) {
+				dataToSend = compressed;
+				this.log(`Compressed for WS: ${decompressedData.length} -> ${dataToSend.length} bytes`);
+			}
+		}
 		this.stats.wsMessagesOut++;
 		if (this.ws.readyState === import_websocket.default.OPEN) {
-			this.ws.send(data);
-			this.log(`Forwarded ${data.length} bytes to WebSocket`);
+			this.ws.send(dataToSend);
+			this.log(`Forwarded ${dataToSend.length} bytes to WebSocket (original: ${decompressedData.length})`);
 		}
 	}
 	log(...args) {
@@ -3980,6 +4592,10 @@ var ProxyConnection = class extends EventEmitter {
 		this.emit("closed");
 	}
 };
+/**
+* WebSocket-to-TCP Proxy server
+* Manages multiple proxy connections
+*/
 var CapnpWebSocketProxy = class extends EventEmitter {
 	wss;
 	connections = /* @__PURE__ */ new Map();
@@ -4037,6 +4653,9 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 	let targetHost = "localhost";
 	let targetPort = 8081;
 	let debug = false;
+	let wsCompression = false;
+	let tcpCompression = false;
+	let compressionThreshold = 1024;
 	for (let i = 0; i < args.length; i++) switch (args[i]) {
 		case "--ws-port":
 		case "-p":
@@ -4053,6 +4672,17 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 		case "-d":
 			debug = true;
 			break;
+		case "--ws-compression":
+		case "-w":
+			wsCompression = true;
+			break;
+		case "--tcp-compression":
+		case "-c":
+			tcpCompression = true;
+			break;
+		case "--compression-threshold":
+			compressionThreshold = Number.parseInt(args[++i], 10);
+			break;
 		case "--help":
 		case "-h":
 			console.log(`
@@ -4061,13 +4691,25 @@ Cap'n Proto WebSocket-to-TCP Proxy
 Usage: npx @naeemo/capnp proxy [options]
 
 Options:
-  -p, --ws-port <port>     WebSocket server port (default: 8080)
-  -t, --target <host:port> Target TCP service (default: localhost:8081)
-  -d, --debug              Enable debug logging
-  -h, --help               Show this help
+  -p, --ws-port <port>            WebSocket server port (default: 8080)
+  -t, --target <host:port>        Target TCP service (default: localhost:8081)
+  -d, --debug                     Enable debug logging
+  -w, --ws-compression            Enable WebSocket side compression
+  -c, --tcp-compression           Enable TCP side compression
+      --compression-threshold <n> Minimum size to compress (default: 1024)
+  -h, --help                      Show this help
 
-Example:
+Examples:
   npx @naeemo/capnp proxy -p 9000 -t 192.168.1.100:7000
+  
+  # Enable compression on WebSocket side only (for browser clients)
+  npx @naeemo/capnp proxy -p 9000 -t localhost:7000 -w
+  
+  # Enable compression on both sides
+  npx @naeemo/capnp proxy -p 9000 -t localhost:7000 -w -c
+  
+  # Enable compression with lower threshold
+  npx @naeemo/capnp proxy -p 9000 -t localhost:7000 -w --compression-threshold 512
 `);
 			process.exit(0);
 	}
@@ -4075,11 +4717,26 @@ Example:
 		wsPort,
 		targetHost,
 		targetPort,
-		debug
+		debug,
+		compression: {
+			ws: {
+				enabled: wsCompression,
+				threshold: compressionThreshold
+			},
+			tcp: {
+				enabled: tcpCompression,
+				threshold: compressionThreshold
+			}
+		}
 	});
 	console.log("WebSocket-to-TCP Proxy started");
 	console.log(`  WebSocket: ws://localhost:${wsPort}`);
 	console.log(`  Target:    ${targetHost}:${targetPort}`);
+	if (wsCompression || tcpCompression) {
+		console.log("  Compression:");
+		console.log(`    WebSocket: ${wsCompression ? "enabled" : "disabled"} (threshold: ${compressionThreshold})`);
+		console.log(`    TCP:       ${tcpCompression ? "enabled" : "disabled"} (threshold: ${compressionThreshold})`);
+	}
 	proxy.on("connection", () => {
 		console.log(`Active connections: ${proxy.getConnectionCount()}`);
 	});
@@ -4525,4 +5182,4 @@ async function run(args) {
 
 //#endregion
 export { run };
-//# sourceMappingURL=cli-bench-bkR1vGK8.js.map
+//# sourceMappingURL=cli-bench-BRKmxDEn.js.map