@naeemo/capnp 0.4.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-BKWQQ7f9.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-BKWQQ7f9.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);
@@ -4901,6 +5287,934 @@ function supportsStreaming(connection) {
 	return connection instanceof StreamingRpcConnection;
 }
 
+//#endregion
+//#region src/rpc/dynamic-reader.ts
+/**
+* Create a dynamic reader from schema and buffer
+*
+* @param schema - The schema node describing the struct type
+* @param buffer - The Cap'n Proto message buffer
+* @returns A DynamicReader for accessing the message fields
+*/
+function createDynamicReader(schema, buffer) {
+	const messageReader = new MessageReader(buffer);
+	if (!schema.structInfo) throw new Error(`Schema node ${schema.displayName} is not a struct`);
+	const { dataWordCount, pointerCount } = schema.structInfo;
+	return new DynamicReaderImpl(schema, messageReader.getRoot(dataWordCount, pointerCount), messageReader);
+}
+/**
+* Create a dynamic reader from an existing StructReader
+*
+* @param schema - The schema node describing the struct type
+* @param structReader - The StructReader to wrap
+* @param messageReader - The underlying MessageReader
+* @returns A DynamicReader for accessing the message fields
+*/
+function createDynamicReaderFromStruct(schema, structReader, messageReader) {
+	return new DynamicReaderImpl(schema, structReader, messageReader);
+}
+/**
+* Implementation of DynamicReader
+*/
+var DynamicReaderImpl = class {
+	fieldCache;
+	pointerOffset;
+	constructor(schema, structReader, messageReader) {
+		this.schema = schema;
+		this.structReader = structReader;
+		this.messageReader = messageReader;
+		this.fieldCache = /* @__PURE__ */ new Map();
+		this.pointerOffset = schema.structInfo?.dataWordCount ?? 0;
+		if (schema.structInfo?.fields) for (const field of schema.structInfo.fields) this.fieldCache.set(field.name, field);
+	}
+	get(fieldName) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		return this.readFieldValue(field);
+	}
+	has(fieldName) {
+		return this.fieldCache.has(fieldName);
+	}
+	getFieldNames() {
+		return Array.from(this.fieldCache.keys());
+	}
+	getSchema() {
+		return this.schema;
+	}
+	getStruct(fieldName) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) return;
+		if (field.type.kind.type !== "struct") return;
+		const pointerIndex = this.getPointerIndex(field);
+		const nestedStruct = this.structReader.getStruct(pointerIndex, 0, 0);
+		if (!nestedStruct) return;
+		return new DynamicStructReaderWithoutSchema(nestedStruct, this.messageReader);
+	}
+	getList(fieldName) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) return;
+		if (field.type.kind.type !== "list") return;
+		const pointerIndex = this.getPointerIndex(field);
+		const elementType = field.type.kind.elementType;
+		return this.readListField(pointerIndex, elementType);
+	}
+	getRawReader() {
+		return this.structReader;
+	}
+	/**
+	* Read a field value based on its type
+	*/
+	readFieldValue(field) {
+		const kind = field.type.kind;
+		switch (kind.type) {
+			case "void": return;
+			case "bool": return this.structReader.getBool(field.offset);
+			case "int8": return this.structReader.getInt8(field.offset);
+			case "int16": return this.structReader.getInt16(field.offset);
+			case "int32": return this.structReader.getInt32(field.offset);
+			case "int64": return this.structReader.getInt64(field.offset);
+			case "uint8": return this.structReader.getUint8(field.offset);
+			case "uint16": return this.structReader.getUint16(field.offset);
+			case "uint32": return this.structReader.getUint32(field.offset);
+			case "uint64": return this.structReader.getUint64(field.offset);
+			case "float32": return this.structReader.getFloat32(field.offset);
+			case "float64": return this.structReader.getFloat64(field.offset);
+			case "text": return this.readTextField(field);
+			case "data": return this.readDataField(field);
+			case "list": return this.readListFieldBySchema(field);
+			case "enum": return this.readEnumField(field);
+			case "struct": return this.readStructField(field);
+			case "interface": return this.readInterfaceField(field);
+			case "anyPointer": return this.readAnyPointerField(field);
+			default: throw new Error(`Unsupported field type: ${kind.type}`);
+		}
+	}
+	/**
+	* Get the pointer index for a field
+	* In Cap'n Proto, pointer fields have offsets that start from 0 for the first pointer
+	* The offset is measured in bits from the start of the data section
+	* For pointer fields, offset = dataWordCount * 64 + pointerIndex * 64
+	* So pointerIndex = (offset - dataWordCount * 64) / 64
+	*/
+	getPointerIndex(field) {
+		const dataSectionBits = (this.schema.structInfo?.dataWordCount ?? 0) * 64;
+		return (field.offset - dataSectionBits) / 64;
+	}
+	/**
+	* Read a text field
+	*/
+	readTextField(field) {
+		const pointerIndex = this.getPointerIndex(field);
+		return this.structReader.getText(pointerIndex);
+	}
+	/**
+	* Read a data field
+	*/
+	readDataField(field) {
+		const pointerIndex = this.getPointerIndex(field);
+		const text = this.structReader.getText(pointerIndex);
+		return new TextEncoder().encode(text);
+	}
+	/**
+	* Read a list field using schema information
+	*/
+	readListFieldBySchema(field) {
+		if (field.type.kind.type !== "list") throw new Error(`Field '${field.name}' is not a list type`);
+		const pointerIndex = this.getPointerIndex(field);
+		const elementType = field.type.kind.elementType;
+		return this.readListField(pointerIndex, elementType);
+	}
+	/**
+	* Read a list field
+	*/
+	readListField(pointerIndex, elementType) {
+		const elementSize = this.mapTypeToElementSize(elementType);
+		const listReader = this.structReader.getList(pointerIndex, elementSize);
+		if (!listReader) return [];
+		const result = [];
+		const length = listReader.length;
+		for (let i = 0; i < length; i++) result.push(this.readListElement(listReader, i, elementType));
+		return result;
+	}
+	/**
+	* Map schema type to ElementSize
+	*/
+	mapTypeToElementSize(type) {
+		switch (type.kind.type) {
+			case "void": return ElementSize.VOID;
+			case "bool": return ElementSize.BIT;
+			case "int8":
+			case "uint8": return ElementSize.BYTE;
+			case "int16":
+			case "uint16": return ElementSize.TWO_BYTES;
+			case "int32":
+			case "uint32":
+			case "float32": return ElementSize.FOUR_BYTES;
+			case "int64":
+			case "uint64":
+			case "float64": return ElementSize.EIGHT_BYTES;
+			case "struct": return ElementSize.COMPOSITE;
+			default: return ElementSize.POINTER;
+		}
+	}
+	/**
+	* Read a single list element
+	*/
+	readListElement(listReader, index, elementType) {
+		switch (elementType.kind.type) {
+			case "void": return;
+			case "bool": return listReader.getPrimitive(index) !== 0;
+			case "int8": return listReader.getPrimitive(index);
+			case "int16": return listReader.getPrimitive(index);
+			case "int32": return listReader.getPrimitive(index);
+			case "int64": return listReader.getPrimitive(index);
+			case "uint8": return listReader.getPrimitive(index);
+			case "uint16": return listReader.getPrimitive(index);
+			case "uint32": return listReader.getPrimitive(index);
+			case "uint64": return listReader.getPrimitive(index);
+			case "float32": return listReader.getPrimitive(index);
+			case "float64": return listReader.getPrimitive(index);
+			case "struct": {
+				const structReader = listReader.getStruct(index);
+				if (!structReader) return void 0;
+				return new DynamicStructReaderWithoutSchema(structReader, this.messageReader);
+			}
+			default: return;
+		}
+	}
+	/**
+	* Read an enum field
+	*/
+	readEnumField(field) {
+		return this.structReader.getUint16(field.offset);
+	}
+	/**
+	* Read a struct field
+	*/
+	readStructField(field) {
+		const pointerIndex = this.getPointerIndex(field);
+		const nestedStruct = this.structReader.getStruct(pointerIndex, 0, 0);
+		if (!nestedStruct) return;
+		return new DynamicStructReaderWithoutSchema(nestedStruct, this.messageReader);
+	}
+	/**
+	* Read an interface field (capability)
+	*/
+	readInterfaceField(_field) {
+		throw new Error("Interface fields not yet supported in dynamic reader");
+	}
+	/**
+	* Read an anyPointer field
+	*/
+	readAnyPointerField(_field) {
+		throw new Error("anyPointer fields not yet supported in dynamic reader");
+	}
+};
+/**
+* A limited dynamic reader for structs without schema information
+* Provides basic field access but no type information
+*/
+var DynamicStructReaderWithoutSchema = class {
+	constructor(structReader, messageReader) {
+		this.structReader = structReader;
+		this.messageReader = messageReader;
+	}
+	get(_fieldName) {
+		throw new Error("Cannot access fields without schema information");
+	}
+	has(_fieldName) {
+		return false;
+	}
+	getFieldNames() {
+		return [];
+	}
+	getSchema() {
+		throw new Error("No schema information available");
+	}
+	getStruct(_fieldName) {}
+	getList(_fieldName) {}
+	getRawReader() {
+		return this.structReader;
+	}
+};
+/**
+* Create a dynamic reader for a specific type ID
+* This looks up the schema in a registry and creates the appropriate reader
+*
+* @param typeId - The type ID of the struct
+* @param buffer - The Cap'n Proto message buffer
+* @param schemaRegistry - A map of type IDs to schema nodes
+* @returns A DynamicReader for the message
+*/
+function createDynamicReaderByTypeId(typeId, buffer, schemaRegistry) {
+	const schema = schemaRegistry.get(typeId);
+	if (!schema) throw new Error(`Schema not found for type ID: ${typeId}`);
+	if (schema.type !== require_rpc_connection.SchemaNodeType.STRUCT) throw new Error(`Type ${typeId} is not a struct`);
+	return createDynamicReader(schema, buffer);
+}
+/**
+* Utility function to dump all fields from a dynamic reader
+* Useful for debugging and exploration
+*
+* @param reader - The DynamicReader to dump
+* @returns An object with all field names and values
+*/
+function dumpDynamicReader(reader) {
+	const result = {};
+	for (const fieldName of reader.getFieldNames()) try {
+		result[fieldName] = reader.get(fieldName);
+	} catch (error) {
+		result[fieldName] = `<error: ${error}>`;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/rpc/dynamic-writer.ts
+/**
+* Create a dynamic writer from schema
+*
+* @param schema - The schema node describing the struct type
+* @returns A DynamicWriter for setting message fields
+*/
+function createDynamicWriter(schema) {
+	if (!schema.structInfo) throw new Error(`Schema node ${schema.displayName} is not a struct`);
+	const { dataWordCount, pointerCount } = schema.structInfo;
+	const messageBuilder = new MessageBuilder();
+	return new DynamicWriterImpl(schema, messageBuilder.initRoot(dataWordCount, pointerCount), messageBuilder);
+}
+/**
+* Create a dynamic writer for a nested struct
+*
+* @param schema - The schema node describing the struct type
+* @param structBuilder - The StructBuilder to wrap
+* @param messageBuilder - The underlying MessageBuilder
+* @returns A DynamicWriter for setting message fields
+*/
+function createNestedDynamicWriter(schema, structBuilder, messageBuilder) {
+	return new DynamicWriterImpl(schema, structBuilder, messageBuilder);
+}
+/**
+* Implementation of DynamicWriter
+*/
+var DynamicWriterImpl = class {
+	fieldCache;
+	pointerOffset;
+	constructor(schema, structBuilder, messageBuilder) {
+		this.schema = schema;
+		this.structBuilder = structBuilder;
+		this.messageBuilder = messageBuilder;
+		this.fieldCache = /* @__PURE__ */ new Map();
+		this.pointerOffset = schema.structInfo?.dataWordCount ?? 0;
+		if (schema.structInfo?.fields) for (const field of schema.structInfo.fields) this.fieldCache.set(field.name, field);
+	}
+	set(fieldName, value) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		this.writeFieldValue(field, value);
+	}
+	setFields(fields) {
+		for (const [name, value] of Object.entries(fields)) this.set(name, value);
+	}
+	initStruct(fieldName) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		if (field.type.kind.type !== "struct") throw new Error(`Field '${fieldName}' is not a struct type`);
+		const pointerIndex = this.getPointerIndex(field);
+		return new DynamicWriterWithoutSchema(this.structBuilder.initStruct(pointerIndex, 0, 0), this.messageBuilder);
+	}
+	initList(fieldName, size) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		if (field.type.kind.type !== "list") throw new Error(`Field '${fieldName}' is not a list type`);
+		const pointerIndex = this.getPointerIndex(field);
+		const elementType = field.type.kind.elementType;
+		return this.createListWriter(pointerIndex, size, elementType);
+	}
+	setText(fieldName, value) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		if (field.type.kind.type !== "text") throw new Error(`Field '${fieldName}' is not a text type`);
+		const pointerIndex = this.getPointerIndex(field);
+		this.structBuilder.setText(pointerIndex, value);
+	}
+	setData(fieldName, value) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		if (field.type.kind.type !== "data") throw new Error(`Field '${fieldName}' is not a data type`);
+		const pointerIndex = this.getPointerIndex(field);
+		const textValue = new TextDecoder().decode(value);
+		this.structBuilder.setText(pointerIndex, `${textValue}\0`);
+	}
+	getSchema() {
+		return this.schema;
+	}
+	getRawBuilder() {
+		return this.structBuilder;
+	}
+	toBuffer() {
+		return this.messageBuilder.toArrayBuffer();
+	}
+	/**
+	* Write a field value based on its type
+	*/
+	writeFieldValue(field, value) {
+		const kind = field.type.kind;
+		switch (kind.type) {
+			case "void": break;
+			case "bool":
+				this.structBuilder.setBool(field.offset, Boolean(value));
+				break;
+			case "int8":
+				this.structBuilder.setInt8(field.offset, Number(value));
+				break;
+			case "int16":
+				this.structBuilder.setInt16(field.offset, Number(value));
+				break;
+			case "int32":
+				this.structBuilder.setInt32(field.offset, Number(value));
+				break;
+			case "int64":
+				this.structBuilder.setInt64(field.offset, BigInt(value));
+				break;
+			case "uint8":
+				this.structBuilder.setUint8(field.offset, Number(value));
+				break;
+			case "uint16":
+				this.structBuilder.setUint16(field.offset, Number(value));
+				break;
+			case "uint32":
+				this.structBuilder.setUint32(field.offset, Number(value));
+				break;
+			case "uint64":
+				this.structBuilder.setUint64(field.offset, BigInt(value));
+				break;
+			case "float32":
+				this.structBuilder.setFloat32(field.offset, Number(value));
+				break;
+			case "float64":
+				this.structBuilder.setFloat64(field.offset, Number(value));
+				break;
+			case "text":
+				this.setText(field.name, String(value));
+				break;
+			case "data":
+				if (value instanceof Uint8Array) this.setData(field.name, value);
+				else throw new Error(`Field '${field.name}' expects Uint8Array`);
+				break;
+			case "list":
+				if (Array.isArray(value)) this.initList(field.name, value.length).setAll(value);
+				else throw new Error(`Field '${field.name}' expects an array`);
+				break;
+			case "enum":
+				this.structBuilder.setUint16(field.offset, Number(value));
+				break;
+			case "struct":
+				if (typeof value === "object" && value !== null) {
+					const structWriter = this.initStruct(field.name);
+					if (!(value instanceof Uint8Array) && !Array.isArray(value)) structWriter.setFields(value);
+				} else throw new Error(`Field '${field.name}' expects an object`);
+				break;
+			case "interface": throw new Error("Interface fields not yet supported in dynamic writer");
+			case "anyPointer": throw new Error("anyPointer fields not yet supported in dynamic writer");
+			default: throw new Error(`Unsupported field type: ${kind.type}`);
+		}
+	}
+	/**
+	* Get the pointer index for a field
+	* In Cap'n Proto, pointer fields have offsets that start from 0 for the first pointer
+	* The offset is measured in bits from the start of the data section
+	* For pointer fields, offset = dataWordCount * 64 + pointerIndex * 64
+	* So pointerIndex = (offset - dataWordCount * 64) / 64
+	*/
+	getPointerIndex(field) {
+		const dataSectionBits = (this.schema.structInfo?.dataWordCount ?? 0) * 64;
+		return (field.offset - dataSectionBits) / 64;
+	}
+	/**
+	* Create a list writer for a field
+	*/
+	createListWriter(pointerIndex, size, elementType) {
+		const elementSize = this.mapTypeToElementSize(elementType);
+		let structSize;
+		if (elementSize === ElementSize.COMPOSITE) structSize = {
+			dataWords: 0,
+			pointerCount: 0
+		};
+		return new DynamicListWriterImpl(this.structBuilder.initList(pointerIndex, elementSize, size, structSize), elementType, this.messageBuilder);
+	}
+	/**
+	* Map schema type to ElementSize
+	*/
+	mapTypeToElementSize(type) {
+		switch (type.kind.type) {
+			case "void": return ElementSize.VOID;
+			case "bool": return ElementSize.BIT;
+			case "int8":
+			case "uint8": return ElementSize.BYTE;
+			case "int16":
+			case "uint16": return ElementSize.TWO_BYTES;
+			case "int32":
+			case "uint32":
+			case "float32": return ElementSize.FOUR_BYTES;
+			case "int64":
+			case "uint64":
+			case "float64": return ElementSize.EIGHT_BYTES;
+			case "struct": return ElementSize.COMPOSITE;
+			default: return ElementSize.POINTER;
+		}
+	}
+};
+/**
+* Implementation of DynamicListWriter
+*/
+var DynamicListWriterImpl = class {
+	constructor(listBuilder, elementType, messageBuilder) {
+		this.listBuilder = listBuilder;
+		this.elementType = elementType;
+		this.messageBuilder = messageBuilder;
+	}
+	set(index, value) {
+		if (index < 0 || index >= this.listBuilder.length) throw new Error(`Index ${index} out of bounds`);
+		const kind = this.elementType.kind;
+		switch (kind.type) {
+			case "void": break;
+			case "bool":
+				this.listBuilder.setPrimitive(index, value ? 1 : 0);
+				break;
+			case "int8":
+			case "uint8":
+			case "int16":
+			case "uint16":
+			case "int32":
+			case "uint32":
+			case "float32":
+				this.listBuilder.setPrimitive(index, Number(value));
+				break;
+			case "int64":
+			case "uint64":
+			case "float64":
+				this.listBuilder.setPrimitive(index, BigInt(value));
+				break;
+			case "struct":
+				if (typeof value === "object" && value !== null && !(value instanceof Uint8Array)) this.initStruct(index).setFields(value);
+				break;
+			default: throw new Error(`Unsupported list element type: ${kind.type}`);
+		}
+	}
+	getSize() {
+		return this.listBuilder.length;
+	}
+	getLength() {
+		return this.listBuilder.length;
+	}
+	initStruct(index) {
+		return new DynamicWriterWithoutSchema(this.listBuilder.getStruct(index), this.messageBuilder);
+	}
+	setAll(values) {
+		if (values.length > this.getSize()) throw new Error(`Cannot set ${values.length} values in list of size ${this.getSize()}`);
+		for (let i = 0; i < values.length; i++) this.set(i, values[i]);
+	}
+};
+/**
+* A limited dynamic writer for structs without full schema information
+* Provides basic field setting but no type validation
+*/
+var DynamicWriterWithoutSchema = class {
+	constructor(structBuilder, messageBuilder) {
+		this.structBuilder = structBuilder;
+		this.messageBuilder = messageBuilder;
+	}
+	set(fieldName, _value) {
+		throw new Error(`Cannot set field '${fieldName}' without schema information`);
+	}
+	setFields(_fields) {
+		throw new Error("Cannot set fields without schema information");
+	}
+	initStruct(_fieldName) {
+		throw new Error("Cannot init struct without schema information");
+	}
+	initList(_fieldName, _size) {
+		throw new Error("Cannot init list without schema information");
+	}
+	setText(_fieldName, _value) {
+		throw new Error("Cannot set text without schema information");
+	}
+	setData(_fieldName, _value) {
+		throw new Error("Cannot set data without schema information");
+	}
+	getSchema() {
+		throw new Error("No schema information available");
+	}
+	getRawBuilder() {
+		return this.structBuilder;
+	}
+	toBuffer() {
+		return this.messageBuilder.toArrayBuffer();
+	}
+};
+/**
+* Create a dynamic writer for a specific type ID
+* This looks up the schema in a registry and creates the appropriate writer
+*
+* @param typeId - The type ID of the struct
+* @param schemaRegistry - A map of type IDs to schema nodes
+* @returns A DynamicWriter for the message
+*/
+function createDynamicWriterByTypeId(typeId, schemaRegistry) {
+	const schema = schemaRegistry.get(typeId);
+	if (!schema) throw new Error(`Schema not found for type ID: ${typeId}`);
+	if (schema.type !== require_rpc_connection.SchemaNodeType.STRUCT) throw new Error(`Type ${typeId} is not a struct`);
+	return createDynamicWriter(schema);
+}
+/**
+* Utility function to create a message from a plain object
+* Uses schema information to properly serialize the data
+*
+* @param schema - The schema node describing the struct type
+* @param data - The data object to serialize
+* @returns The serialized message buffer
+*/
+function serializeDynamic(schema, data) {
+	const writer = createDynamicWriter(schema);
+	writer.setFields(data);
+	return writer.toBuffer();
+}
+/**
+* Utility function to create a message from a plain object using type ID
+*
+* @param typeId - The type ID of the struct
+* @param data - The data object to serialize
+* @param schemaRegistry - A map of type IDs to schema nodes
+* @returns The serialized message buffer
+*/
+function serializeDynamicByTypeId(typeId, data, schemaRegistry) {
+	const writer = createDynamicWriterByTypeId(typeId, schemaRegistry);
+	writer.setFields(data);
+	return writer.toBuffer();
+}
+
+//#endregion
+//#region src/rpc/schema-capability.ts
+/**
+* Server-side implementation of the SchemaCapability interface.
+* Provides schema information to remote clients.
+*/
+var SchemaCapabilityServer = class {
+	registry;
+	schemasByName;
+	/**
+	* Create a new SchemaCapabilityServer
+	* @param initialSchemas - Optional map of schemas to register initially
+	*/
+	constructor(initialSchemas) {
+		this.registry = new Map(initialSchemas);
+		this.schemasByName = /* @__PURE__ */ new Map();
+		for (const schema of this.registry.values()) this.schemasByName.set(schema.displayName, schema);
+	}
+	/**
+	* Register a schema node
+	* @param node - The schema node to register
+	*/
+	registerSchema(node) {
+		this.registry.set(node.id, node);
+		this.schemasByName.set(node.displayName, node);
+	}
+	/**
+	* Unregister a schema by ID
+	* @param typeId - The type ID to unregister
+	*/
+	unregisterSchema(typeId) {
+		const node = this.registry.get(typeId);
+		if (node) {
+			this.registry.delete(typeId);
+			this.schemasByName.delete(node.displayName);
+		}
+	}
+	/**
+	* Get schema information based on target specification
+	* @param params - GetSchemaParams containing target and format
+	* @returns GetSchemaResults with the schema payload
+	*/
+	async getSchema(params) {
+		const { target, format = require_rpc_connection.SchemaFormat.BINARY } = params;
+		let schemaData;
+		let dependencies = [];
+		switch (target.type) {
+			case "byTypeId": {
+				const node = this.registry.get(target.typeId);
+				if (!node) throw new Error(`Schema not found for type ID: ${target.typeId.toString(16)}`);
+				schemaData = this.serializeSchemaNode(node, format);
+				dependencies = this.collectDependencies(node);
+				break;
+			}
+			case "byTypeName": {
+				const node = this.schemasByName.get(target.typeName);
+				if (!node) throw new Error(`Schema not found for type name: ${target.typeName}`);
+				schemaData = this.serializeSchemaNode(node, format);
+				dependencies = this.collectDependencies(node);
+				break;
+			}
+			case "byFileId": {
+				const nodes = this.getSchemasByFileId(target.fileId);
+				schemaData = this.serializeSchemaNodes(nodes, format);
+				break;
+			}
+			case "byFileName": {
+				const nodes = this.getSchemasByFileName(target.fileName);
+				schemaData = this.serializeSchemaNodes(nodes, format);
+				break;
+			}
+			case "allSchemas": {
+				const nodes = Array.from(this.registry.values());
+				schemaData = this.serializeSchemaNodes(nodes, format);
+				break;
+			}
+			case "bootstrapInterface": {
+				const bootstrapSchema = this.findBootstrapSchema();
+				if (!bootstrapSchema) throw new Error("Bootstrap interface schema not available");
+				schemaData = this.serializeSchemaNode(bootstrapSchema, format);
+				dependencies = this.collectDependencies(bootstrapSchema);
+				break;
+			}
+			default: throw new Error(`Unsupported schema target type: ${target.type}`);
+		}
+		return { payload: {
+			schemaData,
+			format,
+			dependencies
+		} };
+	}
+	/**
+	* List all available schemas
+	* @returns ListSchemasResults with available schema information
+	*/
+	async listAvailableSchemas() {
+		const schemas = [];
+		for (const node of this.registry.values()) schemas.push({
+			typeId: node.id,
+			displayName: node.displayName,
+			fileId: node.scopeId,
+			fileName: this.inferFileName(node),
+			isInterface: node.type === require_rpc_connection.SchemaNodeType.INTERFACE,
+			isStruct: node.type === require_rpc_connection.SchemaNodeType.STRUCT,
+			isEnum: node.type === require_rpc_connection.SchemaNodeType.ENUM
+		});
+		return { schemas };
+	}
+	/**
+	* Handle a raw schema request (for RPC integration)
+	* @param requestData - The serialized SchemaRequest
+	* @returns The serialized SchemaResponse
+	*/
+	handleRequest(requestData) {
+		try {
+			const request = require_rpc_connection.deserializeSchemaRequest(requestData);
+			this.getSchema({ target: request.targetSchema });
+			throw new Error("Async handling not implemented in handleRequest");
+		} catch (error) {
+			return require_rpc_connection.serializeSchemaResponse({
+				answerId: 0,
+				result: {
+					type: "exception",
+					exception: {
+						reason: error instanceof Error ? error.message : "Unknown error",
+						type: "failed",
+						obsoleteIsCallersFault: false,
+						obsoleteDurability: 0
+					}
+				}
+			});
+		}
+	}
+	/**
+	* Get the number of registered schemas
+	*/
+	getSchemaCount() {
+		return this.registry.size;
+	}
+	/**
+	* Check if a schema is registered
+	*/
+	hasSchema(typeId) {
+		return this.registry.has(typeId);
+	}
+	serializeSchemaNode(node, format) {
+		switch (format) {
+			case require_rpc_connection.SchemaFormat.BINARY: return this.serializeToBinary([node]);
+			case require_rpc_connection.SchemaFormat.JSON: return this.serializeToJson([node]);
+			case require_rpc_connection.SchemaFormat.CAPNP: return this.serializeToCapnp([node]);
+			default: throw new Error(`Unsupported schema format: ${format}`);
+		}
+	}
+	serializeSchemaNodes(nodes, format) {
+		switch (format) {
+			case require_rpc_connection.SchemaFormat.BINARY: return this.serializeToBinary(nodes);
+			case require_rpc_connection.SchemaFormat.JSON: return this.serializeToJson(nodes);
+			case require_rpc_connection.SchemaFormat.CAPNP: return this.serializeToCapnp(nodes);
+			default: throw new Error(`Unsupported schema format: ${format}`);
+		}
+	}
+	serializeToBinary(nodes) {
+		const encoder = new TextEncoder();
+		const json = JSON.stringify(nodes, (_key, value) => {
+			if (typeof value === "bigint") return value.toString();
+			return value;
+		});
+		return encoder.encode(json);
+	}
+	serializeToJson(nodes) {
+		const encoder = new TextEncoder();
+		const json = JSON.stringify({ nodes: nodes.map((node) => ({
+			id: node.id.toString(),
+			displayName: node.displayName,
+			displayNamePrefixLength: node.displayNamePrefixLength,
+			scopeId: node.scopeId.toString(),
+			type: node.type,
+			structInfo: node.structInfo,
+			enumInfo: node.enumInfo,
+			interfaceInfo: node.interfaceInfo
+		})) });
+		return encoder.encode(json);
+	}
+	serializeToCapnp(nodes) {
+		const lines = [];
+		for (const node of nodes) if (node.structInfo) {
+			lines.push(`struct ${node.displayName} {`);
+			for (const field of node.structInfo.fields) lines.push(`  ${field.name} @${field.codeOrder} :${this.typeToCapnp(field.type)};`);
+			lines.push("}");
+		}
+		return new TextEncoder().encode(lines.join("\n"));
+	}
+	typeToCapnp(type) {
+		switch (type.kind.type) {
+			case "void": return "Void";
+			case "bool": return "Bool";
+			case "int8": return "Int8";
+			case "int16": return "Int16";
+			case "int32": return "Int32";
+			case "int64": return "Int64";
+			case "uint8": return "UInt8";
+			case "uint16": return "UInt16";
+			case "uint32": return "UInt32";
+			case "uint64": return "UInt64";
+			case "float32": return "Float32";
+			case "float64": return "Float64";
+			case "text": return "Text";
+			case "data": return "Data";
+			case "list": return "List";
+			case "enum": return "UInt16";
+			case "struct": return "AnyPointer";
+			case "interface": return "Capability";
+			default: return "AnyPointer";
+		}
+	}
+	collectDependencies(_node) {
+		return [];
+	}
+	getSchemasByFileId(fileId) {
+		return Array.from(this.registry.values()).filter((node) => node.scopeId === fileId);
+	}
+	getSchemasByFileName(fileName) {
+		return Array.from(this.registry.values()).filter((node) => {
+			return this.inferFileName(node) === fileName || node.displayName.startsWith(fileName);
+		});
+	}
+	inferFileName(node) {
+		const parts = node.displayName.split(".");
+		if (parts.length > 1) return `${parts.slice(0, -1).join("/")}.capnp`;
+		return "unknown.capnp";
+	}
+	findBootstrapSchema() {
+		for (const node of this.registry.values()) if (node.type === require_rpc_connection.SchemaNodeType.INTERFACE) return node;
+	}
+};
+/**
+* Client-side implementation for accessing remote SchemaCapability
+*/
+var SchemaCapabilityClient = class {
+	connection;
+	/**
+	* Create a new SchemaCapabilityClient
+	* @param connection - The RPC connection to use
+	*/
+	constructor(connection) {
+		this.connection = connection;
+	}
+	/**
+	* Fetch schema information from the remote server
+	* @param target - The schema target specification
+	* @param format - The desired format (defaults to BINARY)
+	* @returns The schema node
+	*/
+	async getSchema(target, format = require_rpc_connection.SchemaFormat.BINARY) {
+		if (target.type === "byTypeId") return this.connection.getDynamicSchema(target.typeId);
+		if (target.type === "byTypeName") return this.connection.getDynamicSchemaByName(target.typeName);
+		throw new Error(`Schema target type not implemented: ${target.type}`);
+	}
+	/**
+	* Fetch schema by type ID
+	* @param typeId - The type ID
+	* @returns The schema node
+	*/
+	async getSchemaById(typeId) {
+		return this.connection.getDynamicSchema(typeId);
+	}
+	/**
+	* Fetch schema by type name
+	* @param typeName - The fully qualified type name
+	* @returns The schema node
+	*/
+	async getSchemaByName(typeName) {
+		return this.connection.getDynamicSchemaByName(typeName);
+	}
+	/**
+	* List all available schemas from the remote server
+	* @returns Array of available schema information
+	*/
+	async listAvailableSchemas() {
+		return (await this.connection.listAvailableSchemas()).map((s) => ({
+			typeId: s.typeId,
+			displayName: s.displayName,
+			fileId: BigInt(0),
+			fileName: "",
+			isInterface: false,
+			isStruct: true,
+			isEnum: false
+		}));
+	}
+	/**
+	* Fetch multiple schemas at once
+	* @param typeIds - Array of type IDs to fetch
+	* @returns Map of type ID to schema node
+	*/
+	async getSchemas(typeIds) {
+		const results = /* @__PURE__ */ new Map();
+		await Promise.all(typeIds.map(async (typeId) => {
+			try {
+				const schema = await this.getSchemaById(typeId);
+				results.set(typeId, schema);
+			} catch (error) {
+				console.warn(`Failed to fetch schema ${typeId.toString(16)}:`, error);
+			}
+		}));
+		return results;
+	}
+	/**
+	* Check if a schema is available on the remote server
+	* @param typeId - The type ID to check
+	* @returns True if the schema is available
+	*/
+	async hasSchema(typeId) {
+		try {
+			await this.getSchemaById(typeId);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+
 //#endregion
 exports.AnswerTable = require_rpc_connection.AnswerTable;
 exports.BaseCapabilityClient = BaseCapabilityClient;
@@ -4917,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;
@@ -4937,6 +6252,10 @@ exports.RealtimeStream = RealtimeStream;
 exports.RealtimeStreamManager = RealtimeStreamManager;
 exports.RestoreHandler = RestoreHandler;
 exports.RpcConnection = require_rpc_connection.RpcConnection;
+exports.SCHEMA_MESSAGE_TYPES = require_rpc_connection.SCHEMA_MESSAGE_TYPES;
+exports.SchemaCapabilityClient = SchemaCapabilityClient;
+exports.SchemaCapabilityServer = SchemaCapabilityServer;
+exports.SchemaFormat = require_rpc_connection.SchemaFormat;
 exports.Segment = Segment;
 exports.Stream = Stream;
 exports.StreamManager = StreamManager;
@@ -4946,16 +6265,24 @@ 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;
 exports.WebSocketTransport = WebSocketTransport;
 exports.configureGlobalMemoryPool = configureGlobalMemoryPool;
 exports.createBulkTransferManager = createBulkTransferManager;
+exports.createDynamicReader = createDynamicReader;
+exports.createDynamicReaderByTypeId = createDynamicReaderByTypeId;
+exports.createDynamicReaderFromStruct = createDynamicReaderFromStruct;
+exports.createDynamicWriter = createDynamicWriter;
+exports.createDynamicWriterByTypeId = createDynamicWriterByTypeId;
+exports.createNestedDynamicWriter = createNestedDynamicWriter;
 exports.createPipelineClient = require_rpc_connection.createPipelineClient;
 exports.createProvisionId = createProvisionId;
 exports.createRealtimeStreamManager = createRealtimeStreamManager;
 exports.createRecipientId = createRecipientId;
+exports.createSchemaRegistry = require_rpc_connection.createSchemaRegistry;
 exports.createStream = createStream;
 exports.createStreamManager = createStreamManager;
 exports.createStreamingConnection = createStreamingConnection;
@@ -4966,7 +6293,10 @@ exports.createUnionReader = createUnionReader;
 exports.createZeroCopyView = createZeroCopyView;
 exports.decodePointer = decodePointer;
 exports.deserializeRpcMessage = deserializeRpcMessage;
+exports.deserializeSchemaRequest = require_rpc_connection.deserializeSchemaRequest;
+exports.deserializeSchemaResponse = require_rpc_connection.deserializeSchemaResponse;
 exports.deserializeSturdyRef = deserializeSturdyRef;
+exports.dumpDynamicReader = dumpDynamicReader;
 exports.encodeListPointer = encodeListPointer;
 exports.encodeStructPointer = encodeStructPointer;
 exports.fastCopy = fastCopy;
@@ -4977,7 +6307,15 @@ exports.isPipelineClient = require_rpc_connection.isPipelineClient;
 exports.isSameBuffer = isSameBuffer;
 exports.isStream = isStream;
 exports.isSturdyRefValid = isSturdyRefValid;
+exports.parseSchemaNodes = require_rpc_connection.parseSchemaNodes;
+exports.serializeDynamic = serializeDynamic;
+exports.serializeDynamicByTypeId = serializeDynamicByTypeId;
+exports.serializeGetSchemaParams = require_rpc_connection.serializeGetSchemaParams;
+exports.serializeGetSchemaResults = require_rpc_connection.serializeGetSchemaResults;
+exports.serializeListSchemasResults = require_rpc_connection.serializeListSchemasResults;
 exports.serializeRpcMessage = serializeRpcMessage;
+exports.serializeSchemaRequest = require_rpc_connection.serializeSchemaRequest;
+exports.serializeSchemaResponse = require_rpc_connection.serializeSchemaResponse;
 exports.serializeSturdyRef = serializeSturdyRef;
 exports.supportsStreaming = supportsStreaming;
 //# sourceMappingURL=index.cjs.map