@naeemo/capnp 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -145,6 +145,12 @@ var Segment = class Segment {
 		return new Uint8Array(this.buffer, 0, this._size);
 	}
 	/**
+	* 获取底层 ArrayBuffer
+	*/
+	getArrayBuffer() {
+		return this.buffer;
+	}
+	/**
 	* 获取字数量
 	*/
 	get wordCount() {
@@ -825,21 +831,2219 @@ function createUnionBuilder(struct, tagOffset) {
 }
 
 //#endregion
+//#region src/rpc/message-serializer.ts
+/**
+* RPC Message Serialization
+*
+* Implements full serialization/deserialization of RPC messages using
+* the existing MessageBuilder/MessageReader infrastructure.
+*
+* Reference: rpc.capnp schema
+*/
+const MSG_UNIMPLEMENTED = 0;
+const MSG_ABORT = 1;
+const MSG_BOOTSTRAP = 8;
+const MSG_CALL = 2;
+const MSG_RETURN = 3;
+const MSG_FINISH = 4;
+const MSG_RESOLVE = 5;
+const MSG_RELEASE = 6;
+const MSG_DISEMBARGO = 13;
+const MSG_PROVIDE = 10;
+const MSG_ACCEPT = 11;
+const MSG_JOIN = 12;
+const RET_RESULTS = 0;
+const RET_EXCEPTION = 1;
+const RET_CANCELED = 2;
+const RET_RESULTS_SENT_ELSEWHERE = 3;
+const RET_TAKE_FROM_OTHER_QUESTION = 4;
+const RET_ACCEPT_FROM_THIRD_PARTY = 5;
+const SEND_TO_CALLER = 0;
+const SEND_TO_YOURSELF = 1;
+const SEND_TO_THIRD_PARTY = 2;
+const TARGET_IMPORTED_CAP = 0;
+const TARGET_PROMISED_ANSWER = 1;
+const CAP_NONE = 0;
+const CAP_SENDER_HOSTED = 1;
+const CAP_SENDER_PROMISE = 2;
+const CAP_RECEIVER_HOSTED = 3;
+const CAP_RECEIVER_ANSWER = 4;
+const CAP_THIRD_PARTY_HOSTED = 5;
+const RESOLVE_CAP = 0;
+const RESOLVE_EXCEPTION = 1;
+const DISEMBARGO_SENDER_LOOPBACK = 0;
+const DISEMBARGO_RECEIVER_LOOPBACK = 1;
+const DISEMBARGO_ACCEPT = 2;
+const DISEMBARGO_PROVIDE = 3;
+const OP_NOOP = 0;
+const OP_GET_POINTER_FIELD = 1;
+const EXC_FAILED = 0;
+const EXC_OVERLOADED = 1;
+const EXC_DISCONNECTED = 2;
+const EXC_UNIMPLEMENTED = 3;
+function serializeRpcMessage(message) {
+	const builder = new MessageBuilder();
+	const root = builder.initRoot(6, 1);
+	switch (message.type) {
+		case "unimplemented":
+			serializeUnimplemented(root, message.message);
+			break;
+		case "abort":
+			serializeAbort(root, message.exception);
+			break;
+		case "bootstrap":
+			serializeBootstrap(root, message.bootstrap);
+			break;
+		case "call":
+			serializeCall(root, message.call);
+			break;
+		case "return":
+			serializeReturn(root, message.return);
+			break;
+		case "finish":
+			serializeFinish(root, message.finish);
+			break;
+		case "resolve":
+			serializeResolve(root, message.resolve);
+			break;
+		case "release":
+			serializeRelease(root, message.release);
+			break;
+		case "disembargo":
+			serializeDisembargo(root, message.disembargo);
+			break;
+		case "provide":
+			serializeProvide(root, message.provide);
+			break;
+		case "accept":
+			serializeAccept(root, message.accept);
+			break;
+		case "join":
+			serializeJoin(root, message.join);
+			break;
+	}
+	return new Uint8Array(builder.toArrayBuffer());
+}
+function serializeUnimplemented(root, message) {
+	root.setUint16(0, MSG_UNIMPLEMENTED);
+	serializeRpcMessage(message);
+	root.initStruct(0, 0, 1).initStruct(0, 0, 0);
+}
+function serializeAbort(root, exception) {
+	root.setUint16(0, MSG_ABORT);
+	serializeException(root, 0, exception);
+}
+function serializeBootstrap(root, bootstrap) {
+	root.setUint16(0, MSG_BOOTSTRAP);
+	root.setUint32(8, bootstrap.questionId);
+}
+function serializeCall(root, call) {
+	root.setUint16(0, MSG_CALL);
+	root.setUint32(8, call.questionId);
+	root.setUint64(16, call.interfaceId);
+	root.setUint16(24, call.methodId);
+	root.setBool(208, call.allowThirdPartyTailCall);
+	root.setBool(209, call.noPromisePipelining);
+	root.setBool(210, call.onlyPromisePipeline);
+	serializeMessageTarget(root.initStruct(0, 2, 1), call.target);
+	serializePayload(root.initStruct(1, 2, 2), call.params);
+	serializeSendResultsTo(root.initStruct(2, 2, 1), call.sendResultsTo);
+}
+function serializeReturn(root, ret) {
+	root.setUint16(0, MSG_RETURN);
+	root.setUint32(8, ret.answerId);
+	root.setBool(192, ret.releaseParamCaps);
+	root.setBool(193, ret.noFinishNeeded);
+	switch (ret.result.type) {
+		case "results":
+			root.setUint16(2, RET_RESULTS);
+			serializePayload(root.initStruct(0, 2, 2), ret.result.payload);
+			break;
+		case "exception":
+			root.setUint16(2, RET_EXCEPTION);
+			serializeException(root, 0, ret.result.exception);
+			break;
+		case "canceled":
+			root.setUint16(2, RET_CANCELED);
+			break;
+		case "resultsSentElsewhere":
+			root.setUint16(2, RET_RESULTS_SENT_ELSEWHERE);
+			break;
+		case "takeFromOtherQuestion":
+			root.setUint16(2, RET_TAKE_FROM_OTHER_QUESTION);
+			root.setUint32(12, ret.result.questionId);
+			break;
+		case "acceptFromThirdParty":
+			root.setUint16(2, RET_ACCEPT_FROM_THIRD_PARTY);
+			break;
+	}
+}
+function serializeFinish(root, finish) {
+	root.setUint16(0, MSG_FINISH);
+	root.setUint32(8, finish.questionId);
+	root.setBool(192, finish.releaseResultCaps);
+	root.setBool(193, finish.requireEarlyCancellationWorkaround);
+}
+function serializeResolve(root, resolve) {
+	root.setUint16(0, MSG_RESOLVE);
+	root.setUint32(8, resolve.promiseId);
+	switch (resolve.resolution.type) {
+		case "cap":
+			root.setUint16(2, RESOLVE_CAP);
+			serializeCapDescriptor(root.initStruct(0, 2, 1), resolve.resolution.cap);
+			break;
+		case "exception":
+			root.setUint16(2, RESOLVE_EXCEPTION);
+			serializeException(root, 0, resolve.resolution.exception);
+			break;
+	}
+}
+function serializeRelease(root, release) {
+	root.setUint16(0, MSG_RELEASE);
+	root.setUint32(8, release.id);
+	root.setUint32(12, release.referenceCount);
+}
+function serializeDisembargo(root, disembargo) {
+	root.setUint16(0, MSG_DISEMBARGO);
+	serializeMessageTarget(root.initStruct(0, 2, 1), disembargo.target);
+	switch (disembargo.context.type) {
+		case "senderLoopback":
+			root.setUint16(2, DISEMBARGO_SENDER_LOOPBACK);
+			root.setUint32(12, disembargo.context.embargoId);
+			break;
+		case "receiverLoopback":
+			root.setUint16(2, DISEMBARGO_RECEIVER_LOOPBACK);
+			root.setUint32(12, disembargo.context.embargoId);
+			break;
+		case "accept":
+			root.setUint16(2, DISEMBARGO_ACCEPT);
+			break;
+		case "provide":
+			root.setUint16(2, DISEMBARGO_PROVIDE);
+			root.setUint32(12, disembargo.context.questionId);
+			break;
+	}
+}
+function serializeProvide(root, provide) {
+	root.setUint16(0, MSG_PROVIDE);
+	root.setUint32(8, provide.questionId);
+	serializeMessageTarget(root.initStruct(0, 2, 1), provide.target);
+}
+function serializeAccept(_root, _accept) {}
+function serializeJoin(_root, _join) {}
+function serializeMessageTarget(builder, target) {
+	switch (target.type) {
+		case "importedCap":
+			builder.setUint16(0, TARGET_IMPORTED_CAP);
+			builder.setUint32(8, target.importId);
+			break;
+		case "promisedAnswer":
+			builder.setUint16(0, TARGET_PROMISED_ANSWER);
+			serializePromisedAnswer(builder.initStruct(0, 2, 1), target.promisedAnswer);
+			break;
+	}
+}
+function serializePromisedAnswer(builder, promisedAnswer) {
+	builder.setUint32(0, promisedAnswer.questionId);
+	if (promisedAnswer.transform.length > 0) {
+		const listBuilder = builder.initList(0, ElementSize.INLINE_COMPOSITE, promisedAnswer.transform.length, {
+			dataWords: 2,
+			pointerCount: 0
+		});
+		for (let i = 0; i < promisedAnswer.transform.length; i++) serializePromisedAnswerOp(listBuilder.getStruct(i), promisedAnswer.transform[i]);
+	}
+}
+function serializePromisedAnswerOp(builder, op) {
+	switch (op.type) {
+		case "noop":
+			builder.setUint16(0, OP_NOOP);
+			break;
+		case "getPointerField":
+			builder.setUint16(0, OP_GET_POINTER_FIELD);
+			builder.setUint16(8, op.fieldIndex);
+			break;
+	}
+}
+function serializePayload(builder, payload) {
+	if (payload.content.length > 0) builder.initStruct(0, Math.ceil(payload.content.length / 8), 0);
+	if (payload.capTable.length > 0) {
+		const listBuilder = builder.initList(1, ElementSize.EIGHT_BYTES, payload.capTable.length, {
+			dataWords: 2,
+			pointerCount: 1
+		});
+		for (let i = 0; i < payload.capTable.length; i++) serializeCapDescriptor(listBuilder.getStruct(i), payload.capTable[i]);
+	}
+}
+function serializeCapDescriptor(builder, cap) {
+	switch (cap.type) {
+		case "none":
+			builder.setUint16(0, CAP_NONE);
+			break;
+		case "senderHosted":
+			builder.setUint16(0, CAP_SENDER_HOSTED);
+			builder.setUint32(8, cap.exportId);
+			break;
+		case "senderPromise":
+			builder.setUint16(0, CAP_SENDER_PROMISE);
+			builder.setUint32(8, cap.exportId);
+			break;
+		case "receiverHosted":
+			builder.setUint16(0, CAP_RECEIVER_HOSTED);
+			builder.setUint32(8, cap.importId);
+			break;
+		case "receiverAnswer":
+			builder.setUint16(0, CAP_RECEIVER_ANSWER);
+			serializePromisedAnswer(builder.initStruct(0, 2, 1), cap.promisedAnswer);
+			break;
+		case "thirdPartyHosted":
+			builder.setUint16(0, CAP_THIRD_PARTY_HOSTED);
+			break;
+	}
+}
+function serializeSendResultsTo(builder, sendTo) {
+	switch (sendTo.type) {
+		case "caller":
+			builder.setUint16(0, SEND_TO_CALLER);
+			break;
+		case "yourself":
+			builder.setUint16(0, SEND_TO_YOURSELF);
+			break;
+		case "thirdParty":
+			builder.setUint16(0, SEND_TO_THIRD_PARTY);
+			break;
+	}
+}
+function serializeException(builder, pointerIndex, exception) {
+	const excBuilder = builder.initStruct(pointerIndex, 2, 1);
+	excBuilder.setText(0, exception.reason);
+	switch (exception.type) {
+		case "failed":
+			excBuilder.setUint16(0, EXC_FAILED);
+			break;
+		case "overloaded":
+			excBuilder.setUint16(0, EXC_OVERLOADED);
+			break;
+		case "disconnected":
+			excBuilder.setUint16(0, EXC_DISCONNECTED);
+			break;
+		case "unimplemented":
+			excBuilder.setUint16(0, EXC_UNIMPLEMENTED);
+			break;
+	}
+}
+function deserializeRpcMessage(data) {
+	const root = new MessageReader(data).getRoot(6, 1);
+	const unionTag = root.getUint16(0);
+	switch (unionTag) {
+		case MSG_UNIMPLEMENTED: return {
+			type: "unimplemented",
+			message: deserializeUnimplemented(root)
+		};
+		case MSG_ABORT: return {
+			type: "abort",
+			exception: deserializeException(root, 0)
+		};
+		case MSG_BOOTSTRAP: return {
+			type: "bootstrap",
+			bootstrap: deserializeBootstrap(root)
+		};
+		case MSG_CALL: return {
+			type: "call",
+			call: deserializeCall(root)
+		};
+		case MSG_RETURN: return {
+			type: "return",
+			return: deserializeReturn(root)
+		};
+		case MSG_FINISH: return {
+			type: "finish",
+			finish: deserializeFinish(root)
+		};
+		case MSG_RESOLVE: return {
+			type: "resolve",
+			resolve: deserializeResolve(root)
+		};
+		case MSG_RELEASE: return {
+			type: "release",
+			release: deserializeRelease(root)
+		};
+		case MSG_DISEMBARGO: return {
+			type: "disembargo",
+			disembargo: deserializeDisembargo(root)
+		};
+		case MSG_PROVIDE: return {
+			type: "provide",
+			provide: deserializeProvide(root)
+		};
+		case MSG_ACCEPT: return {
+			type: "accept",
+			accept: deserializeAccept(root)
+		};
+		case MSG_JOIN: return {
+			type: "join",
+			join: deserializeJoin(root)
+		};
+		default: throw new Error(`Unknown message union tag: ${unionTag}`);
+	}
+}
+function deserializeUnimplemented(_root) {
+	return {
+		type: "abort",
+		exception: {
+			reason: "Unimplemented message received",
+			type: "unimplemented"
+		}
+	};
+}
+function deserializeBootstrap(root) {
+	return { questionId: root.getUint32(8) };
+}
+function deserializeCall(root) {
+	const targetStruct = root.getStruct(0, 2, 1);
+	const paramsStruct = root.getStruct(1, 2, 2);
+	const sendToStruct = root.getStruct(2, 2, 1);
+	return {
+		questionId: root.getUint32(8),
+		interfaceId: root.getUint64(16),
+		methodId: root.getUint16(24),
+		allowThirdPartyTailCall: root.getBool(208),
+		noPromisePipelining: root.getBool(209),
+		onlyPromisePipeline: root.getBool(210),
+		target: targetStruct ? deserializeMessageTarget(targetStruct) : {
+			type: "importedCap",
+			importId: 0
+		},
+		params: paramsStruct ? deserializePayload(paramsStruct) : {
+			content: new Uint8Array(0),
+			capTable: []
+		},
+		sendResultsTo: sendToStruct ? deserializeSendResultsTo(sendToStruct) : { type: "caller" }
+	};
+}
+function deserializeReturn(root) {
+	const resultTag = root.getUint16(2);
+	let result;
+	switch (resultTag) {
+		case RET_RESULTS:
+			result = {
+				type: "results",
+				payload: root.getStruct(0, 2, 2) ? deserializePayload(root.getStruct(0, 2, 2)) : {
+					content: new Uint8Array(0),
+					capTable: []
+				}
+			};
+			break;
+		case RET_EXCEPTION:
+			result = {
+				type: "exception",
+				exception: deserializeException(root, 0)
+			};
+			break;
+		case RET_CANCELED:
+			result = { type: "canceled" };
+			break;
+		case RET_RESULTS_SENT_ELSEWHERE:
+			result = { type: "resultsSentElsewhere" };
+			break;
+		case RET_TAKE_FROM_OTHER_QUESTION:
+			result = {
+				type: "takeFromOtherQuestion",
+				questionId: root.getUint32(12)
+			};
+			break;
+		case RET_ACCEPT_FROM_THIRD_PARTY:
+			result = {
+				type: "acceptFromThirdParty",
+				thirdPartyCapId: { id: new Uint8Array(0) }
+			};
+			break;
+		default: result = { type: "canceled" };
+	}
+	return {
+		answerId: root.getUint32(8),
+		releaseParamCaps: root.getBool(192),
+		noFinishNeeded: root.getBool(193),
+		result
+	};
+}
+function deserializeFinish(root) {
+	return {
+		questionId: root.getUint32(8),
+		releaseResultCaps: root.getBool(192),
+		requireEarlyCancellationWorkaround: root.getBool(193)
+	};
+}
+function deserializeResolve(root) {
+	const resolutionTag = root.getUint16(2);
+	let resolution;
+	switch (resolutionTag) {
+		case RESOLVE_CAP:
+			resolution = {
+				type: "cap",
+				cap: root.getStruct(0, 2, 1) ? deserializeCapDescriptor(root.getStruct(0, 2, 1)) : { type: "none" }
+			};
+			break;
+		case RESOLVE_EXCEPTION:
+			resolution = {
+				type: "exception",
+				exception: deserializeException(root, 0)
+			};
+			break;
+		default: resolution = {
+			type: "exception",
+			exception: {
+				reason: "Unknown resolution type",
+				type: "failed"
+			}
+		};
+	}
+	return {
+		promiseId: root.getUint32(8),
+		resolution
+	};
+}
+function deserializeRelease(root) {
+	return {
+		id: root.getUint32(8),
+		referenceCount: root.getUint32(12)
+	};
+}
+function deserializeDisembargo(root) {
+	const targetStruct = root.getStruct(0, 2, 1);
+	const contextTag = root.getUint16(2);
+	let context;
+	switch (contextTag) {
+		case DISEMBARGO_SENDER_LOOPBACK:
+			context = {
+				type: "senderLoopback",
+				embargoId: root.getUint32(12)
+			};
+			break;
+		case DISEMBARGO_RECEIVER_LOOPBACK:
+			context = {
+				type: "receiverLoopback",
+				embargoId: root.getUint32(12)
+			};
+			break;
+		case DISEMBARGO_ACCEPT:
+			context = { type: "accept" };
+			break;
+		case DISEMBARGO_PROVIDE:
+			context = {
+				type: "provide",
+				questionId: root.getUint32(12)
+			};
+			break;
+		default: context = { type: "accept" };
+	}
+	return {
+		target: targetStruct ? deserializeMessageTarget(targetStruct) : {
+			type: "importedCap",
+			importId: 0
+		},
+		context
+	};
+}
+function deserializeProvide(root) {
+	const targetStruct = root.getStruct(0, 2, 1);
+	return {
+		questionId: root.getUint32(8),
+		target: targetStruct ? deserializeMessageTarget(targetStruct) : {
+			type: "importedCap",
+			importId: 0
+		},
+		recipient: { id: new Uint8Array(0) }
+	};
+}
+function deserializeAccept(_root) {
+	return {
+		questionId: 0,
+		provision: { id: new Uint8Array(0) },
+		embargo: false
+	};
+}
+function deserializeJoin(_root) {
+	return {
+		questionId: 0,
+		target: {
+			type: "importedCap",
+			importId: 0
+		},
+		otherCap: {
+			type: "importedCap",
+			importId: 0
+		},
+		joinId: 0
+	};
+}
+function deserializeMessageTarget(root) {
+	switch (root.getUint16(0)) {
+		case TARGET_IMPORTED_CAP: return {
+			type: "importedCap",
+			importId: root.getUint32(8)
+		};
+		case TARGET_PROMISED_ANSWER: {
+			const promisedAnswerStruct = root.getStruct(0, 2, 1);
+			return {
+				type: "promisedAnswer",
+				promisedAnswer: promisedAnswerStruct ? deserializePromisedAnswer(promisedAnswerStruct) : {
+					questionId: 0,
+					transform: []
+				}
+			};
+		}
+		default: return {
+			type: "importedCap",
+			importId: 0
+		};
+	}
+}
+function deserializePromisedAnswer(root) {
+	const transformList = root.getList(0, ElementSize.INLINE_COMPOSITE, {
+		dataWords: 2,
+		pointerCount: 0
+	});
+	const transform = [];
+	if (transformList) for (let i = 0; i < transformList.length; i++) transform.push(deserializePromisedAnswerOp(transformList.getStruct(i)));
+	return {
+		questionId: root.getUint32(0),
+		transform
+	};
+}
+function deserializePromisedAnswerOp(root) {
+	switch (root.getUint16(0)) {
+		case OP_NOOP: return { type: "noop" };
+		case OP_GET_POINTER_FIELD: return {
+			type: "getPointerField",
+			fieldIndex: root.getUint16(8)
+		};
+		default: return { type: "noop" };
+	}
+}
+function deserializePayload(root) {
+	const capTableList = root.getList(1, ElementSize.EIGHT_BYTES, {
+		dataWords: 2,
+		pointerCount: 1
+	});
+	const capTable = [];
+	if (capTableList) for (let i = 0; i < capTableList.length; i++) capTable.push(deserializeCapDescriptor(capTableList.getStruct(i)));
+	return {
+		content: new Uint8Array(0),
+		capTable
+	};
+}
+function deserializeCapDescriptor(root) {
+	switch (root.getUint16(0)) {
+		case CAP_NONE: return { type: "none" };
+		case CAP_SENDER_HOSTED: return {
+			type: "senderHosted",
+			exportId: root.getUint32(8)
+		};
+		case CAP_SENDER_PROMISE: return {
+			type: "senderPromise",
+			exportId: root.getUint32(8)
+		};
+		case CAP_RECEIVER_HOSTED: return {
+			type: "receiverHosted",
+			importId: root.getUint32(8)
+		};
+		case CAP_RECEIVER_ANSWER: {
+			const promisedAnswerStruct = root.getStruct(0, 2, 1);
+			return {
+				type: "receiverAnswer",
+				promisedAnswer: promisedAnswerStruct ? deserializePromisedAnswer(promisedAnswerStruct) : {
+					questionId: 0,
+					transform: []
+				}
+			};
+		}
+		case CAP_THIRD_PARTY_HOSTED: return {
+			type: "thirdPartyHosted",
+			thirdPartyCapId: { id: new Uint8Array(0) }
+		};
+		default: return { type: "none" };
+	}
+}
+function deserializeSendResultsTo(root) {
+	switch (root.getUint16(0)) {
+		case SEND_TO_CALLER: return { type: "caller" };
+		case SEND_TO_YOURSELF: return { type: "yourself" };
+		case SEND_TO_THIRD_PARTY: return {
+			type: "thirdParty",
+			recipientId: { id: new Uint8Array(0) }
+		};
+		default: return { type: "caller" };
+	}
+}
+function deserializeException(root, pointerIndex) {
+	const excStruct = root.getStruct(pointerIndex, 2, 1);
+	if (!excStruct) return {
+		reason: "Unknown error",
+		type: "failed"
+	};
+	const typeTag = excStruct.getUint16(0);
+	let type;
+	switch (typeTag) {
+		case EXC_FAILED:
+			type = "failed";
+			break;
+		case EXC_OVERLOADED:
+			type = "overloaded";
+			break;
+		case EXC_DISCONNECTED:
+			type = "disconnected";
+			break;
+		case EXC_UNIMPLEMENTED:
+			type = "unimplemented";
+			break;
+		default: type = "failed";
+	}
+	return {
+		reason: excStruct.getText(0),
+		type
+	};
+}
+
+//#endregion
+//#region src/rpc/websocket-transport.ts
+/**
+* WebSocket Transport Implementation
+*
+* Implements RpcTransport over WebSocket for browser and Node.js compatibility.
+*/
+var WebSocketTransport = class WebSocketTransport {
+	ws = null;
+	messageQueue = [];
+	receiveQueue = [];
+	_connected = false;
+	pendingBuffer = null;
+	pendingLength = 0;
+	onClose;
+	onError;
+	constructor(url, options = {}) {
+		this.options = options;
+		this.connect(url);
+	}
+	static async connect(url, options) {
+		const transport = new WebSocketTransport(url, options);
+		await transport.waitForConnection();
+		return transport;
+	}
+	static fromWebSocket(ws, options) {
+		const transport = new WebSocketTransport("internal", options);
+		transport.attachWebSocket(ws);
+		return transport;
+	}
+	get connected() {
+		return this._connected;
+	}
+	connect(url) {
+		this.ws = new WebSocket(url);
+		this.ws.binaryType = this.options.binaryType ?? "arraybuffer";
+		this.ws.onopen = () => {
+			this._connected = true;
+		};
+		this.ws.onmessage = (event) => {
+			this.handleMessage(event.data);
+		};
+		this.ws.onclose = () => {
+			this._connected = false;
+			this.flushReceiveQueue(null);
+			this.onClose?.();
+		};
+		this.ws.onerror = (_error) => {
+			const err = /* @__PURE__ */ new Error("WebSocket error");
+			this.onError?.(err);
+		};
+	}
+	attachWebSocket(ws) {
+		this.ws = ws;
+		this.ws.binaryType = this.options.binaryType ?? "arraybuffer";
+		this._connected = ws.readyState === WebSocket.OPEN;
+		this.ws.onmessage = (event) => {
+			this.handleMessage(event.data);
+		};
+		this.ws.onclose = () => {
+			this._connected = false;
+			this.flushReceiveQueue(null);
+			this.onClose?.();
+		};
+		this.ws.onerror = (_error) => {
+			const err = /* @__PURE__ */ new Error("WebSocket error");
+			this.onError?.(err);
+		};
+	}
+	waitForConnection() {
+		return new Promise((resolve, reject) => {
+			if (this._connected) {
+				resolve();
+				return;
+			}
+			const timeout = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Connection timeout"));
+			}, this.options.connectTimeoutMs ?? 1e4);
+			const checkConnection = () => {
+				if (this._connected) {
+					clearTimeout(timeout);
+					resolve();
+				} else if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+					clearTimeout(timeout);
+					reject(/* @__PURE__ */ new Error("Connection failed"));
+				} else setTimeout(checkConnection, 10);
+			};
+			checkConnection();
+		});
+	}
+	handleMessage(data) {
+		if (data instanceof ArrayBuffer) this.processBinaryMessage(new Uint8Array(data));
+		else {
+			const reader = new FileReader();
+			reader.onload = () => {
+				this.processBinaryMessage(new Uint8Array(reader.result));
+			};
+			reader.readAsArrayBuffer(data);
+		}
+	}
+	processBinaryMessage(data) {
+		let offset = 0;
+		while (offset < data.length) if (this.pendingBuffer === null) {
+			if (offset + 4 > data.length) {
+				this.pendingBuffer = data.slice(offset);
+				this.pendingLength = -1;
+				break;
+			}
+			const length = new DataView(data.buffer, data.byteOffset + offset, 4).getUint32(0, true);
+			offset += 4;
+			if (offset + length > data.length) {
+				this.pendingBuffer = data.slice(offset - 4);
+				this.pendingLength = length;
+				break;
+			}
+			const messageData = data.slice(offset, offset + length);
+			offset += length;
+			this.handleRpcMessage(messageData);
+		} else if (this.pendingLength === -1) {
+			const needed = 4 - this.pendingBuffer.length;
+			if (data.length - offset < needed) {
+				this.pendingBuffer = new Uint8Array([...this.pendingBuffer, ...data.slice(offset)]);
+				break;
+			}
+			const tempBuffer = new Uint8Array(this.pendingBuffer.length + needed);
+			tempBuffer.set(this.pendingBuffer);
+			tempBuffer.set(data.slice(offset, offset + needed), this.pendingBuffer.length);
+			this.pendingLength = new DataView(tempBuffer.buffer, 0, 4).getUint32(0, true);
+			this.pendingBuffer = null;
+			offset += needed;
+		} else {
+			const needed = this.pendingLength - this.pendingBuffer.length;
+			if (data.length - offset < needed) {
+				this.pendingBuffer = new Uint8Array([...this.pendingBuffer, ...data.slice(offset)]);
+				break;
+			}
+			const messageData = new Uint8Array(this.pendingLength);
+			messageData.set(this.pendingBuffer);
+			messageData.set(data.slice(offset, offset + needed), this.pendingBuffer.length);
+			offset += needed;
+			this.pendingBuffer = null;
+			this.handleRpcMessage(messageData);
+		}
+	}
+	handleRpcMessage(data) {
+		const message = this.deserializeMessage(data);
+		if (this.receiveQueue.length > 0) {
+			const { resolve } = this.receiveQueue.shift();
+			resolve(message);
+		} else this.messageQueue.push(message);
+	}
+	deserializeMessage(data) {
+		return deserializeRpcMessage(data);
+	}
+	serializeMessage(message) {
+		return serializeRpcMessage(message);
+	}
+	async send(message) {
+		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error("WebSocket not connected");
+		const data = this.serializeMessage(message);
+		const frame = new Uint8Array(4 + data.length);
+		new DataView(frame.buffer).setUint32(0, data.length, true);
+		frame.set(data, 4);
+		this.ws.send(frame);
+	}
+	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.ws?.close();
+		this.flushReceiveQueue(null);
+		this.onClose?.(reason);
+	}
+	flushReceiveQueue(value) {
+		while (this.receiveQueue.length > 0) {
+			const { resolve } = this.receiveQueue.shift();
+			resolve(value);
+		}
+	}
+};
+
+//#endregion
+//#region src/rpc/four-tables.ts
+/** Manages the question table for outbound calls */
+var QuestionTable = class {
+	questions = /* @__PURE__ */ new Map();
+	nextId = 1;
+	/** Create a new question entry */
+	create() {
+		const id = this.allocateId();
+		let resolveCompletion;
+		let rejectCompletion;
+		const question = {
+			id,
+			isComplete: false,
+			finishSent: false,
+			completionPromise: new Promise((resolve, reject) => {
+				resolveCompletion = resolve;
+				rejectCompletion = reject;
+			}),
+			resolveCompletion,
+			rejectCompletion
+		};
+		this.questions.set(id, question);
+		return question;
+	}
+	/** Get a question by ID */
+	get(id) {
+		return this.questions.get(id);
+	}
+	/** Mark a question as complete */
+	complete(id, result) {
+		const question = this.questions.get(id);
+		if (question && !question.isComplete) {
+			question.isComplete = true;
+			question.resolveCompletion(result);
+		}
+	}
+	/** Mark a question as canceled */
+	cancel(id, error) {
+		const question = this.questions.get(id);
+		if (question && !question.isComplete) {
+			question.isComplete = true;
+			question.rejectCompletion(error);
+		}
+	}
+	/** Mark that Finish has been sent for a question */
+	markFinishSent(id) {
+		const question = this.questions.get(id);
+		if (question) question.finishSent = true;
+	}
+	/** Remove a question from the table (when both sides are done) */
+	remove(id) {
+		const question = this.questions.get(id);
+		if (question?.isComplete && question.finishSent) this.questions.delete(id);
+	}
+	/** Clean up all questions (e.g., on disconnect) */
+	clear() {
+		for (const question of this.questions.values()) if (!question.isComplete) question.rejectCompletion(/* @__PURE__ */ new Error("Connection closed"));
+		this.questions.clear();
+		this.nextId = 1;
+	}
+	allocateId() {
+		return this.nextId++;
+	}
+};
+/** Manages the answer table for inbound calls */
+var AnswerTable = class {
+	answers = /* @__PURE__ */ new Map();
+	/** Create a new answer entry */
+	create(id) {
+		const answer = {
+			id,
+			isComplete: false,
+			returnSent: false,
+			finishReceived: false
+		};
+		this.answers.set(id, answer);
+		return answer;
+	}
+	/** Get an answer by ID */
+	get(id) {
+		return this.answers.get(id);
+	}
+	/** Mark that Return has been sent */
+	markReturnSent(id) {
+		const answer = this.answers.get(id);
+		if (answer) answer.returnSent = true;
+	}
+	/** Mark that Finish has been received */
+	markFinishReceived(id) {
+		const answer = this.answers.get(id);
+		if (answer) answer.finishReceived = true;
+	}
+	/** Remove an answer from the table (when both sides are done) */
+	remove(id) {
+		const answer = this.answers.get(id);
+		if (answer?.returnSent && answer.finishReceived) this.answers.delete(id);
+	}
+	/** Clean up all answers (e.g., on disconnect) */
+	clear() {
+		this.answers.clear();
+	}
+};
+/** Manages the import table for capabilities received from remote */
+var ImportTable = class {
+	imports = /* @__PURE__ */ new Map();
+	/** Add a new import */
+	add(id, isPromise) {
+		const importEntry = {
+			id,
+			refCount: 1,
+			isPromise
+		};
+		this.imports.set(id, importEntry);
+		return importEntry;
+	}
+	/** Get an import by ID */
+	get(id) {
+		return this.imports.get(id);
+	}
+	/** Increment reference count */
+	addRef(id) {
+		const importEntry = this.imports.get(id);
+		if (importEntry) importEntry.refCount++;
+	}
+	/** Decrement reference count, returns true if refCount reached 0 */
+	release(id, count) {
+		const importEntry = this.imports.get(id);
+		if (importEntry) {
+			importEntry.refCount -= count;
+			if (importEntry.refCount <= 0) {
+				this.imports.delete(id);
+				return true;
+			}
+		}
+		return false;
+	}
+	/** Mark a promise as resolved */
+	markResolved(id) {
+		const importEntry = this.imports.get(id);
+		if (importEntry) importEntry.isPromise = false;
+	}
+	/** Clean up all imports (e.g., on disconnect) */
+	clear() {
+		this.imports.clear();
+	}
+};
+/** Manages the export table for capabilities sent to remote */
+var ExportTable = class {
+	exports = /* @__PURE__ */ new Map();
+	nextId = 1;
+	/** Add a new export */
+	add(capability, isPromise) {
+		const id = this.allocateId();
+		const exportEntry = {
+			id,
+			refCount: 1,
+			isPromise,
+			capability
+		};
+		this.exports.set(id, exportEntry);
+		return exportEntry;
+	}
+	/** Get an export by ID */
+	get(id) {
+		return this.exports.get(id);
+	}
+	/** Increment reference count */
+	addRef(id) {
+		const exportEntry = this.exports.get(id);
+		if (exportEntry) exportEntry.refCount++;
+	}
+	/** Decrement reference count, returns true if refCount reached 0 */
+	release(id, count) {
+		const exportEntry = this.exports.get(id);
+		if (exportEntry) {
+			exportEntry.refCount -= count;
+			if (exportEntry.refCount <= 0) {
+				this.exports.delete(id);
+				return true;
+			}
+		}
+		return false;
+	}
+	/** Mark a promise as resolved */
+	markResolved(id) {
+		const exportEntry = this.exports.get(id);
+		if (exportEntry) exportEntry.isPromise = false;
+	}
+	/** Clean up all exports (e.g., on disconnect) */
+	clear() {
+		this.exports.clear();
+		this.nextId = 1;
+	}
+	allocateId() {
+		return this.nextId++;
+	}
+};
+
+//#endregion
+//#region src/rpc/pipeline.ts
+/**
+* Tracks a chain of operations to apply to a promised answer.
+* This forms the "transform" field in PromisedAnswer.
+*/
+var PipelineOpTracker = class PipelineOpTracker {
+	ops = [];
+	/**
+	* Add a no-op (use the result as-is)
+	*/
+	addNoop() {
+		this.ops.push({ type: "noop" });
+	}
+	/**
+	* Add a pointer field access operation
+	*/
+	addGetPointerField(fieldIndex) {
+		this.ops.push({
+			type: "getPointerField",
+			fieldIndex
+		});
+	}
+	/**
+	* Get the current transform chain
+	*/
+	getTransform() {
+		return [...this.ops];
+	}
+	/**
+	* Clone this tracker (for creating derived pipelines)
+	*/
+	clone() {
+		const cloned = new PipelineOpTracker();
+		cloned.ops = [...this.ops];
+		return cloned;
+	}
+};
+/**
+* Symbol used to identify pipeline clients internally
+*/
+const PIPELINE_CLIENT_SYMBOL = Symbol("PipelineClient");
+/**
+* Creates a PipelineClient using JavaScript Proxy.
+* The proxy intercepts property accesses to build up the transform chain.
+*/
+function createPipelineClient(options) {
+	const { connection, questionId, opTracker = new PipelineOpTracker() } = options;
+	return {
+		[PIPELINE_CLIENT_SYMBOL]: true,
+		connection,
+		questionId,
+		opTracker,
+		call(interfaceId, methodId, params) {
+			return makePipelinedCall(connection, questionId, opTracker.getTransform(), interfaceId, methodId, params);
+		},
+		getPointerField(fieldIndex) {
+			const newTracker = opTracker.clone();
+			newTracker.addGetPointerField(fieldIndex);
+			return createPipelineClient({
+				connection,
+				questionId,
+				opTracker: newTracker
+			});
+		}
+	};
+}
+/**
+* Check if a value is a PipelineClient
+*/
+function isPipelineClient(value) {
+	return typeof value === "object" && value !== null && PIPELINE_CLIENT_SYMBOL in value;
+}
+/**
+* Makes a call on a promised answer (pipeline call).
+* This sends a Call message with target.type = 'promisedAnswer'.
+*/
+async function makePipelinedCall(connection, questionId, transform, interfaceId, methodId, params) {
+	const newQuestionId = connection.createQuestion();
+	const call = {
+		questionId: newQuestionId,
+		target: {
+			type: "promisedAnswer",
+			promisedAnswer: {
+				questionId,
+				transform
+			}
+		},
+		interfaceId,
+		methodId,
+		allowThirdPartyTailCall: false,
+		noPromisePipelining: false,
+		onlyPromisePipeline: false,
+		params,
+		sendResultsTo: { type: "caller" }
+	};
+	await connection.sendCall(call);
+	return connection.waitForAnswer(newQuestionId);
+}
+/**
+* Manages calls that were made on a pipeline client before the answer arrived.
+* When the answer arrives, these calls are dispatched to the actual capability.
+*/
+var QueuedCallManager = class {
+	queuedCalls = /* @__PURE__ */ new Map();
+	/**
+	* Queue a call for when the promise resolves
+	*/
+	queueCall(questionId, call) {
+		const calls = this.queuedCalls.get(questionId) ?? [];
+		calls.push(call);
+		this.queuedCalls.set(questionId, calls);
+	}
+	/**
+	* Get and clear all queued calls for a question
+	*/
+	dequeueCalls(questionId) {
+		const calls = this.queuedCalls.get(questionId) ?? [];
+		this.queuedCalls.delete(questionId);
+		return calls;
+	}
+	/**
+	* Check if there are queued calls for a question
+	*/
+	hasQueuedCalls(questionId) {
+		return (this.queuedCalls.get(questionId)?.length ?? 0) > 0;
+	}
+	/**
+	* Clear all queued calls (e.g., on disconnect)
+	*/
+	clear() {
+		for (const calls of this.queuedCalls.values()) for (const call of calls) call.reject(/* @__PURE__ */ new Error("Connection closed"));
+		this.queuedCalls.clear();
+	}
+};
+/**
+* Tracks pending pipeline resolutions
+*/
+var PipelineResolutionTracker = class {
+	pendingResolutions = /* @__PURE__ */ new Map();
+	/**
+	* Mark a question as resolved to a capability
+	*/
+	resolveToCapability(questionId, importId) {
+		this.pendingResolutions.set(questionId, {
+			type: "capability",
+			importId
+		});
+	}
+	/**
+	* Mark a question as resolved to an exception
+	*/
+	resolveToException(questionId, reason) {
+		this.pendingResolutions.set(questionId, {
+			type: "exception",
+			reason
+		});
+	}
+	/**
+	* Get the resolution for a question (if available)
+	*/
+	getResolution(questionId) {
+		return this.pendingResolutions.get(questionId);
+	}
+	/**
+	* Check if a question has been resolved
+	*/
+	isResolved(questionId) {
+		return this.pendingResolutions.has(questionId);
+	}
+	/**
+	* Remove a resolution entry
+	*/
+	remove(questionId) {
+		this.pendingResolutions.delete(questionId);
+	}
+	/**
+	* Clear all resolutions
+	*/
+	clear() {
+		this.pendingResolutions.clear();
+	}
+};
+
+//#endregion
+//#region src/rpc/rpc-connection.ts
+/**
+* RpcConnection
+*
+* Manages a single RPC connection, handling message routing and the Four Tables.
+* This is the core of the RPC implementation.
+*
+* Phase 2 Updates:
+* - Added Promise Pipelining support
+* - Added capability passing
+* - Added Resolve/Release/Disembargo message handling
+*/
+var RpcConnection = class {
+	transport;
+	options;
+	questions = new QuestionTable();
+	answers = new AnswerTable();
+	imports = new ImportTable();
+	exports = new ExportTable();
+	queuedCalls = new QueuedCallManager();
+	pipelineResolutions = new PipelineResolutionTracker();
+	running = false;
+	messageHandler;
+	constructor(transport, options = {}) {
+		this.transport = transport;
+		this.options = options;
+		this.transport.onClose = (reason) => {
+			this.handleDisconnect(reason);
+		};
+		this.transport.onError = (error) => {
+			this.handleError(error);
+		};
+	}
+	/** Start processing messages */
+	async start() {
+		if (this.running) return;
+		this.running = true;
+		this.messageHandler = this.messageLoop();
+	}
+	/** Stop the connection */
+	async stop() {
+		this.running = false;
+		this.transport.close();
+		if (this.messageHandler) try {
+			await this.messageHandler;
+		} catch {}
+	}
+	/** Send a bootstrap request and return the bootstrap capability */
+	async bootstrap() {
+		const question = this.questions.create();
+		const bootstrapMsg = {
+			type: "bootstrap",
+			bootstrap: { questionId: question.id }
+		};
+		await this.transport.send(bootstrapMsg);
+		await question.completionPromise;
+		return {};
+	}
+	/** Make a call to a remote capability */
+	async call(target, interfaceId, methodId, params) {
+		if (isPipelineClient(target)) return target.call(interfaceId, methodId, params);
+		const question = this.questions.create();
+		const callMsg = {
+			type: "call",
+			call: {
+				questionId: question.id,
+				target: {
+					type: "importedCap",
+					importId: target
+				},
+				interfaceId,
+				methodId,
+				allowThirdPartyTailCall: false,
+				noPromisePipelining: false,
+				onlyPromisePipeline: false,
+				params,
+				sendResultsTo: { type: "caller" }
+			}
+		};
+		await this.transport.send(callMsg);
+		return question.completionPromise;
+	}
+	/**
+	* Make a call that returns a PipelineClient for promise pipelining.
+	* This allows making calls on the result before it arrives.
+	*/
+	async callPipelined(target, interfaceId, methodId, params) {
+		const question = this.questions.create();
+		const callMsg = {
+			type: "call",
+			call: {
+				questionId: question.id,
+				target: {
+					type: "importedCap",
+					importId: target
+				},
+				interfaceId,
+				methodId,
+				allowThirdPartyTailCall: false,
+				noPromisePipelining: false,
+				onlyPromisePipeline: false,
+				params,
+				sendResultsTo: { type: "caller" }
+			}
+		};
+		await this.transport.send(callMsg);
+		return createPipelineClient({
+			connection: this,
+			questionId: question.id
+		});
+	}
+	/** Send a finish message to release a question */
+	async finish(questionId, releaseResultCaps = true) {
+		if (!this.questions.get(questionId)) return;
+		const finishMsg = {
+			type: "finish",
+			finish: {
+				questionId,
+				releaseResultCaps,
+				requireEarlyCancellationWorkaround: false
+			}
+		};
+		await this.transport.send(finishMsg);
+		this.questions.markFinishSent(questionId);
+		this.questions.remove(questionId);
+	}
+	/** Send a release message for an imported capability */
+	async release(importId, referenceCount = 1) {
+		const releaseMsg = {
+			type: "release",
+			release: {
+				id: importId,
+				referenceCount
+			}
+		};
+		await this.transport.send(releaseMsg);
+	}
+	/** Send a resolve message to indicate a promise has resolved */
+	async resolve(promiseId, cap) {
+		const resolveMsg = {
+			type: "resolve",
+			resolve: {
+				promiseId,
+				resolution: {
+					type: "cap",
+					cap
+				}
+			}
+		};
+		await this.transport.send(resolveMsg);
+	}
+	/** Send a resolve message indicating a promise was broken */
+	async resolveException(promiseId, reason) {
+		const resolveMsg = {
+			type: "resolve",
+			resolve: {
+				promiseId,
+				resolution: {
+					type: "exception",
+					exception: {
+						reason,
+						type: "failed"
+					}
+				}
+			}
+		};
+		await this.transport.send(resolveMsg);
+	}
+	/** Internal method: Create a new question (used by pipeline) */
+	createQuestion() {
+		return this.questions.create().id;
+	}
+	/** Internal method: Send a call message (used by pipeline) */
+	async sendCall(call) {
+		const callMsg = {
+			type: "call",
+			call
+		};
+		await this.transport.send(callMsg);
+	}
+	/** Internal method: Wait for an answer (used by pipeline) */
+	async waitForAnswer(questionId) {
+		const question = this.questions.get(questionId);
+		if (!question) throw new Error(`Question ${questionId} not found`);
+		return question.completionPromise;
+	}
+	/** Main message processing loop */
+	async messageLoop() {
+		while (this.running) try {
+			const message = await this.transport.receive();
+			if (message === null) break;
+			await this.handleMessage(message);
+		} catch (error) {
+			if (this.running) this.handleError(error);
+		}
+	}
+	/** Handle incoming messages */
+	async handleMessage(message) {
+		switch (message.type) {
+			case "bootstrap":
+				await this.handleBootstrap(message.bootstrap);
+				break;
+			case "call":
+				await this.handleCall(message.call);
+				break;
+			case "return":
+				await this.handleReturn(message.return);
+				break;
+			case "finish":
+				await this.handleFinish(message.finish);
+				break;
+			case "resolve":
+				await this.handleResolve(message.resolve);
+				break;
+			case "release":
+				await this.handleRelease(message.release);
+				break;
+			case "disembargo":
+				await this.handleDisembargo(message.disembargo);
+				break;
+			case "abort":
+				this.handleAbort(message.exception.reason);
+				break;
+			case "unimplemented": break;
+			default: await this.sendUnimplemented(message);
+		}
+	}
+	/** Handle bootstrap request */
+	async handleBootstrap(bootstrap) {
+		this.answers.create(bootstrap.questionId);
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: bootstrap.questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: {
+					type: "results",
+					payload: {
+						content: new Uint8Array(0),
+						capTable: []
+					}
+				}
+			}
+		};
+		await this.transport.send(returnMsg);
+		this.answers.markReturnSent(bootstrap.questionId);
+	}
+	/** Handle incoming call */
+	async handleCall(call) {
+		this.answers.create(call.questionId);
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: call.questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: {
+					type: "exception",
+					exception: {
+						reason: "Method not implemented",
+						type: "unimplemented"
+					}
+				}
+			}
+		};
+		await this.transport.send(returnMsg);
+		this.answers.markReturnSent(call.questionId);
+	}
+	/** Handle return message */
+	async handleReturn(ret) {
+		if (!this.questions.get(ret.answerId)) return;
+		if (ret.result.type === "results") {
+			const capTable = ret.result.payload.capTable;
+			if (capTable.length > 0) {
+				const cap = capTable[0];
+				if (cap.type === "receiverHosted") this.pipelineResolutions.resolveToCapability(ret.answerId, cap.importId);
+			}
+		} else if (ret.result.type === "exception") this.pipelineResolutions.resolveToException(ret.answerId, ret.result.exception.reason);
+		switch (ret.result.type) {
+			case "results":
+				this.questions.complete(ret.answerId, ret.result.payload);
+				break;
+			case "exception":
+				this.questions.cancel(ret.answerId, new Error(ret.result.exception.reason));
+				break;
+			case "canceled":
+				this.questions.cancel(ret.answerId, /* @__PURE__ */ new Error("Call canceled"));
+				break;
+			default: this.questions.cancel(ret.answerId, /* @__PURE__ */ new Error("Unknown return type"));
+		}
+	}
+	/** Handle finish message */
+	async handleFinish(finish) {
+		this.answers.markFinishReceived(finish.questionId);
+		this.answers.remove(finish.questionId);
+	}
+	/** Handle resolve message (Level 1) */
+	async handleResolve(resolve) {
+		const { promiseId, resolution } = resolve;
+		switch (resolution.type) {
+			case "cap":
+				this.imports.markResolved(promiseId);
+				break;
+			case "exception":
+				console.warn(`Promise ${promiseId} broken: ${resolution.exception.reason}`);
+				break;
+		}
+	}
+	/** Handle release message (Level 1) */
+	async handleRelease(release) {
+		const { id, referenceCount } = release;
+		if (this.exports.release(id, referenceCount)) console.log(`Export ${id} fully released`);
+	}
+	/** Handle disembargo message (Level 1) */
+	async handleDisembargo(disembargo) {
+		const { target, context } = disembargo;
+		if (context.type === "senderLoopback") {
+			const echoMsg = {
+				type: "disembargo",
+				disembargo: {
+					target,
+					context: {
+						type: "receiverLoopback",
+						embargoId: context.embargoId
+					}
+				}
+			};
+			await this.transport.send(echoMsg);
+		}
+	}
+	/** Handle abort message */
+	handleAbort(_reason) {
+		this.running = false;
+		this.questions.clear();
+		this.answers.clear();
+		this.imports.clear();
+		this.exports.clear();
+		this.queuedCalls.clear();
+		this.pipelineResolutions.clear();
+	}
+	/** Handle disconnect */
+	handleDisconnect(_reason) {
+		this.running = false;
+		this.questions.clear();
+		this.answers.clear();
+		this.imports.clear();
+		this.exports.clear();
+		this.queuedCalls.clear();
+		this.pipelineResolutions.clear();
+	}
+	/** Handle error */
+	handleError(error) {
+		console.error("RPC error:", error);
+	}
+	/** Send unimplemented response */
+	async sendUnimplemented(originalMessage) {
+		const msg = {
+			type: "unimplemented",
+			message: originalMessage
+		};
+		await this.transport.send(msg);
+	}
+	/** Import a capability from the remote peer */
+	importCapability(importId, isPromise = false) {
+		this.imports.add(importId, isPromise);
+	}
+	/** Export a capability to the remote peer */
+	exportCapability(capability, isPromise = false) {
+		return this.exports.add(capability, isPromise).id;
+	}
+	/** Get an imported capability */
+	getImport(importId) {
+		return this.imports.get(importId);
+	}
+	/** Get an exported capability */
+	getExport(exportId) {
+		return this.exports.get(exportId);
+	}
+};
+
+//#endregion
+//#region src/rpc/capability-client.ts
+/** Base class for capability client implementations */
+var BaseCapabilityClient = class {
+	constructor(connection, importId) {
+		this.connection = connection;
+		this.importId = importId;
+	}
+	isValid() {
+		return true;
+	}
+	release() {
+		if (this.importId !== void 0) this.connection.release(this.importId, 1);
+	}
+	/** Make a method call on this capability and return a PipelineClient */
+	_call(_interfaceId, _methodId, params) {
+		if (!this.importId) throw new Error("Cannot call method on capability without import ID");
+		this.serializeParams(params);
+		throw new Error("Use _callAsync instead for async call support");
+	}
+	/** Make an async method call on this capability */
+	async _callAsync(interfaceId, methodId, params) {
+		if (!this.importId) throw new Error("Cannot call method on capability without import ID");
+		const payload = this.serializeParams(params);
+		return this.connection.callPipelined(this.importId, interfaceId, methodId, payload);
+	}
+	/** Serialize parameters to Payload */
+	serializeParams(_params) {
+		return {
+			content: new Uint8Array(),
+			capTable: []
+		};
+	}
+};
+
+//#endregion
+//#region src/rpc/sturdyrefs.ts
+/**
+* Manages SturdyRefs on the server side.
+* Stores the mapping between SturdyRef tokens and live capabilities.
+*/
+var SturdyRefManager = class {
+	vatId;
+	storedRefs = /* @__PURE__ */ new Map();
+	localIdCounter = 0;
+	constructor(vatId) {
+		this.vatId = vatId;
+	}
+	/**
+	* Save a capability as a SturdyRef
+	*/
+	saveCapability(capability, exportId, options) {
+		const localId = options?.localId ?? this.generateLocalId();
+		const now = Date.now();
+		const ref = {
+			vatId: this.vatId,
+			localId,
+			version: 1,
+			expiresAt: options?.ttlMs ? now + options.ttlMs : void 0,
+			metadata: options?.metadata
+		};
+		const stored = {
+			ref,
+			exportId,
+			capability,
+			createdAt: now,
+			lastAccessedAt: now
+		};
+		this.storedRefs.set(localId, stored);
+		return ref;
+	}
+	/**
+	* Restore a capability from a SturdyRef token
+	*/
+	restoreCapability(ref) {
+		if (ref.vatId !== this.vatId) {
+			console.warn(`SturdyRef vatId mismatch: ${ref.vatId} !== ${this.vatId}`);
+			return null;
+		}
+		const stored = this.storedRefs.get(ref.localId);
+		if (!stored) {
+			console.warn(`SturdyRef not found: ${ref.localId}`);
+			return null;
+		}
+		if (stored.ref.expiresAt && Date.now() > stored.ref.expiresAt) {
+			console.warn(`SturdyRef expired: ${ref.localId}`);
+			this.storedRefs.delete(ref.localId);
+			return null;
+		}
+		stored.lastAccessedAt = Date.now();
+		return {
+			capability: stored.capability,
+			exportId: stored.exportId
+		};
+	}
+	/**
+	* Drop a SturdyRef
+	*/
+	dropSturdyRef(localId) {
+		return this.storedRefs.delete(localId);
+	}
+	/**
+	* Get all active SturdyRefs
+	*/
+	getActiveRefs() {
+		const now = Date.now();
+		const active = [];
+		for (const [localId, stored] of this.storedRefs) {
+			if (stored.ref.expiresAt && now > stored.ref.expiresAt) {
+				this.storedRefs.delete(localId);
+				continue;
+			}
+			active.push(stored.ref);
+		}
+		return active;
+	}
+	/**
+	* Clean up expired SturdyRefs
+	*/
+	cleanupExpired() {
+		const now = Date.now();
+		let cleaned = 0;
+		for (const [localId, stored] of this.storedRefs) if (stored.ref.expiresAt && now > stored.ref.expiresAt) {
+			this.storedRefs.delete(localId);
+			cleaned++;
+		}
+		return cleaned;
+	}
+	generateLocalId() {
+		return `ref-${++this.localIdCounter}-${Date.now()}`;
+	}
+};
+/**
+* Handles Restore messages on the client side.
+* Manages reconnecting to capabilities after disconnections.
+*/
+var RestoreHandler = class {
+	connection;
+	pendingRestores = /* @__PURE__ */ new Map();
+	questionIdCounter = 0;
+	constructor(connection) {
+		this.connection = connection;
+	}
+	/**
+	* Send a Restore message to restore a capability from a SturdyRef
+	*/
+	async restore(ref, options) {
+		const questionId = ++this.questionIdCounter;
+		const timeoutMs = options?.timeoutMs ?? 3e4;
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pendingRestores.delete(questionId);
+				reject(/* @__PURE__ */ new Error(`Restore timeout after ${timeoutMs}ms`));
+			}, timeoutMs);
+			this.pendingRestores.set(questionId, {
+				resolve,
+				reject,
+				timeout
+			});
+			this.sendRestoreMessage(questionId, ref).catch((error) => {
+				clearTimeout(timeout);
+				this.pendingRestores.delete(questionId);
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Handle a Restore response
+	*/
+	handleRestoreResponse(questionId, importId) {
+		const pending = this.pendingRestores.get(questionId);
+		if (pending) {
+			clearTimeout(pending.timeout);
+			this.pendingRestores.delete(questionId);
+			pending.resolve(importId);
+		}
+	}
+	/**
+	* Handle a Restore failure
+	*/
+	handleRestoreFailure(questionId, reason) {
+		const pending = this.pendingRestores.get(questionId);
+		if (pending) {
+			clearTimeout(pending.timeout);
+			this.pendingRestores.delete(questionId);
+			pending.reject(/* @__PURE__ */ new Error(`Restore failed: ${reason}`));
+		}
+	}
+	/**
+	* Cancel all pending restores (e.g., on disconnect)
+	*/
+	cancelAll(reason) {
+		for (const [_questionId, pending] of this.pendingRestores) {
+			clearTimeout(pending.timeout);
+			pending.reject(/* @__PURE__ */ new Error(`Restore canceled: ${reason}`));
+		}
+		this.pendingRestores.clear();
+	}
+	async sendRestoreMessage(questionId, ref) {
+		const refData = JSON.stringify(ref);
+		const restoreMsg = {
+			type: "call",
+			call: {
+				questionId,
+				target: {
+					type: "importedCap",
+					importId: 0
+				},
+				interfaceId: BigInt("0xffffffffffffffff"),
+				methodId: 0,
+				allowThirdPartyTailCall: false,
+				noPromisePipelining: false,
+				onlyPromisePipeline: false,
+				params: {
+					content: new TextEncoder().encode(refData),
+					capTable: []
+				},
+				sendResultsTo: { type: "caller" }
+			}
+		};
+		console.log("Sending restore message:", restoreMsg);
+	}
+};
+/**
+* Serialize a SturdyRef to a string for storage
+*/
+function serializeSturdyRef(ref) {
+	return JSON.stringify(ref);
+}
+/**
+* Deserialize a SturdyRef from a string
+*/
+function deserializeSturdyRef(data) {
+	try {
+		const parsed = JSON.parse(data);
+		if (typeof parsed.vatId !== "string" || typeof parsed.localId !== "string") return null;
+		return {
+			vatId: parsed.vatId,
+			localId: parsed.localId,
+			version: parsed.version,
+			expiresAt: parsed.expiresAt,
+			metadata: parsed.metadata
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Check if a SturdyRef is valid (not expired)
+*/
+function isSturdyRefValid(ref) {
+	if (ref.expiresAt && Date.now() > ref.expiresAt) return false;
+	return true;
+}
+/**
+* Create a SturdyRef from components
+*/
+function createSturdyRef(vatId, localId, options) {
+	return {
+		vatId,
+		localId,
+		version: 1,
+		expiresAt: options?.ttlMs ? Date.now() + options.ttlMs : void 0,
+		metadata: options?.metadata
+	};
+}
+
+//#endregion
+//#region src/rpc/performance.ts
+/**
+* Performance Optimizations for RPC
+*
+* Phase 3: Performance improvements
+* - Multi-segment message support
+* - Memory pooling
+* - Zero-copy paths where possible
+*/
+/**
+* Memory pool for reusing ArrayBuffers
+* Reduces GC pressure for frequent allocations
+*/
+var MemoryPool = class {
+	pools = /* @__PURE__ */ new Map();
+	maxPoolSize;
+	maxBufferAge;
+	constructor(options) {
+		this.maxPoolSize = options?.maxPoolSize ?? 100;
+		this.maxBufferAge = options?.maxBufferAgeMs ?? 6e4;
+	}
+	/**
+	* Acquire a buffer of at least the requested size
+	*/
+	acquire(size) {
+		const pooledSize = this.roundUpSize(size);
+		const pool = this.pools.get(pooledSize);
+		if (pool && pool.length > 0) {
+			const now = Date.now();
+			const index = pool.findIndex((b) => now - b.lastUsed < this.maxBufferAge);
+			if (index >= 0) return pool.splice(index, 1)[0].buffer;
+		}
+		return new ArrayBuffer(pooledSize);
+	}
+	/**
+	* Release a buffer back to the pool
+	*/
+	release(buffer) {
+		const size = buffer.byteLength;
+		if (size < 64 || size > 1024 * 1024) return;
+		let pool = this.pools.get(size);
+		if (!pool) {
+			pool = [];
+			this.pools.set(size, pool);
+		}
+		if (pool.length < this.maxPoolSize) pool.push({
+			buffer,
+			size,
+			lastUsed: Date.now()
+		});
+	}
+	/**
+	* Clear all pooled buffers
+	*/
+	clear() {
+		this.pools.clear();
+	}
+	/**
+	* Get pool statistics
+	*/
+	getStats() {
+		let totalBuffers = 0;
+		let totalBytes = 0;
+		const sizes = [];
+		for (const [size, pool] of this.pools) {
+			totalBuffers += pool.length;
+			totalBytes += size * pool.length;
+			sizes.push(size);
+		}
+		return {
+			totalBuffers,
+			totalBytes,
+			sizes
+		};
+	}
+	roundUpSize(size) {
+		if (size <= 64) return 64;
+		if (size <= 128) return 128;
+		if (size <= 256) return 256;
+		if (size <= 512) return 512;
+		if (size <= 1024) return 1024;
+		if (size <= 2048) return 2048;
+		if (size <= 4096) return 4096;
+		if (size <= 8192) return 8192;
+		if (size <= 16384) return 16384;
+		if (size <= 32768) return 32768;
+		if (size <= 65536) return 65536;
+		return size;
+	}
+};
+/**
+* Builder for multi-segment messages
+* Optimizes memory usage for large messages
+*/
+var MultiSegmentMessageBuilder = class {
+	segments = [];
+	options;
+	currentSegment;
+	totalSize = 0;
+	constructor(options) {
+		this.options = {
+			initialSegmentSize: options?.initialSegmentSize ?? 8192,
+			maxSegmentSize: options?.maxSegmentSize ?? 65536,
+			allowMultipleSegments: options?.allowMultipleSegments ?? true
+		};
+		this.currentSegment = new Segment(this.options.initialSegmentSize);
+		this.segments.push(this.currentSegment);
+	}
+	/**
+	* Allocate space in the message
+	*/
+	allocate(size) {
+		const alignedBytes = size + 7 & -8;
+		const words = alignedBytes / 8;
+		if (this.currentSegment.byteLength - this.currentSegment.wordCount * 8 >= alignedBytes) {
+			const wordOffset = this.currentSegment.allocate(words);
+			this.totalSize += alignedBytes;
+			return {
+				segment: this.currentSegment,
+				offset: wordOffset * 8
+			};
+		}
+		if (!this.options.allowMultipleSegments) throw new Error("Message too large for single segment");
+		this.currentSegment = new Segment(Math.min(Math.max(alignedBytes, this.options.initialSegmentSize), this.options.maxSegmentSize));
+		this.segments.push(this.currentSegment);
+		const newWordOffset = this.currentSegment.allocate(words);
+		this.totalSize += alignedBytes;
+		return {
+			segment: this.currentSegment,
+			offset: newWordOffset * 8
+		};
+	}
+	/**
+	* Get all segments
+	*/
+	getSegments() {
+		return this.segments;
+	}
+	/**
+	* Get the total size of all segments
+	*/
+	getTotalSize() {
+		return this.totalSize;
+	}
+	/**
+	* Get the number of segments
+	*/
+	getSegmentCount() {
+		return this.segments.length;
+	}
+	/**
+	* Serialize to a single buffer (for transport)
+	*/
+	toBuffer() {
+		if (this.segments.length === 1) {
+			const segmentData = this.segments[0].asUint8Array();
+			return segmentData.buffer.slice(segmentData.byteOffset, segmentData.byteOffset + segmentData.byteLength);
+		}
+		const totalSize = this.segments.reduce((sum, seg) => sum + seg.byteLength, 0);
+		const result = new ArrayBuffer(totalSize + 8 * this.segments.length);
+		const view = new DataView(result);
+		const bytes = new Uint8Array(result);
+		view.setUint32(0, this.segments.length - 1, true);
+		view.setUint32(4, 0, true);
+		let offset = 8;
+		for (let i = 0; i < this.segments.length; i++) {
+			const segment = this.segments[i];
+			if (i > 0) {
+				view.setUint32(offset, segment.byteLength / 8, true);
+				offset += 4;
+			}
+			const segmentBuffer = new Uint8Array(segment.byteLength);
+			const segmentData = segment.dataView;
+			for (let i = 0; i < segment.byteLength; i++) segmentBuffer[i] = segmentData.getUint8(i);
+			bytes.set(segmentBuffer, offset);
+			offset += segment.byteLength;
+		}
+		return result;
+	}
+};
+/**
+* Create a zero-copy view of a buffer
+*/
+function createZeroCopyView(buffer, byteOffset = 0, byteLength) {
+	return {
+		buffer,
+		byteOffset,
+		byteLength: byteLength ?? buffer.byteLength - byteOffset
+	};
+}
+/**
+* Check if two buffers are the same underlying memory
+*/
+function isSameBuffer(a, b) {
+	try {
+		return a === b;
+	} catch {
+		return false;
+	}
+}
+/**
+* Copy data between buffers using the fastest available method
+*/
+function fastCopy(src, dst, srcOffset = 0, dstOffset = 0, length) {
+	const len = length ?? Math.min(src.byteLength - srcOffset, dst.byteLength - dstOffset);
+	const srcView = new Uint8Array(src, srcOffset, len);
+	new Uint8Array(dst, dstOffset, len).set(srcView);
+}
+/**
+* Optimized RPC message builder
+*/
+var OptimizedRpcMessageBuilder = class {
+	options;
+	pool;
+	constructor(options) {
+		this.options = {
+			useMultiSegment: options?.useMultiSegment ?? true,
+			initialSegmentSize: options?.initialSegmentSize ?? 8192,
+			useMemoryPool: options?.useMemoryPool ?? true,
+			memoryPool: options?.memoryPool ?? new MemoryPool()
+		};
+		this.pool = this.options.memoryPool;
+	}
+	/**
+	* Build a message with optimizations applied
+	*/
+	buildMessage(content) {
+		const totalSize = 8 + content.length;
+		if (this.options.useMemoryPool) {
+			const buffer = this.pool.acquire(totalSize);
+			const view = new DataView(buffer);
+			const bytes = new Uint8Array(buffer);
+			view.setUint32(0, 0, true);
+			view.setUint32(4, content.length / 8, true);
+			bytes.set(content, 8);
+			return buffer;
+		}
+		const buffer = new ArrayBuffer(totalSize);
+		const view = new DataView(buffer);
+		const bytes = new Uint8Array(buffer);
+		view.setUint32(0, 0, true);
+		view.setUint32(4, content.length / 8, true);
+		bytes.set(content, 8);
+		return buffer;
+	}
+	/**
+	* Release a buffer back to the pool
+	*/
+	releaseBuffer(buffer) {
+		if (this.options.useMemoryPool) this.pool.release(buffer);
+	}
+	/**
+	* Get pool statistics
+	*/
+	getPoolStats() {
+		return this.pool.getStats();
+	}
+};
+let globalMemoryPool = null;
+/**
+* Get the global memory pool instance
+*/
+function getGlobalMemoryPool() {
+	if (!globalMemoryPool) globalMemoryPool = new MemoryPool();
+	return globalMemoryPool;
+}
+/**
+* Configure the global memory pool
+*/
+function configureGlobalMemoryPool(options) {
+	globalMemoryPool = new MemoryPool(options);
+}
+
+//#endregion
+exports.AnswerTable = AnswerTable;
+exports.BaseCapabilityClient = BaseCapabilityClient;
 exports.ElementSize = ElementSize;
+exports.ExportTable = ExportTable;
+exports.ImportTable = ImportTable;
 exports.ListBuilder = ListBuilder;
 exports.ListReader = ListReader;
+exports.MemoryPool = MemoryPool;
 exports.MessageBuilder = MessageBuilder;
 exports.MessageReader = MessageReader;
+exports.MultiSegmentMessageBuilder = MultiSegmentMessageBuilder;
+exports.OptimizedRpcMessageBuilder = OptimizedRpcMessageBuilder;
+exports.PIPELINE_CLIENT_SYMBOL = PIPELINE_CLIENT_SYMBOL;
+exports.PipelineOpTracker = PipelineOpTracker;
+exports.PipelineResolutionTracker = PipelineResolutionTracker;
 exports.PointerTag = PointerTag;
+exports.QuestionTable = QuestionTable;
+exports.QueuedCallManager = QueuedCallManager;
+exports.RestoreHandler = RestoreHandler;
+exports.RpcConnection = RpcConnection;
 exports.Segment = Segment;
 exports.StructBuilder = StructBuilder;
 exports.StructReader = StructReader;
+exports.SturdyRefManager = SturdyRefManager;
 exports.UnionBuilder = UnionBuilder;
 exports.UnionReader = UnionReader;
 exports.WORD_SIZE = WORD_SIZE;
+exports.WebSocketTransport = WebSocketTransport;
+exports.configureGlobalMemoryPool = configureGlobalMemoryPool;
+exports.createPipelineClient = createPipelineClient;
+exports.createSturdyRef = createSturdyRef;
 exports.createUnionBuilder = createUnionBuilder;
 exports.createUnionReader = createUnionReader;
+exports.createZeroCopyView = createZeroCopyView;
 exports.decodePointer = decodePointer;
+exports.deserializeRpcMessage = deserializeRpcMessage;
+exports.deserializeSturdyRef = deserializeSturdyRef;
 exports.encodeListPointer = encodeListPointer;
 exports.encodeStructPointer = encodeStructPointer;
+exports.fastCopy = fastCopy;
+exports.getGlobalMemoryPool = getGlobalMemoryPool;
+exports.isPipelineClient = isPipelineClient;
+exports.isSameBuffer = isSameBuffer;
+exports.isSturdyRefValid = isSturdyRefValid;
+exports.serializeRpcMessage = serializeRpcMessage;
+exports.serializeSturdyRef = serializeSturdyRef;
 //# sourceMappingURL=index.cjs.map