@naeemo/capnp 0.5.0 → 0.5.2

package/dist/index.cjs

@@ -1,5 +1,34 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_rpc_connection = require('./rpc-connection-CnyIwb0Z.js');
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_rpc_connection = require('./rpc-connection-_eHtWsk2.js');
+let node_net = require("node:net");
+node_net = __toESM(node_net);
 
 //#region src/core/pointer.ts
 /**
@@ -128,6 +157,7 @@ var Segment = class Segment {
 	*/
 	getWord(wordOffset) {
 		const byteOffset = wordOffset * WORD_SIZE;
+		if (byteOffset + 8 > this._size) throw new Error(`Offset ${wordOffset} is outside the bounds of the segment (${this.wordCount} words)`);
 		const low = BigInt(this.view.getUint32(byteOffset, true));
 		return BigInt(this.view.getUint32(byteOffset + 4, true)) << BigInt(32) | low;
 	}
@@ -136,6 +166,7 @@ var Segment = class Segment {
 	*/
 	setWord(wordOffset, value) {
 		const byteOffset = wordOffset * WORD_SIZE;
+		if (byteOffset + 8 > this.buffer.byteLength) throw new Error(`Offset ${wordOffset} is outside the bounds of the segment`);
 		this.view.setUint32(byteOffset, Number(value & BigInt(4294967295)), true);
 		this.view.setUint32(byteOffset + 4, Number(value >> BigInt(32)), true);
 	}
@@ -637,73 +668,113 @@ var StructReader = class StructReader {
 	getBool(bitOffset) {
 		const byteOffset = Math.floor(bitOffset / 8);
 		const bitInByte = bitOffset % 8;
-		return (this.message.getSegment(this.segmentIndex).dataView.getUint8(this.wordOffset * WORD_SIZE + byteOffset) & 1 << bitInByte) !== 0;
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return false;
+		return (segment.dataView.getUint8(dataOffset) & 1 << bitInByte) !== 0;
 	}
 	/**
 	* 获取 int8 字段
 	*/
 	getInt8(byteOffset) {
-		return this.message.getSegment(this.segmentIndex).dataView.getInt8(this.wordOffset * WORD_SIZE + byteOffset);
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return 0;
+		return segment.dataView.getInt8(dataOffset);
 	}
 	/**
 	* 获取 int16 字段
 	*/
 	getInt16(byteOffset) {
-		return this.message.getSegment(this.segmentIndex).dataView.getInt16(this.wordOffset * WORD_SIZE + byteOffset, true);
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 2 > dataSectionEnd) return 0;
+		return segment.dataView.getInt16(dataOffset, true);
 	}
 	/**
 	* 获取 int32 字段
 	*/
 	getInt32(byteOffset) {
-		return this.message.getSegment(this.segmentIndex).dataView.getInt32(this.wordOffset * WORD_SIZE + byteOffset, true);
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
+		return segment.dataView.getInt32(dataOffset, true);
 	}
 	/**
 	* 获取 int64 字段
 	*/
 	getInt64(byteOffset) {
 		const segment = this.message.getSegment(this.segmentIndex);
-		const offset = this.wordOffset * WORD_SIZE + byteOffset;
-		const low = BigInt(segment.dataView.getUint32(offset, true));
-		return BigInt(segment.dataView.getInt32(offset + 4, true)) << BigInt(32) | low;
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return BigInt(0);
+		const low = BigInt(segment.dataView.getUint32(dataOffset, true));
+		return BigInt(segment.dataView.getInt32(dataOffset + 4, true)) << BigInt(32) | low;
 	}
 	/**
 	* 获取 uint8 字段
 	*/
 	getUint8(byteOffset) {
-		return this.message.getSegment(this.segmentIndex).dataView.getUint8(this.wordOffset * WORD_SIZE + byteOffset);
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return 0;
+		return segment.dataView.getUint8(dataOffset);
 	}
 	/**
 	* 获取 uint16 字段
 	*/
 	getUint16(byteOffset) {
-		return this.message.getSegment(this.segmentIndex).dataView.getUint16(this.wordOffset * WORD_SIZE + byteOffset, true);
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 2 > dataSectionEnd) return 0;
+		return segment.dataView.getUint16(dataOffset, true);
 	}
 	/**
 	* 获取 uint32 字段
 	*/
 	getUint32(byteOffset) {
-		return this.message.getSegment(this.segmentIndex).dataView.getUint32(this.wordOffset * WORD_SIZE + byteOffset, true);
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
+		return segment.dataView.getUint32(dataOffset, true);
 	}
 	/**
 	* 获取 uint64 字段
 	*/
 	getUint64(byteOffset) {
 		const segment = this.message.getSegment(this.segmentIndex);
-		const offset = this.wordOffset * WORD_SIZE + byteOffset;
-		const low = BigInt(segment.dataView.getUint32(offset, true));
-		return BigInt(segment.dataView.getUint32(offset + 4, true)) << BigInt(32) | low;
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return BigInt(0);
+		const low = BigInt(segment.dataView.getUint32(dataOffset, true));
+		return BigInt(segment.dataView.getUint32(dataOffset + 4, true)) << BigInt(32) | low;
 	}
 	/**
 	* 获取 float32 字段
 	*/
 	getFloat32(byteOffset) {
-		return this.message.getSegment(this.segmentIndex).dataView.getFloat32(this.wordOffset * WORD_SIZE + byteOffset, true);
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
+		return segment.dataView.getFloat32(dataOffset, true);
 	}
 	/**
 	* 获取 float64 字段
 	*/
 	getFloat64(byteOffset) {
-		return this.message.getSegment(this.segmentIndex).dataView.getFloat64(this.wordOffset * WORD_SIZE + byteOffset, true);
+		const segment = this.message.getSegment(this.segmentIndex);
+		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
+		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
+		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return 0;
+		return segment.dataView.getFloat64(dataOffset, true);
 	}
 	/**
 	* 获取文本字段
@@ -748,13 +819,18 @@ var StructReader = class StructReader {
 		let actualStructSize = structSize;
 		const segment = this.message.getSegment(segmentIndex);
 		if (listPtr.elementSize === ElementSize.COMPOSITE) {
-			const tagWord = segment.getWord(targetOffset);
-			elementCount = Number(tagWord & BigInt(4294967295));
-			actualStructSize = {
-				dataWords: Number(tagWord >> BigInt(32) & BigInt(65535)),
-				pointerCount: Number(tagWord >> BigInt(48) & BigInt(65535))
-			};
-			targetOffset += 1;
+			if (targetOffset < 0 || targetOffset >= segment.wordCount) return;
+			try {
+				const tagWord = segment.getWord(targetOffset);
+				elementCount = Number(tagWord & BigInt(4294967295));
+				actualStructSize = {
+					dataWords: Number(tagWord >> BigInt(32) & BigInt(65535)),
+					pointerCount: Number(tagWord >> BigInt(48) & BigInt(65535))
+				};
+				targetOffset += 1;
+			} catch {
+				return;
+			}
 		}
 		return new ListReader(this.message, segmentIndex, listPtr.elementSize, elementCount, actualStructSize, targetOffset);
 	}
@@ -1694,6 +1770,316 @@ var WebSocketTransport = class WebSocketTransport {
 	}
 };
 
+//#endregion
+//#region src/rpc/tcp-transport.ts
+/**
+* TCP Transport Implementation for Node.js
+*
+* Implements RpcTransport over raw TCP socket for C++ interop testing.
+* This allows direct communication with the official Cap'n Proto C++ implementation.
+*/
+/**
+* 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]
+*/
+var TcpTransport = class TcpTransport {
+	socket = null;
+	messageQueue = [];
+	receiveQueue = [];
+	_connected = false;
+	pendingBuffer = Buffer.alloc(0);
+	pendingLength = 0;
+	hasPendingLength = false;
+	onClose;
+	onError;
+	constructor(host, port, options = {}) {
+		this.host = host;
+		this.port = port;
+		this.options = options;
+	}
+	static async connect(host, port, options) {
+		const transport = new TcpTransport(host, port, options);
+		await transport.connect();
+		return transport;
+	}
+	static fromSocket(socket, options) {
+		const transport = new TcpTransport("", 0, options);
+		transport.attachSocket(socket);
+		return transport;
+	}
+	get connected() {
+		return this._connected && this.socket?.readyState === "open";
+	}
+	connect() {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.socket?.destroy();
+				reject(/* @__PURE__ */ new Error("Connection timeout"));
+			}, this.options.connectTimeoutMs ?? 1e4);
+			this.socket = new node_net.Socket();
+			this.socket.on("connect", () => {
+				clearTimeout(timeout);
+				this._connected = true;
+				resolve();
+			});
+			this.socket.on("data", (data) => {
+				this.handleData(data);
+			});
+			this.socket.on("close", (hadError) => {
+				this._connected = false;
+				this.flushReceiveQueue(null);
+				if (hadError) this.onClose?.(/* @__PURE__ */ new Error("Connection closed with error"));
+				else this.onClose?.();
+			});
+			this.socket.on("error", (err) => {
+				clearTimeout(timeout);
+				this._connected = false;
+				this.onError?.(err);
+				reject(err);
+			});
+			this.socket.on("end", () => {
+				this._connected = false;
+			});
+			this.socket.connect(this.port, this.host);
+		});
+	}
+	attachSocket(socket) {
+		this.socket = socket;
+		this._connected = socket.readyState === "open";
+		socket.on("data", (data) => {
+			this.handleData(data);
+		});
+		socket.on("close", (hadError) => {
+			this._connected = false;
+			this.flushReceiveQueue(null);
+			if (hadError) this.onClose?.(/* @__PURE__ */ new Error("Connection closed with error"));
+			else this.onClose?.();
+		});
+		socket.on("error", (err) => {
+			this._connected = false;
+			this.onError?.(err);
+		});
+		socket.on("end", () => {
+			this._connected = false;
+		});
+	}
+	handleData(data) {
+		this.pendingBuffer = Buffer.concat([this.pendingBuffer, data]);
+		while (this.pendingBuffer.length >= 4) {
+			if (!this.hasPendingLength) {
+				this.pendingLength = this.pendingBuffer.readUInt32LE(0);
+				this.hasPendingLength = true;
+				if (this.pendingLength > 64 * 1024 * 1024) {
+					this.onError?.(/* @__PURE__ */ new Error(`Message too large: ${this.pendingLength} bytes`));
+					this.close(/* @__PURE__ */ new Error("Message too large"));
+					return;
+				}
+			}
+			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)));
+			}
+		}
+	}
+	handleRpcMessage(message) {
+		if (this.receiveQueue.length > 0) {
+			const { resolve } = this.receiveQueue.shift();
+			resolve(message);
+		} else this.messageQueue.push(message);
+	}
+	async send(message) {
+		if (!this.socket || this.socket.readyState !== "open") throw new Error("Socket not connected");
+		const data = serializeRpcMessage(message);
+		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();
+			});
+		});
+	}
+	async receive() {
+		if (this.messageQueue.length > 0) return this.messageQueue.shift();
+		if (!this._connected) return null;
+		return new Promise((resolve, reject) => {
+			this.receiveQueue.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	close(reason) {
+		this._connected = false;
+		this.socket?.end();
+		this.socket?.destroy();
+		this.flushReceiveQueue(null);
+		this.onClose?.(reason);
+	}
+	flushReceiveQueue(value) {
+		while (this.receiveQueue.length > 0) {
+			const { resolve } = this.receiveQueue.shift();
+			resolve(value);
+		}
+	}
+};
+
+//#endregion
+//#region src/rpc/ezrpc-transport.ts
+/**
+* EzRpc TCP Transport
+*
+* Implements RpcTransport over raw TCP socket for C++ EzRpc compatibility.
+* Does NOT use length-prefixed framing - sends raw Cap'n Proto messages.
+*/
+/**
+* EzRpc TCP Transport
+*
+* Compatible with Cap'n Proto C++ EzRpcServer/EzRpcClient.
+* Sends raw Cap'n Proto messages without length prefix.
+*/
+var EzRpcTransport = class EzRpcTransport {
+	socket = null;
+	messageQueue = [];
+	receiveQueue = [];
+	_connected = false;
+	pendingBuffer = Buffer.alloc(0);
+	onClose;
+	onError;
+	constructor(host, port, options = {}) {
+		this.host = host;
+		this.port = port;
+		this.options = options;
+	}
+	static async connect(host, port, options) {
+		const transport = new EzRpcTransport(host, port, options);
+		await transport.doConnect();
+		return transport;
+	}
+	get connected() {
+		return this._connected && this.socket !== null && !this.socket.destroyed;
+	}
+	doConnect() {
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.socket?.destroy();
+				reject(/* @__PURE__ */ new Error(`Connection timeout: failed to connect to ${this.host}:${this.port}`));
+			}, this.options.connectTimeoutMs ?? 1e4);
+			this.socket = new node_net.Socket();
+			this.socket.on("connect", () => {
+				clearTimeout(timeout);
+				this._connected = true;
+				resolve();
+			});
+			this.socket.on("data", (data) => {
+				try {
+					this.handleData(data);
+				} catch (err) {
+					this.onError?.(err instanceof Error ? err : new Error(String(err)));
+				}
+			});
+			this.socket.on("close", (hadError) => {
+				const wasConnected = this._connected;
+				this._connected = false;
+				const error = hadError ? /* @__PURE__ */ new Error("Connection closed with error") : /* @__PURE__ */ new Error("Connection closed");
+				this.flushReceiveQueueWithError(error);
+				if (wasConnected) this.onClose?.(hadError ? error : void 0);
+			});
+			this.socket.on("error", (err) => {
+				clearTimeout(timeout);
+				this._connected = false;
+				this.flushReceiveQueueWithError(err);
+				this.onError?.(err);
+				reject(err);
+			});
+			this.socket.connect(this.port, this.host);
+		});
+	}
+	handleData(data) {
+		if (this.pendingBuffer.length > 0) this.pendingBuffer = Buffer.concat([this.pendingBuffer, data]);
+		else this.pendingBuffer = Buffer.from(data);
+		while (this.pendingBuffer.length >= 8) {
+			const segmentCount = this.pendingBuffer.readUInt32LE(0) + 1;
+			const firstSegmentSize = this.pendingBuffer.readUInt32LE(4);
+			let headerSize = 8;
+			if (segmentCount > 1) headerSize += (segmentCount - 1) * 4;
+			const messageSize = headerSize + firstSegmentSize * 8;
+			if (this.pendingBuffer.length < messageSize) break;
+			const messageData = this.pendingBuffer.subarray(0, messageSize);
+			this.pendingBuffer = this.pendingBuffer.subarray(messageSize);
+			try {
+				const message = deserializeRpcMessage(new Uint8Array(messageData));
+				if (this.receiveQueue.length > 0) {
+					const { resolve } = this.receiveQueue.shift();
+					resolve(message);
+				} else this.messageQueue.push(message);
+			} catch (err) {
+				this.onError?.(err instanceof Error ? err : new Error(String(err)));
+			}
+		}
+	}
+	async send(message) {
+		if (!this.connected) throw new Error(`Cannot send: socket not connected to ${this.host}:${this.port}`);
+		const data = serializeRpcMessage(message);
+		return new Promise((resolve, reject) => {
+			this.socket.write(Buffer.from(data), (err) => {
+				if (err) reject(/* @__PURE__ */ new Error(`Failed to send message: ${err.message}`));
+				else resolve();
+			});
+		});
+	}
+	async receive() {
+		if (this.messageQueue.length > 0) return this.messageQueue.shift();
+		if (!this.connected) return null;
+		return new Promise((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				const index = this.receiveQueue.findIndex((item) => item.resolve === resolve);
+				if (index !== -1) this.receiveQueue.splice(index, 1);
+				reject(/* @__PURE__ */ new Error("Receive timeout"));
+			}, 3e4);
+			this.receiveQueue.push({
+				resolve: (msg) => {
+					clearTimeout(timeoutId);
+					resolve(msg);
+				},
+				reject: (err) => {
+					clearTimeout(timeoutId);
+					reject(err);
+				}
+			});
+		});
+	}
+	close(reason) {
+		this._connected = false;
+		this.socket?.end();
+		this.socket?.destroy();
+		this.flushReceiveQueue(null);
+		this.onClose?.(reason);
+	}
+	flushReceiveQueueWithError(error) {
+		while (this.receiveQueue.length > 0) {
+			const { reject } = this.receiveQueue.shift();
+			reject(error);
+		}
+	}
+	flushReceiveQueue(value) {
+		while (this.receiveQueue.length > 0) {
+			const { resolve } = this.receiveQueue.shift();
+			resolve(value);
+		}
+	}
+};
+
 //#endregion
 //#region src/rpc/capability-client.ts
 /** Base class for capability client implementations */
