@naeemo/capnp 0.5.0 → 0.5.2

package/dist/index.js

@@ -1,5 +1,6 @@
 import { C as QuestionTable, S as ImportTable, _ as QueuedCallManager, a as serializeGetSchemaParams, b as AnswerTable, c as serializeSchemaRequest, d as parseSchemaNodes, f as SchemaFormat, g as PipelineResolutionTracker, h as PipelineOpTracker, i as deserializeSchemaResponse, l as serializeSchemaResponse, m as PIPELINE_CLIENT_SYMBOL, n as SCHEMA_MESSAGE_TYPES, o as serializeGetSchemaResults, p as SchemaNodeType, r as deserializeSchemaRequest, s as serializeListSchemasResults, t as RpcConnection, u as createSchemaRegistry, v as createPipelineClient, x as ExportTable, y as isPipelineClient } from "./rpc-connection-C3-uEtpd.js";
 import { createRequire } from "node:module";
+import * as net from "node:net";
 
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -132,6 +133,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;
 	}
@@ -140,6 +142,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);
 	}
@@ -641,73 +644,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);
 	}
 	/**
 	* 获取文本字段
@@ -752,13 +795,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);
 	}
@@ -1698,6 +1746,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 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 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 */
@@ -2310,7 +2668,7 @@ var ConnectionManager = class {
 		}
 	}
 	async doEstablishConnection(vatId, address) {
-		const { RpcConnection } = await import("./rpc-connection-BPkslKv3.js");
+		const { RpcConnection } = await import("./rpc-connection-jIPnPyT6.js");
 		const connection = new RpcConnection(await this.options.connectionFactory(vatId, address), this.options.connectionOptions);
 		await connection.start();
 		this.registerConnection(vatId, connection);
@@ -5834,5 +6192,5 @@ var SchemaCapabilityClient = class {
 };
 
 //#endregion
-export { AnswerTable, BaseCapabilityClient, BulkTransfer, BulkTransferManager, ConnectionManager, DEFAULT_BULK_CONFIG, DEFAULT_ESCROW_CONFIG, DEFAULT_FLOW_CONTROL, DEFAULT_JOIN_OPTIONS, DEFAULT_JOIN_SECURITY_POLICY, DEFAULT_REALTIME_CONFIG, DEFAULT_STREAMING_CAPABILITIES, DropPolicy, ElementSize, ExportTable, ImportTable, Level3Handlers, Level4Handlers, ListBuilder, ListReader, MemoryPool, MessageBuilder, MessageReader, MultiSegmentMessageBuilder, OptimizedRpcMessageBuilder, PIPELINE_CLIENT_SYMBOL, PipelineOpTracker, PipelineResolutionTracker, PointerTag, QuestionTable, QueuedCallManager, RealtimeStream, RealtimeStreamManager, RestoreHandler, RpcConnection, SCHEMA_MESSAGE_TYPES, SchemaCapabilityClient, SchemaCapabilityServer, SchemaFormat, Segment, Stream, StreamManager, StreamPriority, StreamType, StreamingRpcConnection, StructBuilder, StructReader, SturdyRefManager, UnionBuilder, UnionReader, WORD_SIZE, WebSocketTransport, configureGlobalMemoryPool, createBulkTransferManager, createDynamicReader, createDynamicReaderByTypeId, createDynamicReaderFromStruct, createDynamicWriter, createDynamicWriterByTypeId, createNestedDynamicWriter, createPipelineClient, createProvisionId, createRealtimeStreamManager, createRecipientId, createSchemaRegistry, createStream, createStreamManager, createStreamingConnection, createSturdyRef, createThirdPartyCapId, createUnionBuilder, createUnionReader, createZeroCopyView, decodePointer, deserializeRpcMessage, deserializeSchemaRequest, deserializeSchemaResponse, deserializeSturdyRef, dumpDynamicReader, encodeListPointer, encodeStructPointer, fastCopy, generateProvisionId, generateVatId, getGlobalMemoryPool, isPipelineClient, isSameBuffer, isStream, isSturdyRefValid, parseSchemaNodes, serializeDynamic, serializeDynamicByTypeId, serializeGetSchemaParams, serializeGetSchemaResults, serializeListSchemasResults, serializeRpcMessage, serializeSchemaRequest, serializeSchemaResponse, serializeSturdyRef, supportsStreaming };
+export { AnswerTable, BaseCapabilityClient, BulkTransfer, BulkTransferManager, ConnectionManager, DEFAULT_BULK_CONFIG, DEFAULT_ESCROW_CONFIG, DEFAULT_FLOW_CONTROL, DEFAULT_JOIN_OPTIONS, DEFAULT_JOIN_SECURITY_POLICY, DEFAULT_REALTIME_CONFIG, DEFAULT_STREAMING_CAPABILITIES, DropPolicy, ElementSize, ExportTable, EzRpcTransport, ImportTable, Level3Handlers, Level4Handlers, ListBuilder, ListReader, MemoryPool, MessageBuilder, MessageReader, MultiSegmentMessageBuilder, OptimizedRpcMessageBuilder, PIPELINE_CLIENT_SYMBOL, PipelineOpTracker, PipelineResolutionTracker, PointerTag, QuestionTable, QueuedCallManager, RealtimeStream, RealtimeStreamManager, RestoreHandler, RpcConnection, SCHEMA_MESSAGE_TYPES, SchemaCapabilityClient, SchemaCapabilityServer, SchemaFormat, Segment, Stream, StreamManager, StreamPriority, StreamType, StreamingRpcConnection, StructBuilder, StructReader, SturdyRefManager, TcpTransport, UnionBuilder, UnionReader, WORD_SIZE, WebSocketTransport, configureGlobalMemoryPool, createBulkTransferManager, createDynamicReader, createDynamicReaderByTypeId, createDynamicReaderFromStruct, createDynamicWriter, createDynamicWriterByTypeId, createNestedDynamicWriter, createPipelineClient, createProvisionId, createRealtimeStreamManager, createRecipientId, createSchemaRegistry, createStream, createStreamManager, createStreamingConnection, createSturdyRef, createThirdPartyCapId, createUnionBuilder, createUnionReader, createZeroCopyView, decodePointer, deserializeRpcMessage, deserializeSchemaRequest, deserializeSchemaResponse, deserializeSturdyRef, dumpDynamicReader, encodeListPointer, encodeStructPointer, fastCopy, generateProvisionId, generateVatId, getGlobalMemoryPool, isPipelineClient, isSameBuffer, isStream, isSturdyRefValid, parseSchemaNodes, serializeDynamic, serializeDynamicByTypeId, serializeGetSchemaParams, serializeGetSchemaResults, serializeListSchemasResults, serializeRpcMessage, serializeSchemaRequest, serializeSchemaResponse, serializeSturdyRef, supportsStreaming };
 //# sourceMappingURL=index.js.map