@naeemo/capnp 0.9.1 → 0.9.3

package/dist/index.cjs

@@ -105,6 +105,13 @@ function encodeStructPointer(offset, dataWords, pointerCount) {
 function encodeListPointer(offset, elementSize, elementCount) {
 	return (BigInt(offset < 0 ? offset + 1073741824 : offset) & BigInt(1073741823)) << BigInt(2) | BigInt(1) | BigInt(elementSize) << BigInt(32) | BigInt(elementCount) << BigInt(35);
 }
+/**
+* 编码 Far 指针
+*/
+function encodeFarPointer(segment, offset, doubleFar = false) {
+	const offsetBits = BigInt(offset) & BigInt(536870911);
+	return (BigInt(segment) & BigInt(4294967295)) << BigInt(32) | offsetBits << BigInt(3) | (doubleFar ? BigInt(1) << BigInt(2) : BigInt(0)) | BigInt(2);
+}
 
 //#endregion
 //#region src/core/segment.ts
@@ -1689,6 +1696,18 @@ var WebSocketTransport = class WebSocketTransport {
 	get connected() {
 		return this._connected;
 	}
+	getCompressionState() {
+		return {
+			enabled: false,
+			algorithm: "none",
+			bytesSent: 0,
+			bytesReceived: 0,
+			uncompressedBytesSent: 0,
+			uncompressedBytesReceived: 0,
+			messagesCompressed: 0,
+			messagesDecompressed: 0
+		};
+	}
 	connect(url) {
 		this.ws = new WebSocket(url);
 		this.ws.binaryType = this.options.binaryType ?? "arraybuffer";
@@ -1845,6 +1864,432 @@ var WebSocketTransport = class WebSocketTransport {
 	}
 };
 
+//#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/rpc/tcp-transport.ts
 /**
@@ -1853,11 +2298,20 @@ var WebSocketTransport = class WebSocketTransport {
 * Implements RpcTransport over raw TCP socket for C++ interop testing.
 * This allows direct communication with the official Cap'n Proto C++ implementation.
 */
+const FRAME_MAGIC = 1280980035;
+const ALGORITHM_LZ4 = 1;
+const CAPABILITY_VERSION = 1;
+const DEFAULT_COMPRESSION_THRESHOLD = 256;
 /**
 * TCP Transport for Cap'n Proto RPC
 *
 * Uses length-prefixed binary message framing compatible with Cap'n Proto C++ implementation.
 * Format: [4 bytes: message length (little-endian)] [N bytes: message data]
+*
+* With compression support:
+* - Connection establishment includes capability negotiation
+* - Messages larger than threshold are automatically compressed
+* - Frame header indicates compression algorithm used
 */
 var TcpTransport = class TcpTransport {
 	socket = null;
@@ -1867,12 +2321,35 @@ var TcpTransport = class TcpTransport {
 	pendingBuffer = Buffer.alloc(0);
 	pendingLength = 0;
 	hasPendingLength = false;
+	compressionConfig;
+	localSupportsLz4 = false;
+	remoteSupportsLz4 = false;
+	compressionEnabled = false;
+	compressionState;
+	negotiationComplete = false;
 	onClose;
 	onError;
 	constructor(host, port, options = {}) {
 		this.host = host;
 		this.port = port;
 		this.options = options;
+		this.compressionConfig = {
+			enabled: options.compression?.enabled ?? true,
+			algorithm: options.compression?.algorithm ?? "lz4",
+			thresholdBytes: options.compression?.thresholdBytes ?? DEFAULT_COMPRESSION_THRESHOLD,
+			level: options.compression?.level ?? 1
+		};
+		this.localSupportsLz4 = this.compressionConfig.enabled && this.compressionConfig.algorithm === "lz4";
+		this.compressionState = {
+			enabled: false,
+			algorithm: "none",
+			bytesSent: 0,
+			bytesReceived: 0,
+			uncompressedBytesSent: 0,
+			uncompressedBytesReceived: 0,
+			messagesCompressed: 0,
+			messagesDecompressed: 0
+		};
 	}
 	static async connect(host, port, options) {
 		const transport = new TcpTransport(host, port, options);
@@ -1887,6 +2364,9 @@ var TcpTransport = class TcpTransport {
 	get connected() {
 		return this._connected && this.socket?.readyState === "open";
 	}
+	getCompressionState() {
+		return { ...this.compressionState };
+	}
 	connect() {
 		return new Promise((resolve, reject) => {
 			const timeout = setTimeout(() => {
@@ -1894,10 +2374,15 @@ var TcpTransport = class TcpTransport {
 				reject(/* @__PURE__ */ new Error("Connection timeout"));
 			}, this.options.connectTimeoutMs ?? 1e4);
 			this.socket = new node_net.Socket();
-			this.socket.on("connect", () => {
+			this.socket.on("connect", async () => {
 				clearTimeout(timeout);
 				this._connected = true;
-				resolve();
+				try {
+					await this.performCapabilityNegotiation();
+					resolve();
+				} catch (err) {
+					reject(err instanceof Error ? err : new Error(String(err)));
+				}
 			});
 			this.socket.on("data", (data) => {
 				this.handleData(data);
@@ -1939,6 +2424,85 @@ var TcpTransport = class TcpTransport {
 		socket.on("end", () => {
 			this._connected = false;
 		});
+		if (this._connected) this.performCapabilityNegotiation().catch((err) => {
+			this.onError?.(err instanceof Error ? err : new Error(String(err)));
+		});
+	}
+	/**
+	* Perform capability negotiation with the remote peer
+	*/
+	async performCapabilityNegotiation() {
+		if (!this.socket) throw new Error("Socket not connected");
+		if (this.host === "" && this.port === 0) {
+			this.remoteSupportsLz4 = (await this.readCapabilityNegotiation()).supportsLz4;
+			await this.sendCapabilityNegotiation();
+		} else {
+			await this.sendCapabilityNegotiation();
+			this.remoteSupportsLz4 = (await this.readCapabilityNegotiation()).supportsLz4;
+		}
+		this.compressionEnabled = this.localSupportsLz4 && this.remoteSupportsLz4;
+		this.compressionState.enabled = this.compressionEnabled;
+		this.compressionState.algorithm = this.compressionEnabled ? "lz4" : "none";
+		this.negotiationComplete = true;
+	}
+	/**
+	* Send capability negotiation message
+	*/
+	async sendCapabilityNegotiation() {
+		const caps = {
+			type: "capabilities",
+			supportsLz4: this.localSupportsLz4,
+			version: CAPABILITY_VERSION
+		};
+		const data = Buffer.from(JSON.stringify(caps), "utf-8");
+		const frame = Buffer.allocUnsafe(4 + data.length);
+		frame.writeUInt32LE(data.length, 0);
+		frame.set(data, 4);
+		return new Promise((resolve, reject) => {
+			this.socket.write(frame, (err) => {
+				if (err) reject(err);
+				else resolve();
+			});
+		});
+	}
+	/**
+	* Read capability negotiation message
+	*/
+	async readCapabilityNegotiation() {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Capability negotiation timeout"));
+			}, 5e3);
+			const checkBuffer = () => {
+				if (this.pendingBuffer.length < 4) {
+					this.socket.listenerCount("data");
+					const dataHandler = () => {
+						this.socket.off("data", dataHandler);
+						checkBuffer();
+					};
+					this.socket.once("data", dataHandler);
+					return;
+				}
+				const length = this.pendingBuffer.readUInt32LE(0);
+				if (this.pendingBuffer.length < 4 + length) {
+					const dataHandler = () => {
+						this.socket.off("data", dataHandler);
+						checkBuffer();
+					};
+					this.socket.once("data", dataHandler);
+					return;
+				}
+				clearTimeout(timeout);
+				const capsData = this.pendingBuffer.subarray(4, 4 + length);
+				this.pendingBuffer = this.pendingBuffer.subarray(4 + length);
+				try {
+					resolve(JSON.parse(capsData.toString("utf-8")));
+				} catch (err) {
+					reject(/* @__PURE__ */ new Error(`Failed to parse capability negotiation: ${err}`));
+				}
+			};
+			checkBuffer();
+		});
 	}
 	handleData(data) {
 		this.pendingBuffer = Buffer.concat([this.pendingBuffer, data]);
@@ -1954,14 +2518,50 @@ var TcpTransport = class TcpTransport {
 			}
 			const totalLength = 4 + this.pendingLength;
 			if (this.pendingBuffer.length < totalLength) break;
-			const messageData = this.pendingBuffer.subarray(4, totalLength);
-			this.pendingBuffer = this.pendingBuffer.subarray(totalLength);
-			this.hasPendingLength = false;
-			try {
-				const message = deserializeRpcMessage(new Uint8Array(messageData));
-				this.handleRpcMessage(message);
-			} catch (err) {
-				this.onError?.(err instanceof Error ? err : new Error(String(err)));
+			if (this.pendingBuffer.readUInt32LE(4) === FRAME_MAGIC && this.negotiationComplete) {
+				if (this.pendingLength < 16) {
+					this.onError?.(/* @__PURE__ */ new Error("Invalid compressed frame"));
+					this.close(/* @__PURE__ */ new Error("Invalid compressed frame"));
+					return;
+				}
+				const headerOffset = 4;
+				const originalSize = this.pendingBuffer.readUInt32LE(headerOffset + 4);
+				const compressedSize = this.pendingBuffer.readUInt32LE(headerOffset + 8);
+				const algorithm = this.pendingBuffer.readUInt32LE(headerOffset + 12);
+				const frameTotalLength = 20 + compressedSize;
+				if (this.pendingBuffer.length < frameTotalLength) break;
+				const compressedData = this.pendingBuffer.subarray(headerOffset + 16, frameTotalLength);
+				this.pendingBuffer = this.pendingBuffer.subarray(frameTotalLength);
+				this.hasPendingLength = false;
+				try {
+					let messageData;
+					if (algorithm === ALGORITHM_LZ4) {
+						const decompressed = decompress(compressedData, originalSize);
+						if (!decompressed) throw new Error("LZ4 decompression failed");
+						messageData = decompressed;
+						this.compressionState.messagesDecompressed++;
+						this.compressionState.bytesReceived += compressedData.length;
+						this.compressionState.uncompressedBytesReceived += messageData.length;
+					} else {
+						messageData = new Uint8Array(compressedData);
+						this.compressionState.bytesReceived += compressedData.length;
+						this.compressionState.uncompressedBytesReceived += compressedData.length;
+					}
+					const message = deserializeRpcMessage(messageData);
+					this.handleRpcMessage(message);
+				} catch (err) {
+					this.onError?.(err instanceof Error ? err : new Error(String(err)));
+				}
+			} else {
+				const messageData = this.pendingBuffer.subarray(4, totalLength);
+				this.pendingBuffer = this.pendingBuffer.subarray(totalLength);
+				this.hasPendingLength = false;
+				try {
+					const message = deserializeRpcMessage(new Uint8Array(messageData));
+					this.handleRpcMessage(message);
+				} catch (err) {
+					this.onError?.(err instanceof Error ? err : new Error(String(err)));
+				}
 			}
 		}
 	}
@@ -1973,10 +2573,31 @@ var TcpTransport = class TcpTransport {
 	}
 	async send(message) {
 		if (!this.socket || this.socket.readyState !== "open") throw new Error("Socket not connected");
+		if (!this.negotiationComplete) throw new Error("Capability negotiation not complete");
 		const data = serializeRpcMessage(message);
-		const frame = Buffer.allocUnsafe(4 + data.length);
-		frame.writeUInt32LE(data.length, 0);
-		frame.set(data, 4);
+		const shouldCompress = this.compressionEnabled && data.length >= this.compressionConfig.thresholdBytes;
+		let frame;
+		if (shouldCompress) {
+			const compressed = compress(data, { threshold: 0 });
+			if (!compressed) throw new Error("Compression failed");
+			const frameLength = 16 + compressed.length;
+			frame = Buffer.allocUnsafe(4 + frameLength);
+			frame.writeUInt32LE(frameLength, 0);
+			frame.writeUInt32LE(FRAME_MAGIC, 4);
+			frame.writeUInt32LE(data.length, 8);
+			frame.writeUInt32LE(compressed.length, 12);
+			frame.writeUInt32LE(ALGORITHM_LZ4, 16);
+			frame.set(compressed, 20);
+			this.compressionState.bytesSent += compressed.length;
+			this.compressionState.uncompressedBytesSent += data.length;
+			this.compressionState.messagesCompressed++;
+		} else {
+			frame = Buffer.allocUnsafe(4 + data.length);
+			frame.writeUInt32LE(data.length, 0);
+			frame.set(data, 4);
+			this.compressionState.bytesSent += data.length;
+			this.compressionState.uncompressedBytesSent += data.length;
+		}
 		return new Promise((resolve, reject) => {
 			this.socket.write(frame, (err) => {
 				if (err) reject(err);
@@ -2044,6 +2665,18 @@ var EzRpcTransport = class EzRpcTransport {
 	get connected() {
 		return this._connected && this.socket !== null && !this.socket.destroyed;
 	}
+	getCompressionState() {
+		return {
+			enabled: false,
+			algorithm: "none",
+			bytesSent: 0,
+			bytesReceived: 0,
+			uncompressedBytesSent: 0,
+			uncompressedBytesReceived: 0,
+			messagesCompressed: 0,
+			messagesDecompressed: 0
+		};
+	}
 	doConnect() {
 		return new Promise((resolve, reject) => {
 			const timeout = setTimeout(() => {
@@ -9818,6 +10451,131 @@ 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
+	};
+}
+/**
+* Check if data is a compression frame (has LZ4 magic)
+* Works with both Buffer and Uint8Array
+*/
+function isCompressionFrame(data) {
+	return hasFrameMagic(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+}
+/**
+* Try to decompress, return original if not compressed or decompression fails
+* Works with both Buffer and Uint8Array
+* Assumes data has LZ4 frame header (created by compressFrame)
+*/
+function tryDecompress(data) {
+	const uint8Data = data instanceof Buffer ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : data;
+	return decompressFrame(uint8Data, uncompress) ?? uint8Data;
+}
+/**
+* Default compression configuration
+*/
+const DEFAULT_COMPRESSION_CONFIG = createCompressionConfig();
+
 //#endregion
 //#region src/proxy/websocket-proxy.ts
 /**
@@ -9826,6 +10584,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 node_events.EventEmitter {
 	ws;
@@ -9833,16 +10612,22 @@ var ProxyConnection = class extends node_events.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();
 	}
@@ -9870,6 +10655,7 @@ var ProxyConnection = class extends node_events.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) => {
@@ -9889,29 +10675,78 @@ var ProxyConnection = class extends node_events.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) {
@@ -9928,6 +10763,10 @@ var ProxyConnection = class extends node_events.EventEmitter {
 		this.emit("closed");
 	}
 };
+/**
+* WebSocket-to-TCP Proxy server
+* Manages multiple proxy connections
+*/
 var CapnpWebSocketProxy = class extends node_events.EventEmitter {
 	wss;
 	connections = /* @__PURE__ */ new Map();
@@ -9985,6 +10824,9 @@ if (require("url").pathToFileURL(__filename).href === `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":
@@ -10001,6 +10843,17 @@ if (require("url").pathToFileURL(__filename).href === `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(`
@@ -10009,13 +10862,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);
 	}
@@ -10023,11 +10888,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()}`);
 	});
@@ -10049,6 +10929,7 @@ exports.BulkTransferManager = BulkTransferManager;
 exports.CapnpWebSocketProxy = CapnpWebSocketProxy;
 exports.ConnectionManager = ConnectionManager;
 exports.DEFAULT_BULK_CONFIG = DEFAULT_BULK_CONFIG;
+exports.DEFAULT_COMPRESSION_CONFIG = DEFAULT_COMPRESSION_CONFIG;
 exports.DEFAULT_ESCROW_CONFIG = DEFAULT_ESCROW_CONFIG;
 exports.DEFAULT_FLOW_CONTROL = DEFAULT_FLOW_CONTROL;
 exports.DEFAULT_JOIN_OPTIONS = DEFAULT_JOIN_OPTIONS;
@@ -10059,6 +10940,7 @@ exports.DropPolicy = DropPolicy;
 exports.ElementSize = ElementSize;
 exports.ExportTable = require_rpc_connection.ExportTable;
 exports.EzRpcTransport = EzRpcTransport;
+exports.FrameFlags = FrameFlags;
 exports.ImportTable = require_rpc_connection.ImportTable;
 exports.Level3Handlers = Level3Handlers;
 exports.Level4Handlers = Level4Handlers;
@@ -10097,8 +10979,11 @@ exports.UnionBuilder = UnionBuilder;
 exports.UnionReader = UnionReader;
 exports.WORD_SIZE = WORD_SIZE;
 exports.WebSocketTransport = WebSocketTransport;
+exports.compress = compress;
 exports.configureGlobalMemoryPool = configureGlobalMemoryPool;
 exports.createBulkTransferManager = createBulkTransferManager;
+exports.createCompressionConfig = createCompressionConfig;
+exports.createCompressionStats = createCompressionStats;
 exports.createDynamicReader = createDynamicReader;
 exports.createDynamicReaderByTypeId = createDynamicReaderByTypeId;
 exports.createDynamicReaderFromStruct = createDynamicReaderFromStruct;
@@ -10126,17 +11011,20 @@ exports.deserializeSturdyRef = deserializeSturdyRef;
 exports.disableDebug = require_rpc_connection.disableDebug;
 exports.dumpDynamicReader = dumpDynamicReader;
 exports.enableDebug = require_rpc_connection.enableDebug;
+exports.encodeFarPointer = encodeFarPointer;
 exports.encodeListPointer = encodeListPointer;
 exports.encodeStructPointer = encodeStructPointer;
 exports.fastCopy = fastCopy;
 exports.generateProvisionId = generateProvisionId;
 exports.generateVatId = generateVatId;
 exports.getGlobalMemoryPool = getGlobalMemoryPool;
+exports.isCompressionFrame = isCompressionFrame;
 exports.isDebugEnabled = require_rpc_connection.isDebugEnabled;
 exports.isPipelineClient = require_rpc_connection.isPipelineClient;
 exports.isSameBuffer = isSameBuffer;
 exports.isStream = isStream;
 exports.isSturdyRefValid = isSturdyRefValid;
+exports.parseFrameHeader = parseFrameHeader;
 exports.parseSchemaNodes = require_rpc_connection.parseSchemaNodes;
 exports.serializeDynamic = serializeDynamic;
 exports.serializeDynamicByTypeId = serializeDynamicByTypeId;
@@ -10148,4 +11036,6 @@ exports.serializeSchemaRequest = require_rpc_connection.serializeSchemaRequest;
 exports.serializeSchemaResponse = require_rpc_connection.serializeSchemaResponse;
 exports.serializeSturdyRef = serializeSturdyRef;
 exports.supportsStreaming = supportsStreaming;
+exports.tryDecompress = tryDecompress;
+exports.uncompress = uncompress;
 //# sourceMappingURL=index.cjs.map