@@ -2306,7 +2692,7 @@ var ConnectionManager = class {
 		}
 	}
 	async doEstablishConnection(vatId, address) {
-		const { RpcConnection } = await Promise.resolve().then(() => require("./rpc-connection-CnyIwb0Z.js")).then((n) => n.rpc_connection_exports);
+		const { RpcConnection } = await Promise.resolve().then(() => require("./rpc-connection-CDzawjwJ.js"));
 		const connection = new RpcConnection(await this.options.connectionFactory(vatId, address), this.options.connectionOptions);
 		await connection.start();
 		this.registerConnection(vatId, connection);
@@ -5845,6 +6231,7 @@ exports.DEFAULT_STREAMING_CAPABILITIES = DEFAULT_STREAMING_CAPABILITIES;
 exports.DropPolicy = DropPolicy;
 exports.ElementSize = ElementSize;
 exports.ExportTable = require_rpc_connection.ExportTable;
+exports.EzRpcTransport = EzRpcTransport;
 exports.ImportTable = require_rpc_connection.ImportTable;
 exports.Level3Handlers = Level3Handlers;
 exports.Level4Handlers = Level4Handlers;
@@ -5878,6 +6265,7 @@ exports.StreamingRpcConnection = StreamingRpcConnection;
 exports.StructBuilder = StructBuilder;
 exports.StructReader = StructReader;
 exports.SturdyRefManager = SturdyRefManager;
+exports.TcpTransport = TcpTransport;
 exports.UnionBuilder = UnionBuilder;
 exports.UnionReader = UnionReader;
 exports.WORD_SIZE = WORD_SIZE;