@naeemo/capnp 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_rpc_connection = require('./rpc-connection-BKWQQ7f9.js');
 
 //#region src/core/pointer.ts
 /**
@@ -145,6 +146,12 @@ var Segment = class Segment {
 		return new Uint8Array(this.buffer, 0, this._size);
 	}
 	/**
+	* 获取底层 ArrayBuffer
+	*/
+	getArrayBuffer() {
+		return this.buffer;
+	}
+	/**
 	* 获取字数量
 	*/
 	get wordCount() {
@@ -825,21 +832,4152 @@ 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/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
+//#region src/rpc/connection-manager.ts
+/**
+* ConnectionManager manages multiple RPC connections for Level 3 RPC.
+*
+* Key responsibilities:
+* 1. Maintain a pool of connections to other vats
+* 2. Handle automatic connection establishment for third-party capabilities
+* 3. Manage pending provisions (capabilities waiting to be picked up)
+* 4. Route messages to the appropriate connection
+* 5. Handle connection lifecycle (connect, disconnect, reconnect)
+*/
+var ConnectionManager = class {
+	options;
+	connections = /* @__PURE__ */ new Map();
+	pendingProvisions = /* @__PURE__ */ new Map();
+	connectionPromises = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = {
+			maxConnections: 100,
+			idleTimeoutMs: 3e5,
+			autoConnect: true,
+			...options
+		};
+	}
+	/**
+	* Register an existing connection with the manager.
+	* This is called when a connection is established (either inbound or outbound).
+	*/
+	registerConnection(vatId, connection) {
+		const vatIdKey = this.vatIdToKey(vatId);
+		const info = {
+			connection,
+			remoteVatId: vatId,
+			establishedAt: /* @__PURE__ */ new Date(),
+			lastActivity: /* @__PURE__ */ new Date(),
+			state: "connected"
+		};
+		this.connections.set(vatIdKey, info);
+		return info;
+	}
+	/**
+	* Get or establish a connection to a vat.
+	* If autoConnect is enabled and no connection exists, a new one will be created.
+	*/
+	async getConnection(vatId) {
+		const vatIdKey = this.vatIdToKey(vatId);
+		const existing = this.connections.get(vatIdKey);
+		if (existing && existing.state === "connected") {
+			existing.lastActivity = /* @__PURE__ */ new Date();
+			return existing.connection;
+		}
+		const pending = this.connectionPromises.get(vatIdKey);
+		if (pending) return pending;
+		if (this.options.autoConnect) return this.establishConnection(vatId);
+	}
+	/**
+	* Establish a new connection to a vat.
+	*/
+	async establishConnection(vatId, address) {
+		const vatIdKey = this.vatIdToKey(vatId);
+		if (this.connectionPromises.has(vatIdKey)) return this.connectionPromises.get(vatIdKey);
+		const connectPromise = this.doEstablishConnection(vatId, address);
+		this.connectionPromises.set(vatIdKey, connectPromise);
+		try {
+			return await connectPromise;
+		} finally {
+			this.connectionPromises.delete(vatIdKey);
+		}
+	}
+	async doEstablishConnection(vatId, address) {
+		const { RpcConnection } = await Promise.resolve().then(() => require("./rpc-connection-BKWQQ7f9.js")).then((n) => n.rpc_connection_exports);
+		const connection = new RpcConnection(await this.options.connectionFactory(vatId, address), this.options.connectionOptions);
+		await connection.start();
+		this.registerConnection(vatId, connection);
+		return connection;
+	}
+	/**
+	* Close a connection to a vat.
+	*/
+	async closeConnection(vatId) {
+		const vatIdKey = this.vatIdToKey(vatId);
+		const info = this.connections.get(vatIdKey);
+		if (info) {
+			info.state = "closing";
+			await info.connection.stop();
+			this.connections.delete(vatIdKey);
+		}
+	}
+	/**
+	* Close all connections.
+	*/
+	async closeAll() {
+		const closePromises = [];
+		for (const [_vatIdKey, info] of this.connections) {
+			info.state = "closing";
+			closePromises.push(info.connection.stop().catch(() => {}));
+		}
+		await Promise.all(closePromises);
+		this.connections.clear();
+		this.pendingProvisions.clear();
+	}
+	/**
+	* Create a pending provision for a third-party capability.
+	* Called when we receive a Provide message.
+	*/
+	createPendingProvision(provisionId, recipientId, targetExportId, questionId, embargoed) {
+		const provisionKey = this.provisionIdToKey(provisionId);
+		const provision = {
+			provisionId,
+			recipientId,
+			targetExportId,
+			questionId,
+			createdAt: /* @__PURE__ */ new Date(),
+			embargoed
+		};
+		this.pendingProvisions.set(provisionKey, provision);
+		return provision;
+	}
+	/**
+	* Get a pending provision by ID.
+	*/
+	getPendingProvision(provisionId) {
+		const provisionKey = this.provisionIdToKey(provisionId);
+		return this.pendingProvisions.get(provisionKey);
+	}
+	/**
+	* Remove a pending provision (when it's been accepted or expired).
+	*/
+	removePendingProvision(provisionId) {
+		const provisionKey = this.provisionIdToKey(provisionId);
+		return this.pendingProvisions.delete(provisionKey);
+	}
+	/**
+	* Find provisions for a specific recipient.
+	*/
+	findProvisionsForRecipient(recipientId) {
+		const recipientKey = this.vatIdToKey(recipientId);
+		const result = [];
+		for (const provision of this.pendingProvisions.values()) if (this.vatIdToKey(provision.recipientId) === recipientKey) result.push(provision);
+		return result;
+	}
+	/**
+	* Clean up expired provisions.
+	*/
+	cleanupExpiredProvisions(maxAgeMs = 3e5) {
+		const now = Date.now();
+		let removed = 0;
+		for (const [key, provision] of this.pendingProvisions) if (now - provision.createdAt.getTime() > maxAgeMs) {
+			this.pendingProvisions.delete(key);
+			removed++;
+		}
+		return removed;
+	}
+	/**
+	* Resolve a third-party capability ID to a connection.
+	* This is the core of Level 3 RPC - automatically establishing connections
+	* to third parties when capabilities are passed between vats.
+	*/
+	async resolveThirdPartyCap(thirdPartyCapId) {
+		const parsed = this.parseThirdPartyCapId(thirdPartyCapId);
+		if (!parsed) return;
+		const connection = await this.getConnection(parsed.vatId);
+		if (!connection) return;
+		return {
+			connection,
+			provisionId: parsed.provisionId
+		};
+	}
+	/**
+	* Parse a ThirdPartyCapId to extract vat ID and provision ID.
+	* The format is implementation-specific, but typically:
+	* - First N bytes: vat ID
+	* - Remaining bytes: provision ID
+	*/
+	parseThirdPartyCapId(thirdPartyCapId) {
+		const data = thirdPartyCapId.id;
+		if (data.length < 32) return;
+		const vatIdBytes = data.slice(0, 32);
+		const provisionIdBytes = data.slice(32);
+		return {
+			vatId: { id: vatIdBytes },
+			provisionId: { id: provisionIdBytes }
+		};
+	}
+	/**
+	* Get all active connections.
+	*/
+	getAllConnections() {
+		return Array.from(this.connections.values());
+	}
+	/**
+	* Get the number of active connections.
+	*/
+	getConnectionCount() {
+		return this.connections.size;
+	}
+	/**
+	* Get the number of pending provisions.
+	*/
+	getPendingProvisionCount() {
+		return this.pendingProvisions.size;
+	}
+	/**
+	* Check if a connection exists to a vat.
+	*/
+	hasConnection(vatId) {
+		const vatIdKey = this.vatIdToKey(vatId);
+		const info = this.connections.get(vatIdKey);
+		return info !== void 0 && info.state === "connected";
+	}
+	/**
+	* Update the last activity timestamp for a connection.
+	*/
+	touchConnection(vatId) {
+		const vatIdKey = this.vatIdToKey(vatId);
+		const info = this.connections.get(vatIdKey);
+		if (info) info.lastActivity = /* @__PURE__ */ new Date();
+	}
+	vatIdToKey(vatId) {
+		return Array.from(vatId.id).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+	provisionIdToKey(provisionId) {
+		return Array.from(provisionId.id).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+};
+/**
+* Create a ThirdPartyCapId from vat ID and provision ID.
+*/
+function createThirdPartyCapId(vatId, provisionId) {
+	const combined = new Uint8Array(vatId.id.length + provisionId.id.length);
+	combined.set(vatId.id, 0);
+	combined.set(provisionId.id, vatId.id.length);
+	return { id: combined };
+}
+/**
+* Create a RecipientId from a vat ID.
+*/
+function createRecipientId(vatId) {
+	return { id: vatId.id };
+}
+/**
+* Create a ProvisionId from raw bytes.
+*/
+function createProvisionId(id) {
+	return { id };
+}
+/**
+* Generate a random provision ID.
+*/
+function generateProvisionId() {
+	const id = new Uint8Array(32);
+	if (typeof crypto !== "undefined" && crypto.getRandomValues) crypto.getRandomValues(id);
+	else {
+		const { randomBytes } = require("node:crypto");
+		randomBytes(32).copy(id);
+	}
+	return { id };
+}
+/**
+* Generate a random vat ID.
+*/
+function generateVatId() {
+	const id = new Uint8Array(32);
+	if (typeof crypto !== "undefined" && crypto.getRandomValues) crypto.getRandomValues(id);
+	else {
+		const { randomBytes } = require("node:crypto");
+		randomBytes(32).copy(id);
+	}
+	return { id };
+}
+
+//#endregion
+//#region src/rpc/level3-handlers.ts
+/**
+* Manages Level 3 RPC message handling for a connection.
+*
+* This class handles:
+* 1. Provide messages - when someone wants to give us a capability to share with a third party
+* 2. Accept messages - when a third party wants to pick up a capability we provided
+* 3. Embargo handling - breaking cycles in introduction graphs
+*/
+var Level3Handlers = class {
+	options;
+	pendingAccepts = /* @__PURE__ */ new Map();
+	embargoedCalls = /* @__PURE__ */ new Map();
+	nextEmbargoId = 1;
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Handle an incoming Provide message.
+	*
+	* When we receive a Provide message, it means someone wants us to hold a capability
+	* and make it available to a specific third party. We:
+	* 1. Create a pending provision
+	* 2. Return an answer acknowledging receipt
+	* 3. Wait for the third party to Accept
+	*/
+	async handleProvide(provide) {
+		const { questionId, target, recipient } = provide;
+		const { connectionManager } = this.options;
+		const provisionId = generateProvisionId();
+		const targetExportId = this.extractTargetExportId(target);
+		if (targetExportId === void 0) {
+			await this.sendReturnException(questionId, "Invalid provide target: must be a hosted capability");
+			return;
+		}
+		connectionManager.createPendingProvision(provisionId, this.recipientIdToVatId(recipient), targetExportId, questionId, false);
+		if (this.options.onProvide) await this.options.onProvide(provide);
+		await this.sendReturnResults(questionId, { provisionId: provisionId.id });
+	}
+	/**
+	* Send a Provide message to offer a capability to a third party.
+	*
+	* This is called when we want to introduce a third party to a capability we hold.
+	* For example, Alice calls this to offer Bob access to Carol's capability.
+	*/
+	async sendProvide(target, recipient) {
+		const { connection } = this.options;
+		const questionId = connection.createQuestion();
+		const provideMsg = {
+			type: "provide",
+			provide: {
+				questionId,
+				target,
+				recipient
+			}
+		};
+		await connection.sendCall(provideMsg.provide);
+		await connection.waitForAnswer(questionId);
+		return {
+			questionId,
+			provisionId: { id: new Uint8Array(0) }
+		};
+	}
+	/**
+	* Handle an incoming Accept message.
+	*
+	* When we receive an Accept message, it means a third party wants to pick up
+	* a capability we previously agreed to provide. We:
+	* 1. Look up the pending provision
+	* 2. Verify the recipient matches
+	* 3. Return the capability
+	*/
+	async handleAccept(accept) {
+		const { questionId, provision, embargo } = accept;
+		const { connectionManager } = this.options;
+		const pendingProvision = connectionManager.getPendingProvision(provision);
+		if (!pendingProvision) {
+			await this.sendReturnException(questionId, "Invalid provision ID: no pending provision found");
+			return;
+		}
+		connectionManager.removePendingProvision(provision);
+		if (embargo || pendingProvision.embargoed) {
+			await this.handleEmbargoedAccept(questionId, pendingProvision);
+			return;
+		}
+		const capDescriptor = {
+			type: "senderHosted",
+			exportId: pendingProvision.targetExportId
+		};
+		await this.sendReturnCapability(questionId, capDescriptor);
+		if (this.options.onAccept) await this.options.onAccept(accept);
+	}
+	/**
+	* Send an Accept message to pick up a capability from a third party.
+	*
+	* This is called when we receive a third-party capability and want to
+	* establish a direct connection to use it.
+	*/
+	async sendAccept(targetConnection, provision, embargo = false) {
+		const questionId = targetConnection.createQuestion();
+		const acceptMsg = {
+			type: "accept",
+			accept: {
+				questionId,
+				provision,
+				embargo
+			}
+		};
+		await targetConnection.sendCall(acceptMsg.accept);
+		await targetConnection.waitForAnswer(questionId);
+		return 0;
+	}
+	/**
+	* Handle an embargoed accept.
+	*
+	* Embargoes are used to break cycles in the introduction graph. For example,
+	* if Alice introduces Bob to Carol and Carol to Bob simultaneously, both
+	* introductions use embargo=true to prevent deadlock.
+	*/
+	async handleEmbargoedAccept(questionId, provision) {
+		const pendingAccept = {
+			questionId,
+			provision,
+			embargoId: this.nextEmbargoId++
+		};
+		this.pendingAccepts.set(questionId, pendingAccept);
+		await this.sendReturnResultsSentElsewhere(questionId);
+	}
+	/**
+	* Handle a Disembargo message.
+	*
+	* Disembargo messages are used to lift embargoes on capabilities.
+	*/
+	async handleDisembargo(disembargo) {
+		const { target, context } = disembargo;
+		switch (context.type) {
+			case "senderLoopback":
+				await this.sendDisembargoEcho(disembargo);
+				break;
+			case "receiverLoopback":
+				await this.liftEmbargo(context.embargoId);
+				break;
+			case "accept":
+				await this.liftAcceptEmbargo(target);
+				break;
+			case "provide":
+				await this.liftProvideEmbargo(context.questionId);
+				break;
+		}
+	}
+	/**
+	* Lift an embargo by ID.
+	*/
+	async liftEmbargo(embargoId) {
+		const calls = this.embargoedCalls.get(embargoId);
+		if (calls) {
+			for (const call of calls) await this.resendEmbargoedCall(call);
+			this.embargoedCalls.delete(embargoId);
+		}
+	}
+	/**
+	* Lift an embargo on an accept.
+	*/
+	async liftAcceptEmbargo(target) {
+		for (const [questionId, pendingAccept] of this.pendingAccepts) if (this.matchesTarget(pendingAccept.provision.targetExportId, target)) {
+			const capDescriptor = {
+				type: "senderHosted",
+				exportId: pendingAccept.provision.targetExportId
+			};
+			await this.sendReturnCapability(pendingAccept.questionId, capDescriptor);
+			this.pendingAccepts.delete(questionId);
+		}
+	}
+	/**
+	* Lift an embargo on a provide.
+	*/
+	async liftProvideEmbargo(_questionId) {
+		const { connectionManager } = this.options;
+		for (const _provision of connectionManager.getAllConnections());
+	}
+	/**
+	* Handle receiving a third-party capability.
+	*
+	* When we receive a CapDescriptor with type 'thirdPartyHosted', we need to:
+	* 1. Establish a connection to the third party (if not already connected)
+	* 2. Send an Accept message to pick up the capability
+	* 3. Return a local import ID for the capability
+	*/
+	async handleThirdPartyCapability(thirdPartyCapId) {
+		const { connectionManager } = this.options;
+		const resolved = await connectionManager.resolveThirdPartyCap(thirdPartyCapId);
+		if (!resolved) return;
+		const { connection, provisionId } = resolved;
+		return await this.sendAccept(connection, provisionId);
+	}
+	/**
+	* Create a third-party capability descriptor.
+	*
+	* This is called when we want to pass a capability to a peer, but the capability
+	* is actually hosted by a third party. We create a ThirdPartyCapId that allows
+	* the recipient to connect directly to the third party.
+	*/
+	createThirdPartyCapDescriptor(_hostedConnection, exportId, recipientVatId) {
+		const { connectionManager, selfVatId } = this.options;
+		const provisionId = generateProvisionId();
+		const thirdPartyCapId = createThirdPartyCapId(selfVatId, provisionId);
+		connectionManager.createPendingProvision(provisionId, recipientVatId, exportId, 0, false);
+		return {
+			type: "thirdPartyHosted",
+			thirdPartyCapId
+		};
+	}
+	extractTargetExportId(target) {
+		if (target.type === "importedCap") return target.importId;
+	}
+	recipientIdToVatId(recipient) {
+		return { id: recipient.id };
+	}
+	matchesTarget(exportId, target) {
+		if (target.type === "importedCap") return target.importId === exportId;
+		return false;
+	}
+	async sendReturnResults(questionId, _results) {
+		const { connection } = this.options;
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: {
+					type: "results",
+					payload: {
+						content: new Uint8Array(0),
+						capTable: []
+					}
+				}
+			}
+		};
+		await connection.sendReturn(returnMsg.return);
+	}
+	async sendReturnCapability(questionId, cap) {
+		const { connection } = this.options;
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: {
+					type: "results",
+					payload: {
+						content: new Uint8Array(0),
+						capTable: [cap]
+					}
+				}
+			}
+		};
+		await connection.sendReturn(returnMsg.return);
+	}
+	async sendReturnException(questionId, reason) {
+		const { connection } = this.options;
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: {
+					type: "exception",
+					exception: {
+						reason,
+						type: "failed"
+					}
+				}
+			}
+		};
+		await connection.sendReturn(returnMsg.return);
+	}
+	async sendReturnResultsSentElsewhere(questionId) {
+		const { connection } = this.options;
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: { type: "resultsSentElsewhere" }
+			}
+		};
+		await connection.sendReturn(returnMsg.return);
+	}
+	async sendDisembargoEcho(disembargo) {
+		const { connection } = this.options;
+		if (disembargo.context.type !== "senderLoopback") return;
+		const echoMsg = {
+			type: "disembargo",
+			disembargo: {
+				target: disembargo.target,
+				context: {
+					type: "receiverLoopback",
+					embargoId: disembargo.context.embargoId
+				}
+			}
+		};
+		await connection.sendDisembargo(echoMsg.disembargo);
+	}
+	async resendEmbargoedCall(_call) {}
+};
+
+//#endregion
+//#region src/rpc/level4-types.ts
+/**
+* Default join options.
+*/
+const DEFAULT_JOIN_OPTIONS = {
+	timeoutMs: 3e4,
+	requireCryptoVerification: true,
+	cacheResult: true,
+	cacheTtlMs: 3e5
+};
+/**
+* Default escrow configuration.
+*/
+const DEFAULT_ESCROW_CONFIG = {
+	enabled: false,
+	requiredParties: 2,
+	timeoutMs: 6e4
+};
+/**
+* Default join security policy.
+*/
+const DEFAULT_JOIN_SECURITY_POLICY = {
+	verifyIdentityHashes: true,
+	checkRevocation: true,
+	maxProxyDepth: 10,
+	auditLog: true,
+	allowedVats: []
+};
+
+//#endregion
+//#region src/rpc/level4-handlers.ts
+/**
+* Manages Level 4 RPC message handling for reference equality verification.
+*
+* This class handles:
+* 1. Join messages - verifying that two capabilities point to the same object
+* 2. Object identity tracking and caching
+* 3. Escrow agent functionality for consensus verification
+* 4. Security verification (anti-spoofing)
+*
+* ## Usage Example
+*
+* ```typescript
+* const level4Handlers = new Level4Handlers({
+*   connection,
+*   connectionManager,
+*   level3Handlers,
+*   selfVatId,
+* });
+*
+* // Enable escrow mode for consensus verification
+* level4Handlers.setEscrowConfig({
+*   enabled: true,
+*   requiredParties: 2,
+* });
+*
+* // Send a Join request
+* const result = await level4Handlers.sendJoin(target1, target2);
+* if (result.equal) {
+*   console.log('Capabilities point to the same object!');
+* }
+* ```
+*/
+var Level4Handlers = class {
+	options;
+	pendingJoins = /* @__PURE__ */ new Map();
+	joinResultsCache = /* @__PURE__ */ new Map();
+	objectIdentities = /* @__PURE__ */ new Map();
+	nextJoinId = 1;
+	escrowConfig;
+	securityPolicy;
+	joinOptions;
+	escrowParties = /* @__PURE__ */ new Map();
+	escrowConsensus;
+	constructor(options) {
+		this.options = options;
+		this.escrowConfig = {
+			...DEFAULT_ESCROW_CONFIG,
+			...options.escrowConfig
+		};
+		this.securityPolicy = {
+			...DEFAULT_JOIN_SECURITY_POLICY,
+			...options.securityPolicy
+		};
+		this.joinOptions = {
+			...DEFAULT_JOIN_OPTIONS,
+			...options.joinOptions
+		};
+	}
+	/**
+	* Handle an incoming Join message.
+	*
+	* When we receive a Join message, we need to verify whether the two
+	* capability references point to the same underlying object.
+	*
+	* The verification process:
+	* 1. Resolve both targets to their underlying objects
+	* 2. Compare object identities (vat ID + object ID)
+	* 3. Optionally verify identity hashes cryptographically
+	* 4. Return the result
+	*/
+	async handleJoin(join) {
+		const { questionId, target, otherCap, joinId } = join;
+		try {
+			const cacheKey = this.getCacheKey(target, otherCap);
+			const cached = this.joinResultsCache.get(cacheKey);
+			if (cached && Date.now() - cached.cachedAt < this.joinOptions.cacheTtlMs) {
+				await this.sendJoinResult(questionId, cached.result);
+				return;
+			}
+			const identity1 = await this.resolveTargetToIdentity(target);
+			const identity2 = await this.resolveTargetToIdentity(otherCap);
+			const result = this.compareIdentities(identity1, identity2, joinId);
+			if (this.joinOptions.cacheResult) this.joinResultsCache.set(cacheKey, {
+				result,
+				cachedAt: Date.now(),
+				targets: [this.hashTarget(target), this.hashTarget(otherCap)]
+			});
+			if (this.securityPolicy.auditLog) this.logJoinOperation(target, otherCap, result);
+			await this.sendJoinResult(questionId, result);
+			if (this.options.onJoin) await this.options.onJoin(join);
+		} catch (error) {
+			await this.sendJoinException(questionId, error instanceof Error ? error.message : "Join operation failed");
+		}
+	}
+	/**
+	* Send a Join message to verify that two capabilities point to the same object.
+	*
+	* @param target1 First capability target
+	* @param target2 Second capability target
+	* @returns Promise resolving to the join result
+	*/
+	async sendJoin(target1, target2) {
+		const { connection } = this.options;
+		const joinId = this.nextJoinId++;
+		const questionId = connection.createQuestion();
+		const pendingJoin = {
+			joinId,
+			target1,
+			target2,
+			startedAt: Date.now(),
+			resolve: () => {},
+			reject: () => {}
+		};
+		const completionPromise = new Promise((resolve, reject) => {
+			pendingJoin.resolve = resolve;
+			pendingJoin.reject = reject;
+		});
+		this.pendingJoins.set(joinId, pendingJoin);
+		const timeoutMs = this.joinOptions.timeoutMs;
+		const timeoutId = setTimeout(() => {
+			this.pendingJoins.delete(joinId);
+			pendingJoin.reject(/* @__PURE__ */ new Error(`Join operation timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		const originalResolve = pendingJoin.resolve;
+		pendingJoin.resolve = (result) => {
+			clearTimeout(timeoutId);
+			this.pendingJoins.delete(joinId);
+			originalResolve(result);
+		};
+		try {
+			const joinMsg = {
+				type: "join",
+				join: {
+					questionId,
+					target: target1,
+					otherCap: target2,
+					joinId
+				}
+			};
+			await connection.sendCall(joinMsg.join);
+			return await completionPromise;
+		} catch (error) {
+			clearTimeout(timeoutId);
+			this.pendingJoins.delete(joinId);
+			throw error;
+		}
+	}
+	/**
+	* Complete a pending join operation with the result.
+	* This is called when we receive a Return message for a Join.
+	*/
+	completeJoin(joinId, result) {
+		const pending = this.pendingJoins.get(joinId);
+		if (pending) {
+			pending.resolve(result);
+			this.pendingJoins.delete(joinId);
+		}
+	}
+	/**
+	* Resolve a MessageTarget to its ObjectIdentity.
+	*
+	* This may involve:
+	* 1. Looking up local exports
+	* 2. Resolving promises
+	* 3. Following third-party capabilities
+	* 4. Verifying proxy chains
+	*/
+	async resolveTargetToIdentity(target) {
+		if (target.type === "importedCap") {
+			const cached = this.objectIdentities.get(target.importId);
+			if (cached) return cached;
+			if (!this.options.connection.getImport(target.importId)) return null;
+			return null;
+		}
+		if (target.type === "promisedAnswer") {
+			const { questionId } = target.promisedAnswer;
+			try {
+				await this.options.connection.waitForAnswer(questionId);
+				return null;
+			} catch {
+				return null;
+			}
+		}
+		return null;
+	}
+	/**
+	* Compare two object identities for equality.
+	*/
+	compareIdentities(identity1, identity2, joinId) {
+		if (!identity1 && !identity2) return {
+			equal: true,
+			joinId
+		};
+		if (!identity1 || !identity2) return {
+			equal: false,
+			joinId,
+			inequalityReason: "One capability is null, the other is not"
+		};
+		if (!this.arraysEqual(identity1.vatId, identity2.vatId)) return {
+			equal: false,
+			joinId,
+			inequalityReason: "Capabilities hosted by different vats"
+		};
+		if (!this.arraysEqual(identity1.objectId, identity2.objectId)) return {
+			equal: false,
+			joinId,
+			inequalityReason: "Different object IDs within the same vat"
+		};
+		if (this.securityPolicy.verifyIdentityHashes) {
+			if (identity1.identityHash && identity2.identityHash) {
+				if (!this.arraysEqual(identity1.identityHash, identity2.identityHash)) return {
+					equal: false,
+					joinId,
+					inequalityReason: "Identity hash mismatch (possible spoofing attempt)"
+				};
+			}
+		}
+		return {
+			equal: true,
+			joinId,
+			identity: identity1
+		};
+	}
+	/**
+	* Set the escrow configuration.
+	*/
+	setEscrowConfig(config) {
+		this.escrowConfig = {
+			...this.escrowConfig,
+			...config
+		};
+	}
+	/**
+	* Register a party in an escrow consensus verification.
+	*
+	* This is used when multiple parties need to verify they are referring
+	* to the same object (e.g., in a trade or agreement).
+	*
+	* @param partyId Unique identifier for the party
+	* @param target The capability reference from this party
+	* @returns Whether consensus has been reached
+	*/
+	async registerEscrowParty(partyId, target) {
+		if (!this.escrowConfig.enabled) throw new Error("Escrow mode is not enabled");
+		if (this.escrowParties.has(partyId)) throw new Error(`Party ${partyId} is already registered`);
+		this.escrowParties.set(partyId, { target });
+		if (this.escrowParties.size >= this.escrowConfig.requiredParties) {
+			const consensus = await this.verifyEscrowConsensus();
+			if (consensus.consensus) {
+				this.escrowConsensus = {
+					identity: consensus.identity,
+					parties: Array.from(this.escrowParties.keys())
+				};
+				if (this.escrowConfig.onConsensus) this.escrowConfig.onConsensus(consensus.identity, Array.from(this.escrowParties.keys()));
+			} else if (this.escrowConfig.onConsensusFailure) this.escrowConfig.onConsensusFailure(consensus.reason, Array.from(this.escrowParties.keys()));
+			return {
+				consensus: consensus.consensus,
+				identity: consensus.identity
+			};
+		}
+		return { consensus: false };
+	}
+	/**
+	* Verify that all registered escrow parties refer to the same object.
+	*/
+	async verifyEscrowConsensus() {
+		const parties = Array.from(this.escrowParties.entries());
+		if (parties.length < this.escrowConfig.requiredParties) return {
+			consensus: false,
+			reason: "Not enough parties registered"
+		};
+		const [firstPartyId, firstParty] = parties[0];
+		const firstIdentity = await this.resolveTargetToIdentity(firstParty.target);
+		if (!firstIdentity) return {
+			consensus: false,
+			reason: `Could not resolve identity for party ${firstPartyId}`
+		};
+		for (const [partyId, party] of parties.slice(1)) {
+			const identity = await this.resolveTargetToIdentity(party.target);
+			const comparison = this.compareIdentities(firstIdentity, identity, 0);
+			if (!comparison.equal) return {
+				consensus: false,
+				reason: `Party ${partyId} refers to a different object: ${comparison.inequalityReason}`
+			};
+		}
+		return {
+			consensus: true,
+			identity: firstIdentity
+		};
+	}
+	/**
+	* Clear all escrow state.
+	*/
+	clearEscrow() {
+		this.escrowParties.clear();
+		this.escrowConsensus = void 0;
+	}
+	/**
+	* Get the current escrow consensus if reached.
+	*/
+	getEscrowConsensus() {
+		return this.escrowConsensus;
+	}
+	/**
+	* Set the security policy.
+	*/
+	setSecurityPolicy(policy) {
+		this.securityPolicy = {
+			...this.securityPolicy,
+			...policy
+		};
+	}
+	/**
+	* Verify that a vat is allowed to participate in join operations.
+	*/
+	isVatAllowed(vatId) {
+		if (this.securityPolicy.allowedVats.length === 0) return true;
+		return this.securityPolicy.allowedVats.some((allowed) => this.arraysEqual(allowed, vatId));
+	}
+	/**
+	* Generate a cryptographic identity hash for an object.
+	*
+	* This creates a verifiable fingerprint of the object's identity
+	* that can be used to detect spoofing attempts.
+	*/
+	async generateIdentityHash(vatId, objectId) {
+		const combined = new Uint8Array(vatId.length + objectId.length);
+		combined.set(vatId, 0);
+		combined.set(objectId, vatId.length);
+		if (typeof crypto !== "undefined" && crypto.subtle) {
+			const hashBuffer = await crypto.subtle.digest("SHA-256", combined);
+			return new Uint8Array(hashBuffer);
+		}
+		const { createHash } = require("node:crypto");
+		const hash = createHash("sha256");
+		hash.update(combined);
+		return hash.digest();
+	}
+	/**
+	* Clear the join results cache.
+	*/
+	clearCache() {
+		this.joinResultsCache.clear();
+	}
+	/**
+	* Clean up expired cache entries.
+	*/
+	cleanupExpiredCache() {
+		const now = Date.now();
+		let removed = 0;
+		for (const [key, entry] of this.joinResultsCache) if (now - entry.cachedAt > this.joinOptions.cacheTtlMs) {
+			this.joinResultsCache.delete(key);
+			removed++;
+		}
+		return removed;
+	}
+	/**
+	* Get cache statistics.
+	*/
+	getCacheStats() {
+		return {
+			size: this.joinResultsCache.size,
+			hitRate: 0
+		};
+	}
+	getCacheKey(target1, target2) {
+		const sorted = [this.hashTarget(target1), this.hashTarget(target2)].sort();
+		return `join:${sorted[0]}:${sorted[1]}`;
+	}
+	hashTarget(target) {
+		if (target.type === "importedCap") return `import:${target.importId}`;
+		if (target.type === "promisedAnswer") return `answer:${target.promisedAnswer.questionId}`;
+		return "unknown";
+	}
+	arraysEqual(a, b) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+		return true;
+	}
+	async sendJoinResult(questionId, result) {
+		const { connection } = this.options;
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: {
+					type: "results",
+					payload: {
+						content: this.serializeJoinResult(result),
+						capTable: []
+					}
+				}
+			}
+		};
+		await connection.sendReturn(returnMsg.return);
+	}
+	async sendJoinException(questionId, reason) {
+		const { connection } = this.options;
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: {
+					type: "exception",
+					exception: {
+						reason,
+						type: "failed"
+					}
+				}
+			}
+		};
+		await connection.sendReturn(returnMsg.return);
+	}
+	serializeJoinResult(result) {
+		const obj = {
+			equal: result.equal,
+			joinId: result.joinId,
+			inequalityReason: result.inequalityReason
+		};
+		return new TextEncoder().encode(JSON.stringify(obj));
+	}
+	logJoinOperation(target1, target2, result) {
+		console.log("[Level4] Join operation:", {
+			target1: this.hashTarget(target1),
+			target2: this.hashTarget(target2),
+			equal: result.equal,
+			joinId: result.joinId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+};
+
+//#endregion
+//#region src/rpc/stream.ts
+/** Stream priority levels */
+let StreamPriority = /* @__PURE__ */ function(StreamPriority) {
+	StreamPriority[StreamPriority["CRITICAL"] = 0] = "CRITICAL";
+	StreamPriority[StreamPriority["HIGH"] = 1] = "HIGH";
+	StreamPriority[StreamPriority["NORMAL"] = 2] = "NORMAL";
+	StreamPriority[StreamPriority["LOW"] = 3] = "LOW";
+	StreamPriority[StreamPriority["BACKGROUND"] = 4] = "BACKGROUND";
+	return StreamPriority;
+}({});
+/** Default flow control configuration */
+const DEFAULT_FLOW_CONTROL = {
+	initialWindowSize: 65536,
+	maxWindowSize: 1048576,
+	minWindowSize: 4096,
+	windowUpdateThreshold: 16384,
+	windowUpdateIncrement: 32768
+};
+/**
+* Stream abstraction for Cap'n Proto RPC
+*
+* Manages bidirectional streaming with flow control and backpressure.
+*/
+var Stream = class {
+	options;
+	handlers;
+	state = "connecting";
+	error;
+	sendWindow;
+	receiveWindow;
+	flowControlConfig;
+	sendBuffer = [];
+	receiveBuffer = [];
+	maxBufferSize = 1048576;
+	bytesSent = 0;
+	bytesReceived = 0;
+	totalBytesExpected;
+	lastProgressUpdate = 0;
+	progressUpdateInterval;
+	transferStartTime;
+	nextSendSequence = 0;
+	nextExpectedSequence = 0;
+	openResolver;
+	openRejector;
+	closeResolver;
+	constructor(options, handlers = {}) {
+		this.options = options;
+		this.handlers = handlers;
+		this.flowControlConfig = {
+			...DEFAULT_FLOW_CONTROL,
+			...options.flowControl
+		};
+		this.sendWindow = {
+			currentSize: this.flowControlConfig.initialWindowSize,
+			maxSize: this.flowControlConfig.maxWindowSize,
+			bytesInWindow: 0,
+			backpressureActive: false
+		};
+		this.receiveWindow = {
+			currentSize: this.flowControlConfig.initialWindowSize,
+			maxSize: this.flowControlConfig.maxWindowSize,
+			bytesInWindow: 0,
+			backpressureActive: false
+		};
+		this.progressUpdateInterval = options.progressInterval ?? 65536;
+	}
+	/** Get stream ID */
+	get id() {
+		return this.options.streamId;
+	}
+	/** Get stream direction */
+	get direction() {
+		return this.options.direction;
+	}
+	/** Get stream priority */
+	get priority() {
+		return this.options.priority ?? StreamPriority.NORMAL;
+	}
+	/** Get current stream state */
+	get currentState() {
+		return this.state;
+	}
+	/** Get whether stream is open */
+	get isOpen() {
+		return this.state === "open";
+	}
+	/** Get whether backpressure is active for sending */
+	get isBackpressureActive() {
+		return this.sendWindow.backpressureActive;
+	}
+	/** Get bytes sent */
+	get bytesSentCount() {
+		return this.bytesSent;
+	}
+	/** Get bytes received */
+	get bytesReceivedCount() {
+		return this.bytesReceived;
+	}
+	/** Get metadata */
+	get metadata() {
+		return this.options.metadata;
+	}
+	/**
+	* Open the stream
+	*/
+	async open() {
+		if (this.state !== "connecting") throw new Error(`Cannot open stream in state: ${this.state}`);
+		return new Promise((resolve, reject) => {
+			this.openResolver = resolve;
+			this.openRejector = reject;
+			this.transitionState("open");
+			this.transferStartTime = Date.now();
+			this.handlers.onOpen?.();
+		});
+	}
+	/**
+	* Send data through the stream
+	*
+	* Respects flow control and handles backpressure.
+	*/
+	async send(data, endOfStream = false) {
+		if (this.state !== "open") throw new Error(`Cannot send in state: ${this.state}`);
+		if (this.sendWindow.bytesInWindow + data.length > this.sendWindow.currentSize) await this.waitForWindowUpdate();
+		const chunk = {
+			data,
+			endOfStream,
+			sequenceNumber: this.nextSendSequence++,
+			timestamp: Date.now()
+		};
+		this.sendWindow.bytesInWindow += data.length;
+		this.bytesSent += data.length;
+		this.checkBackpressure();
+		await this.sendChunk(chunk);
+		this.reportProgress();
+	}
+	/**
+	* Send a chunk of data
+	*
+	* Override in subclasses to implement actual transport.
+	*/
+	async sendChunk(chunk) {
+		this.sendBuffer.push(chunk);
+	}
+	/**
+	* Receive data from the stream
+	*
+	* Returns buffered data or waits for new data.
+	*/
+	async receive() {
+		if (this.receiveBuffer.length > 0) return this.receiveBuffer.shift();
+		if (this.state === "closed") return null;
+		return new Promise((resolve, reject) => {
+			const checkBuffer = () => {
+				if (this.receiveBuffer.length > 0) resolve(this.receiveBuffer.shift());
+				else if (this.state === "closed") resolve(null);
+				else if (this.state === "error") reject(this.error ?? /* @__PURE__ */ new Error("Stream error"));
+				else setTimeout(checkBuffer, 10);
+			};
+			checkBuffer();
+		});
+	}
+	/**
+	* Handle incoming chunk from transport
+	*/
+	handleIncomingChunk(chunk) {
+		if (this.state !== "open" && this.state !== "closing") return;
+		this.receiveWindow.bytesInWindow += chunk.data.length;
+		this.bytesReceived += chunk.data.length;
+		this.checkReceiveWindow();
+		if (this.handlers.onData) Promise.resolve(this.handlers.onData(chunk)).catch((err) => {
+			this.handleError(err);
+		});
+		else this.receiveBuffer.push(chunk);
+		this.reportProgress();
+		if (chunk.endOfStream) this.transitionState("closing");
+	}
+	/**
+	* Update the send window (called when receiving window update from peer)
+	*/
+	updateSendWindow(increment) {
+		this.sendWindow.currentSize = Math.min(this.sendWindow.currentSize + increment, this.sendWindow.maxSize);
+		if (this.sendWindow.backpressureActive) {
+			if (this.sendWindow.currentSize - this.sendWindow.bytesInWindow >= this.flowControlConfig.minWindowSize) {
+				this.sendWindow.backpressureActive = false;
+				this.handlers.onBackpressure?.(false);
+			}
+		}
+	}
+	/**
+	* Acknowledge received bytes (called to update peer's send window)
+	*/
+	acknowledgeBytes(bytes) {
+		this.receiveWindow.bytesInWindow = Math.max(0, this.receiveWindow.bytesInWindow - bytes);
+		if (this.receiveWindow.bytesInWindow < this.flowControlConfig.windowUpdateThreshold) this.sendWindowUpdate();
+	}
+	/**
+	* Close the stream gracefully
+	*/
+	async close() {
+		if (this.state === "closed" || this.state === "closing") return;
+		this.transitionState("closing");
+		await this.drainSendBuffer();
+		await this.sendChunk({
+			data: new Uint8Array(0),
+			endOfStream: true
+		});
+		this.transitionState("closed");
+		this.handlers.onClose?.();
+	}
+	/**
+	* Abort the stream with an error
+	*/
+	abort(error) {
+		this.error = error;
+		this.transitionState("error");
+		this.handlers.onError?.(error);
+	}
+	/**
+	* Set total bytes expected (for progress calculation)
+	*/
+	setTotalBytesExpected(total) {
+		this.totalBytesExpected = total;
+	}
+	/**
+	* Wait for the stream to be ready for sending
+	*/
+	async ready() {
+		if (this.state === "open" && !this.sendWindow.backpressureActive) return;
+		if (this.state !== "open") throw new Error(`Stream not open: ${this.state}`);
+		return this.waitForWindowUpdate();
+	}
+	transitionState(newState) {
+		this.state;
+		this.state = newState;
+		if (newState === "open" && this.openResolver) {
+			this.openResolver();
+			this.openResolver = void 0;
+			this.openRejector = void 0;
+		} else if (newState === "error" && this.openRejector) {
+			this.openRejector(this.error ?? /* @__PURE__ */ new Error("Stream error"));
+			this.openResolver = void 0;
+			this.openRejector = void 0;
+		}
+		if (newState === "closed" && this.closeResolver) {
+			this.closeResolver();
+			this.closeResolver = void 0;
+		}
+	}
+	checkBackpressure() {
+		if (this.sendWindow.currentSize - this.sendWindow.bytesInWindow < this.flowControlConfig.minWindowSize && !this.sendWindow.backpressureActive) {
+			this.sendWindow.backpressureActive = true;
+			this.handlers.onBackpressure?.(true);
+		}
+	}
+	checkReceiveWindow() {
+		if (this.receiveWindow.bytesInWindow < this.flowControlConfig.windowUpdateThreshold) this.sendWindowUpdate();
+	}
+	async waitForWindowUpdate() {
+		return new Promise((resolve, reject) => {
+			const checkWindow = () => {
+				const available = this.sendWindow.currentSize - this.sendWindow.bytesInWindow;
+				if (this.state === "error") {
+					reject(this.error ?? /* @__PURE__ */ new Error("Stream error"));
+					return;
+				}
+				if (this.state !== "open") {
+					reject(/* @__PURE__ */ new Error("Stream closed"));
+					return;
+				}
+				if (available >= this.flowControlConfig.minWindowSize) {
+					resolve();
+					return;
+				}
+				setTimeout(checkWindow, 10);
+			};
+			checkWindow();
+		});
+	}
+	async drainSendBuffer() {
+		this.sendBuffer.length = 0;
+	}
+	sendWindowUpdate() {}
+	reportProgress() {
+		if (!this.options.enableProgress || !this.handlers.onProgress) return;
+		const now = Date.now();
+		const bytesTransferred = Math.max(this.bytesSent, this.bytesReceived);
+		if (bytesTransferred - this.lastProgressUpdate < this.progressUpdateInterval) return;
+		this.lastProgressUpdate = bytesTransferred;
+		let transferRate;
+		if (this.transferStartTime) {
+			const elapsed = (now - this.transferStartTime) / 1e3;
+			if (elapsed > 0) transferRate = bytesTransferred / elapsed;
+		}
+		let percentage;
+		let estimatedTimeRemaining;
+		if (this.totalBytesExpected && this.totalBytesExpected > 0) {
+			percentage = Math.min(100, bytesTransferred / this.totalBytesExpected * 100);
+			if (transferRate && transferRate > 0) estimatedTimeRemaining = (this.totalBytesExpected - bytesTransferred) / transferRate * 1e3;
+		}
+		const progress = {
+			streamId: this.id,
+			bytesTransferred,
+			totalBytes: this.totalBytesExpected,
+			percentage,
+			transferRate,
+			estimatedTimeRemaining
+		};
+		this.handlers.onProgress(progress);
+	}
+	handleError(error) {
+		this.error = error;
+		this.transitionState("error");
+		this.handlers.onError?.(error);
+	}
+};
+/**
+* Create a new stream
+*/
+function createStream(options, handlers) {
+	return new Stream(options, handlers);
+}
+/**
+* Check if an object is a Stream
+*/
+function isStream(obj) {
+	return obj instanceof Stream;
+}
+
+//#endregion
+//#region src/rpc/bulk.ts
+/** Default bulk transfer configuration */
+const DEFAULT_BULK_CONFIG = {
+	chunkSize: 16384,
+	enableProgress: true,
+	progressInterval: 65536,
+	maxConcurrentChunks: 8,
+	chunkAckTimeoutMs: 3e4
+};
+/**
+* Bulk transfer manager
+*
+* Manages high-volume data transfers with flow control and backpressure.
+*/
+var BulkTransfer = class {
+	stream;
+	config;
+	handlers;
+	metadata;
+	direction;
+	state = "pending";
+	error;
+	chunksInFlight = 0;
+	chunksAcknowledged = 0;
+	totalChunks = 0;
+	startTime;
+	endTime;
+	pendingChunks = /* @__PURE__ */ new Map();
+	chunkAckCallbacks = /* @__PURE__ */ new Map();
+	currentWindowSize;
+	dataSource;
+	dataSink;
+	constructor(stream, direction, metadata, config = {}, handlers = {}) {
+		this.stream = stream;
+		this.direction = direction;
+		this.metadata = metadata;
+		this.config = {
+			...DEFAULT_BULK_CONFIG,
+			...config
+		};
+		this.handlers = handlers;
+		this.currentWindowSize = this.config.flowControl?.initialWindowSize ?? DEFAULT_FLOW_CONTROL.initialWindowSize;
+		this.setupStreamHandlers();
+	}
+	/** Get transfer ID */
+	get id() {
+		return this.metadata.id;
+	}
+	/** Get current state */
+	get currentState() {
+		return this.state;
+	}
+	/** Get transfer statistics */
+	get stats() {
+		const now = Date.now();
+		const elapsed = this.startTime ? (this.endTime ?? now) - this.startTime : 0;
+		const bytesTransferred = this.stream.bytesSentCount + this.stream.bytesReceivedCount;
+		let transferRate = 0;
+		if (elapsed > 0) transferRate = bytesTransferred / elapsed * 1e3;
+		let estimatedTimeRemaining;
+		if (this.metadata.totalSize && transferRate > 0) estimatedTimeRemaining = (this.metadata.totalSize - bytesTransferred) / transferRate * 1e3;
+		return {
+			bytesTransferred,
+			totalBytes: this.metadata.totalSize,
+			transferRate,
+			elapsedTime: elapsed,
+			estimatedTimeRemaining,
+			chunksTransferred: this.chunksAcknowledged + this.pendingChunks.size,
+			chunksAcknowledged: this.chunksAcknowledged,
+			currentWindowSize: this.currentWindowSize,
+			backpressureActive: this.stream.isBackpressureActive
+		};
+	}
+	/**
+	* Set the data source for upload
+	*/
+	setDataSource(source) {
+		if (this.direction !== "upload") throw new Error("Data source only valid for uploads");
+		this.dataSource = source;
+	}
+	/**
+	* Set the data sink for download
+	*/
+	setDataSink(sink) {
+		if (this.direction !== "download") throw new Error("Data sink only valid for downloads");
+		this.dataSink = sink;
+	}
+	/**
+	* Start the bulk transfer
+	*/
+	async start() {
+		if (this.state !== "pending") throw new Error(`Cannot start transfer in state: ${this.state}`);
+		this.state = "transferring";
+		this.startTime = Date.now();
+		this.handlers.onStart?.();
+		if (this.metadata.totalSize) this.stream.setTotalBytesExpected(this.metadata.totalSize);
+		try {
+			if (this.direction === "upload") await this.performUpload();
+			else await this.performDownload();
+			if (this.state === "transferring") {
+				this.state = "completed";
+				this.endTime = Date.now();
+				this.handlers.onComplete?.();
+			}
+		} catch (err) {
+			this.handleError(err);
+		}
+	}
+	/**
+	* Pause the transfer
+	*/
+	pause() {
+		if (this.state === "transferring") this.state = "paused";
+	}
+	/**
+	* Resume the transfer
+	*/
+	resume() {
+		if (this.state === "paused") this.state = "transferring";
+	}
+	/**
+	* Cancel the transfer
+	*/
+	cancel() {
+		if (this.state === "completed" || this.state === "error" || this.state === "cancelled") return;
+		this.state = "cancelled";
+		this.endTime = Date.now();
+		for (const { timeout } of this.pendingChunks.values()) clearTimeout(timeout);
+		this.pendingChunks.clear();
+		this.handlers.onCancel?.();
+	}
+	/**
+	* Handle chunk acknowledgment from peer
+	*/
+	handleChunkAck(ack) {
+		const pending = this.pendingChunks.get(ack.sequenceNumber);
+		if (pending) {
+			clearTimeout(pending.timeout);
+			this.pendingChunks.delete(ack.sequenceNumber);
+			this.chunksAcknowledged++;
+			this.chunksInFlight--;
+			this.currentWindowSize += ack.bytesAcknowledged;
+			const callback = this.chunkAckCallbacks.get(ack.sequenceNumber);
+			if (callback) {
+				callback();
+				this.chunkAckCallbacks.delete(ack.sequenceNumber);
+			}
+		}
+	}
+	/**
+	* Update flow control window
+	*/
+	updateWindow(newWindowSize) {
+		this.currentWindowSize = newWindowSize;
+		this.stream.updateSendWindow(newWindowSize);
+	}
+	setupStreamHandlers() {}
+	async performUpload() {
+		if (!this.dataSource) throw new Error("No data source set for upload");
+		if (Symbol.asyncIterator in this.dataSource) for await (const data of this.dataSource) {
+			if (this.state !== "transferring") break;
+			await this.sendChunkWithFlowControl(data);
+		}
+		else {
+			const sourceFn = this.dataSource;
+			while (this.state === "transferring") {
+				const data = await sourceFn();
+				if (!data || data.length === 0) break;
+				await this.sendChunkWithFlowControl(data);
+			}
+		}
+		await this.waitForAllAcks();
+	}
+	async performDownload() {
+		if (!this.dataSink) throw new Error("No data sink set for download");
+		while (this.state === "transferring") await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	async sendChunkWithFlowControl(data) {
+		while (this.chunksInFlight >= (this.config.maxConcurrentChunks ?? 8)) {
+			if (this.state !== "transferring") return;
+			await new Promise((resolve) => setTimeout(resolve, 10));
+		}
+		await this.stream.ready();
+		const sequenceNumber = this.totalChunks++;
+		await this.stream.send(data, false);
+		this.chunksInFlight++;
+		const timeout = setTimeout(() => {
+			this.handleChunkTimeout(sequenceNumber);
+		}, this.config.chunkAckTimeoutMs ?? 3e4);
+		this.pendingChunks.set(sequenceNumber, {
+			chunk: {
+				data,
+				sequenceNumber,
+				timestamp: Date.now()
+			},
+			timeout
+		});
+	}
+	async sendChunkAck(_sequenceNumber, _bytes) {}
+	handleChunkTimeout(sequenceNumber) {
+		if (this.pendingChunks.get(sequenceNumber)) {
+			this.pendingChunks.delete(sequenceNumber);
+			this.chunksInFlight--;
+			this.handleError(/* @__PURE__ */ new Error(`Chunk ${sequenceNumber} acknowledgment timeout`));
+		}
+	}
+	async waitForAllAcks() {
+		for (const [sequenceNumber, { timeout }] of this.pendingChunks) {
+			clearTimeout(timeout);
+			this.handleChunkAck({
+				sequenceNumber,
+				bytesAcknowledged: 0
+			});
+		}
+		this.pendingChunks.clear();
+	}
+	handleError(error) {
+		if (this.state === "completed" || this.state === "error") return;
+		this.error = error;
+		this.state = "error";
+		this.endTime = Date.now();
+		for (const { timeout } of this.pendingChunks.values()) clearTimeout(timeout);
+		this.handlers.onError?.(error);
+	}
+};
+/**
+* Bulk transfer manager
+*
+* Manages multiple concurrent bulk transfers.
+*/
+var BulkTransferManager = class {
+	transfers = /* @__PURE__ */ new Map();
+	streams = /* @__PURE__ */ new Map();
+	nextStreamId = 1;
+	/**
+	* Create a new bulk transfer
+	*/
+	createTransfer(direction, metadata, config, handlers) {
+		const streamId = this.nextStreamId++;
+		const stream = new Stream({
+			streamId,
+			direction: direction === "upload" ? "outbound" : "inbound",
+			priority: StreamPriority.NORMAL,
+			enableProgress: config?.enableProgress ?? true,
+			progressInterval: config?.progressInterval,
+			flowControl: config?.flowControl
+		}, {
+			onProgress: handlers?.onProgress,
+			onBackpressure: handlers?.onBackpressure,
+			onError: handlers?.onError
+		});
+		this.streams.set(streamId, stream);
+		const transfer = new BulkTransfer(stream, direction, metadata, config, handlers);
+		this.transfers.set(metadata.id, transfer);
+		return transfer;
+	}
+	/**
+	* Get a transfer by ID
+	*/
+	getTransfer(id) {
+		return this.transfers.get(id);
+	}
+	/**
+	* Get a stream by ID
+	*/
+	getStream(id) {
+		return this.streams.get(id);
+	}
+	/**
+	* Remove a transfer
+	*/
+	removeTransfer(id) {
+		const transfer = this.transfers.get(id);
+		if (transfer) {
+			transfer.cancel();
+			this.transfers.delete(id);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Get all active transfers
+	*/
+	getActiveTransfers() {
+		return Array.from(this.transfers.values()).filter((t) => t.currentState === "pending" || t.currentState === "transferring" || t.currentState === "paused");
+	}
+	/**
+	* Get transfer statistics summary
+	*/
+	getStatsSummary() {
+		const transfers = Array.from(this.transfers.values());
+		const active = transfers.filter((t) => t.currentState === "transferring");
+		const completed = transfers.filter((t) => t.currentState === "completed");
+		const totalBytes = transfers.reduce((sum, t) => sum + t.stats.bytesTransferred, 0);
+		return {
+			totalTransfers: transfers.length,
+			activeTransfers: active.length,
+			completedTransfers: completed.length,
+			totalBytesTransferred: totalBytes
+		};
+	}
+	/**
+	* Close all transfers
+	*/
+	async closeAll() {
+		for (const transfer of this.transfers.values()) transfer.cancel();
+		this.transfers.clear();
+		this.streams.clear();
+	}
+};
+/**
+* Create a bulk transfer manager
+*/
+function createBulkTransferManager() {
+	return new BulkTransferManager();
+}
+
+//#endregion
+//#region src/rpc/realtime.ts
+/**
+* Realtime API - Real-time communication with prioritization
+*
+* Phase 5: Flow Control and Realtime Communication
+*
+* Features:
+* - Message priority queues
+* - Message drop policies for latency-sensitive scenarios
+* - Bandwidth adaptation
+* - Jitter buffer management
+*/
+/** Message drop policy for latency-sensitive scenarios */
+let DropPolicy = /* @__PURE__ */ function(DropPolicy) {
+	/** Never drop messages */
+	DropPolicy["NEVER"] = "never";
+	/** Drop oldest messages when queue is full */
+	DropPolicy["DROP_OLDEST"] = "drop_oldest";
+	/** Drop newest messages when queue is full */
+	DropPolicy["DROP_NEWEST"] = "drop_newest";
+	/** Drop low priority messages first */
+	DropPolicy["DROP_LOW_PRIORITY"] = "drop_low_priority";
+	/** Drop messages that exceed max latency */
+	DropPolicy["DROP_STALE"] = "drop_stale";
+	return DropPolicy;
+}({});
+/** Default realtime configuration */
+const DEFAULT_REALTIME_CONFIG = {
+	targetLatencyMs: 50,
+	maxLatencyMs: 200,
+	jitterBufferMs: 30,
+	maxQueueSize: 1e3,
+	dropPolicy: DropPolicy.DROP_STALE,
+	adaptiveBitrate: true,
+	minBitrate: 16e3,
+	maxBitrate: 10485760,
+	bandwidthWindowMs: 1e3
+};
+/**
+* Priority queue for realtime messages
+*/
+var PriorityMessageQueue = class {
+	queues = /* @__PURE__ */ new Map();
+	totalSize = 0;
+	maxSize;
+	dropPolicy;
+	maxLatencyMs;
+	constructor(maxSize, dropPolicy, maxLatencyMs) {
+		this.maxSize = maxSize;
+		this.dropPolicy = dropPolicy;
+		this.maxLatencyMs = maxLatencyMs;
+		for (let i = 0; i <= 4; i++) this.queues.set(i, []);
+	}
+	/** Get total queue size */
+	get size() {
+		return this.totalSize;
+	}
+	/** Check if queue is empty */
+	get isEmpty() {
+		return this.totalSize === 0;
+	}
+	/** Enqueue a message */
+	enqueue(message) {
+		if (this.dropPolicy === DropPolicy.DROP_STALE) {
+			if (Date.now() - message.timestamp > this.maxLatencyMs && !message.critical) return false;
+		}
+		if (this.totalSize >= this.maxSize) {
+			if (!this.handleQueueFull(message)) return false;
+		}
+		this.queues.get(message.priority).push(message);
+		this.totalSize++;
+		return true;
+	}
+	/** Dequeue the highest priority message */
+	dequeue() {
+		for (let priority = 0; priority <= 4; priority++) {
+			const queue = this.queues.get(priority);
+			if (queue.length > 0) {
+				this.totalSize--;
+				return queue.shift();
+			}
+		}
+	}
+	/** Peek at the highest priority message without removing */
+	peek() {
+		for (let priority = 0; priority <= 4; priority++) {
+			const queue = this.queues.get(priority);
+			if (queue.length > 0) return queue[0];
+		}
+	}
+	/** Remove stale messages */
+	removeStale() {
+		const now = Date.now();
+		const removed = [];
+		for (const [priority, queue] of this.queues) {
+			const remaining = [];
+			for (const msg of queue) if (now - msg.timestamp <= this.maxLatencyMs || msg.critical) remaining.push(msg);
+			else {
+				removed.push(msg);
+				this.totalSize--;
+			}
+			this.queues.set(priority, remaining);
+		}
+		return removed;
+	}
+	/** Clear all messages */
+	clear() {
+		const all = [];
+		for (const queue of this.queues.values()) all.push(...queue);
+		for (const queue of this.queues.values()) queue.length = 0;
+		this.totalSize = 0;
+		return all;
+	}
+	handleQueueFull(newMessage) {
+		switch (this.dropPolicy) {
+			case DropPolicy.NEVER: return false;
+			case DropPolicy.DROP_OLDEST:
+				for (let priority = 4; priority >= 0; priority--) {
+					const queue = this.queues.get(priority);
+					if (queue.length > 0 && priority >= newMessage.priority) {
+						queue.shift();
+						this.totalSize--;
+						return true;
+					}
+				}
+				return false;
+			case DropPolicy.DROP_NEWEST:
+				if (newMessage.priority >= StreamPriority.NORMAL) return false;
+				return true;
+			case DropPolicy.DROP_LOW_PRIORITY:
+				for (let priority = 4; priority > newMessage.priority; priority--) {
+					const queue = this.queues.get(priority);
+					if (queue.length > 0) {
+						queue.shift();
+						this.totalSize--;
+						return true;
+					}
+				}
+				return false;
+			case DropPolicy.DROP_STALE:
+				if (this.removeStale().length > 0) return true;
+				for (let priority = 4; priority >= 0; priority--) {
+					const queue = this.queues.get(priority);
+					if (queue.length > 0 && priority >= newMessage.priority) {
+						queue.shift();
+						this.totalSize--;
+						return true;
+					}
+				}
+				return false;
+			default: return false;
+		}
+	}
+};
+/**
+* Realtime stream for low-latency communication
+*
+* Manages message prioritization, jitter buffering, and bandwidth adaptation.
+*/
+var RealtimeStream = class {
+	stream;
+	config;
+	handlers;
+	sendQueue;
+	receiveQueue;
+	jitterBuffer = [];
+	jitterBufferTargetSize;
+	bandwidthStats = {
+		currentBitrate: 0,
+		measuredBandwidth: 0,
+		packetLossRate: 0,
+		averageLatencyMs: 0,
+		jitterMs: 0,
+		congestionLevel: 0
+	};
+	bitrateHistory = [];
+	latencyHistory = [];
+	lastBandwidthUpdate = 0;
+	nextSendSequence = 0;
+	nextExpectedSequence = 0;
+	receivedSequences = /* @__PURE__ */ new Set();
+	isRunning = false;
+	sendInterval;
+	jitterInterval;
+	bandwidthInterval;
+	constructor(stream, config = {}, handlers = {}) {
+		this.stream = stream;
+		this.config = {
+			...DEFAULT_REALTIME_CONFIG,
+			...config
+		};
+		this.handlers = handlers;
+		this.sendQueue = new PriorityMessageQueue(this.config.maxQueueSize, this.config.dropPolicy, this.config.maxLatencyMs);
+		this.receiveQueue = new PriorityMessageQueue(this.config.maxQueueSize, this.config.dropPolicy, this.config.maxLatencyMs);
+		this.jitterBufferTargetSize = Math.ceil(this.config.jitterBufferMs / this.config.targetLatencyMs);
+		this.setupStreamHandlers();
+	}
+	/** Get current bandwidth statistics */
+	get stats() {
+		return { ...this.bandwidthStats };
+	}
+	/** Get current send queue size */
+	get sendQueueSize() {
+		return this.sendQueue.size;
+	}
+	/** Get current receive queue size */
+	get receiveQueueSize() {
+		return this.receiveQueue.size;
+	}
+	/** Get jitter buffer size */
+	get jitterBufferSize() {
+		return this.jitterBuffer.length;
+	}
+	/**
+	* Start the realtime stream
+	*/
+	start() {
+		if (this.isRunning) return;
+		this.isRunning = true;
+		this.sendInterval = setInterval(() => {
+			this.processSendQueue();
+		}, this.config.targetLatencyMs / 2);
+		this.jitterInterval = setInterval(() => {
+			this.processJitterBuffer();
+		}, this.config.targetLatencyMs / 4);
+		if (this.config.adaptiveBitrate) this.bandwidthInterval = setInterval(() => {
+			this.updateBandwidthStats();
+		}, this.config.bandwidthWindowMs);
+		this.handlers.onReady?.();
+	}
+	/**
+	* Stop the realtime stream
+	*/
+	stop() {
+		this.isRunning = false;
+		if (this.sendInterval) {
+			clearInterval(this.sendInterval);
+			this.sendInterval = void 0;
+		}
+		if (this.jitterInterval) {
+			clearInterval(this.jitterInterval);
+			this.jitterInterval = void 0;
+		}
+		if (this.bandwidthInterval) {
+			clearInterval(this.bandwidthInterval);
+			this.bandwidthInterval = void 0;
+		}
+		const dropped = this.sendQueue.clear();
+		if (dropped.length > 0) this.handlers.onDrop?.(dropped, "stream stopped");
+	}
+	/**
+	* Send a realtime message
+	*/
+	sendMessage(data, priority = StreamPriority.NORMAL, options = {}) {
+		if (!this.isRunning) return false;
+		const message = {
+			id: this.generateMessageId(),
+			priority,
+			timestamp: Date.now(),
+			data,
+			type: options.type,
+			sequenceNumber: this.nextSendSequence++,
+			critical: options.critical
+		};
+		if (!this.sendQueue.enqueue(message)) {
+			this.handlers.onDrop?.([message], "queue full");
+			return false;
+		}
+		return true;
+	}
+	/**
+	* Receive the next message (blocking)
+	*/
+	async receiveMessage() {
+		return new Promise((resolve) => {
+			const checkQueue = () => {
+				const message = this.receiveQueue.dequeue();
+				if (message) resolve(message);
+				else if (!this.isRunning) resolve(void 0);
+				else setTimeout(checkQueue, 5);
+			};
+			checkQueue();
+		});
+	}
+	/**
+	* Set target bitrate (for manual bitrate control)
+	*/
+	setTargetBitrate(bitrate) {
+		this.bandwidthStats.currentBitrate = Math.max(this.config.minBitrate, Math.min(this.config.maxBitrate, bitrate));
+	}
+	setupStreamHandlers() {
+		const originalOnData = this.stream.handlers?.onData;
+		this.stream.handlers = {
+			...this.stream.handlers,
+			onData: (chunk) => {
+				this.handleIncomingData(chunk);
+				originalOnData?.(chunk);
+			}
+		};
+	}
+	handleIncomingData(chunk) {
+		try {
+			const message = this.deserializeMessage(chunk.data);
+			if (message.sequenceNumber > this.nextExpectedSequence) {
+				const lost = message.sequenceNumber - this.nextExpectedSequence;
+				this.bandwidthStats.packetLossRate = this.bandwidthStats.packetLossRate * .9 + lost * .1;
+			}
+			this.nextExpectedSequence = message.sequenceNumber + 1;
+			const latency = Date.now() - message.timestamp;
+			this.latencyHistory.push(latency);
+			if (this.latencyHistory.length > 100) this.latencyHistory.shift();
+			const playoutTime = Date.now() + this.config.jitterBufferMs;
+			this.jitterBuffer.push({
+				message,
+				receivedAt: Date.now(),
+				playoutTime
+			});
+			this.jitterBuffer.sort((a, b) => a.message.sequenceNumber - b.message.sequenceNumber);
+		} catch (error) {
+			this.handlers.onError?.(error);
+		}
+	}
+	processSendQueue() {
+		if (!this.isRunning || this.sendQueue.isEmpty) return;
+		if (this.config.adaptiveBitrate) {
+			const maxBytesPerInterval = this.bandwidthStats.currentBitrate * this.config.targetLatencyMs / 1e3 / 2;
+			let bytesSent = 0;
+			while (bytesSent < maxBytesPerInterval) {
+				const message = this.sendQueue.dequeue();
+				if (!message) break;
+				this.sendMessageToStream(message);
+				bytesSent += message.data.length;
+			}
+		} else {
+			const message = this.sendQueue.dequeue();
+			if (message) this.sendMessageToStream(message);
+		}
+		if (this.config.dropPolicy === DropPolicy.DROP_STALE) {
+			const stale = this.sendQueue.removeStale();
+			if (stale.length > 0) this.handlers.onDrop?.(stale, "stale");
+		}
+	}
+	sendMessageToStream(message) {
+		try {
+			const data = this.serializeMessage(message);
+			this.stream.send(data).catch((err) => {
+				this.handlers.onError?.(err);
+			});
+			this.bitrateHistory.push(data.length);
+			if (this.bitrateHistory.length > 100) this.bitrateHistory.shift();
+		} catch (error) {
+			this.handlers.onError?.(error);
+		}
+	}
+	processJitterBuffer() {
+		if (!this.isRunning || this.jitterBuffer.length === 0) return;
+		const now = Date.now();
+		while (this.jitterBuffer.length > 0) {
+			const entry = this.jitterBuffer[0];
+			if (this.jitterBuffer.length < this.jitterBufferTargetSize && entry.playoutTime > now) break;
+			if (entry.playoutTime <= now) {
+				this.jitterBuffer.shift();
+				this.receiveQueue.enqueue(entry.message);
+				this.handlers.onMessage?.(entry.message);
+			} else break;
+		}
+		const maxAge = this.config.maxLatencyMs * 2;
+		const stale = [];
+		this.jitterBuffer = this.jitterBuffer.filter((entry) => {
+			if (now - entry.receivedAt > maxAge && !entry.message.critical) {
+				stale.push(entry.message);
+				return false;
+			}
+			return true;
+		});
+		if (stale.length > 0) this.handlers.onDrop?.(stale, "jitter buffer stale");
+	}
+	updateBandwidthStats() {
+		const now = Date.now();
+		const windowMs = this.config.bandwidthWindowMs;
+		if (this.bitrateHistory.length >= 2) {
+			const totalBytes = this.bitrateHistory.reduce((a, b) => a + b, 0);
+			this.bandwidthStats.measuredBandwidth = totalBytes / windowMs * 1e3;
+		}
+		if (this.latencyHistory.length > 0) {
+			const avgLatency = this.latencyHistory.reduce((a, b) => a + b, 0) / this.latencyHistory.length;
+			this.bandwidthStats.averageLatencyMs = avgLatency;
+			const variance = this.latencyHistory.reduce((sum, lat) => sum + (lat - avgLatency) ** 2, 0) / this.latencyHistory.length;
+			this.bandwidthStats.jitterMs = Math.sqrt(variance);
+			this.handlers.onLatencyChange?.(avgLatency);
+		}
+		const queueUtilization = this.sendQueue.size / this.config.maxQueueSize;
+		const latencyRatio = this.bandwidthStats.averageLatencyMs / this.config.targetLatencyMs;
+		this.bandwidthStats.congestionLevel = Math.min(1, (queueUtilization + latencyRatio) / 2);
+		if (this.config.adaptiveBitrate) this.adaptBitrate();
+		this.lastBandwidthUpdate = now;
+	}
+	adaptBitrate() {
+		const { congestionLevel, packetLossRate } = this.bandwidthStats;
+		let newBitrate = this.bandwidthStats.currentBitrate;
+		if (congestionLevel > .7 || packetLossRate > .05) newBitrate = newBitrate * .8;
+		else if (congestionLevel < .3 && packetLossRate < .01) newBitrate = newBitrate * 1.05;
+		newBitrate = Math.max(this.config.minBitrate, Math.min(this.config.maxBitrate, newBitrate));
+		if (newBitrate !== this.bandwidthStats.currentBitrate) {
+			this.bandwidthStats.currentBitrate = newBitrate;
+			this.handlers.onBandwidthAdapt?.(newBitrate, this.bandwidthStats);
+		}
+	}
+	serializeMessage(message) {
+		const header = JSON.stringify({
+			id: message.id,
+			priority: message.priority,
+			timestamp: message.timestamp,
+			type: message.type,
+			sequenceNumber: message.sequenceNumber,
+			critical: message.critical,
+			dataLength: message.data.length
+		});
+		const headerBytes = new TextEncoder().encode(header);
+		const headerLength = new Uint8Array(4);
+		new DataView(headerLength.buffer).setUint32(0, headerBytes.length, true);
+		const result = new Uint8Array(4 + headerBytes.length + message.data.length);
+		result.set(headerLength, 0);
+		result.set(headerBytes, 4);
+		result.set(message.data, 4 + headerBytes.length);
+		return result;
+	}
+	deserializeMessage(data) {
+		const headerLength = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, true);
+		const headerBytes = data.slice(4, 4 + headerLength);
+		const header = JSON.parse(new TextDecoder().decode(headerBytes));
+		return {
+			id: header.id,
+			priority: header.priority,
+			timestamp: header.timestamp,
+			type: header.type,
+			sequenceNumber: header.sequenceNumber,
+			critical: header.critical,
+			data: data.slice(4 + headerLength, 4 + headerLength + header.dataLength)
+		};
+	}
+	generateMessageId() {
+		return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+	}
+};
+/**
+* Realtime stream manager
+*/
+var RealtimeStreamManager = class {
+	streams = /* @__PURE__ */ new Map();
+	nextStreamId = 1;
+	/**
+	* Create a new realtime stream
+	*/
+	createStream(baseStream, config, handlers) {
+		const streamId = this.nextStreamId++;
+		const stream = new RealtimeStream(baseStream, config, handlers);
+		this.streams.set(streamId, stream);
+		return stream;
+	}
+	/**
+	* Get a stream by ID
+	*/
+	getStream(id) {
+		return this.streams.get(id);
+	}
+	/**
+	* Remove a stream
+	*/
+	removeStream(id) {
+		const stream = this.streams.get(id);
+		if (stream) {
+			stream.stop();
+			this.streams.delete(id);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Get all active streams
+	*/
+	getActiveStreams() {
+		return Array.from(this.streams.values());
+	}
+	/**
+	* Stop all streams
+	*/
+	stopAll() {
+		for (const stream of this.streams.values()) stream.stop();
+		this.streams.clear();
+	}
+};
+/**
+* Create a realtime stream manager
+*/
+function createRealtimeStreamManager() {
+	return new RealtimeStreamManager();
+}
+
+//#endregion
+//#region src/rpc/stream-manager.ts
+/**
+* Stream Management - Unified stream lifecycle management
+*
+* Phase 5: Flow Control and Realtime Communication
+*
+* Manages:
+* - Stream creation and registration
+* - Bidirectional stream support
+* - Stream lifecycle (open, close, error handling)
+* - Stream multiplexing over a single connection
+*/
+/** Stream type */
+let StreamType = /* @__PURE__ */ function(StreamType) {
+	/** Standard stream */
+	StreamType["STANDARD"] = "standard";
+	/** Bulk transfer stream */
+	StreamType["BULK"] = "bulk";
+	/** Realtime stream */
+	StreamType["REALTIME"] = "realtime";
+	return StreamType;
+}({});
+/** Default stream manager configuration */
+const DEFAULT_STREAM_MANAGER_CONFIG = {
+	maxStreams: 100,
+	defaultPriority: StreamPriority.NORMAL,
+	enableMultiplexing: true,
+	idleTimeoutMs: 3e5
+};
+/**
+* Stream manager
+*
+* Manages all streams for an RPC connection.
+*/
+var StreamManager = class {
+	config;
+	handlers;
+	connection;
+	transport;
+	streams = /* @__PURE__ */ new Map();
+	streamTypes = /* @__PURE__ */ new Map();
+	streamInfos = /* @__PURE__ */ new Map();
+	nextStreamId = 1;
+	bulkManager;
+	realtimeManager;
+	idleTimeout;
+	isRunning = false;
+	constructor(config = {}, handlers = {}) {
+		this.config = {
+			...DEFAULT_STREAM_MANAGER_CONFIG,
+			...config
+		};
+		this.handlers = handlers;
+		this.bulkManager = new BulkTransferManager();
+		this.realtimeManager = new RealtimeStreamManager();
+	}
+	/** Get the number of active streams */
+	get streamCount() {
+		return this.streams.size;
+	}
+	/** Get the maximum number of streams */
+	get maxStreams() {
+		return this.config.maxStreams;
+	}
+	/** Get all stream infos */
+	get allStreamInfos() {
+		return Array.from(this.streamInfos.values());
+	}
+	/**
+	* Attach to an RPC connection
+	*/
+	attach(connection, transport) {
+		this.connection = connection;
+		this.transport = transport;
+		this.isRunning = true;
+		this.resetIdleTimeout();
+	}
+	/**
+	* Detach from connection
+	*/
+	detach() {
+		this.closeAllStreams();
+		this.isRunning = false;
+		this.connection = void 0;
+		this.transport = void 0;
+		if (this.idleTimeout) {
+			clearTimeout(this.idleTimeout);
+			this.idleTimeout = void 0;
+		}
+	}
+	/**
+	* Create a new stream
+	*/
+	createStream(options = {}) {
+		if (this.streams.size >= this.config.maxStreams) throw new Error(`Maximum number of streams (${this.config.maxStreams}) reached`);
+		const streamId = this.nextStreamId++;
+		const type = options.type ?? StreamType.STANDARD;
+		const streamOptions = {
+			streamId,
+			direction: options.direction ?? "bidirectional",
+			priority: options.priority ?? this.config.defaultPriority ?? StreamPriority.NORMAL,
+			metadata: options.metadata,
+			flowControl: options.flowControl
+		};
+		const stream = new Stream(streamOptions, {
+			onOpen: () => {
+				this.updateStreamState(streamId, "open");
+				this.handlers.onStreamOpen?.(this.getStreamInfo(streamId));
+			},
+			onClose: () => {
+				this.updateStreamState(streamId, "closed");
+				this.handlers.onStreamClose?.(this.getStreamInfo(streamId));
+				this.removeStream(streamId);
+			},
+			onError: (error) => {
+				this.updateStreamState(streamId, "error");
+				const info = this.getStreamInfo(streamId);
+				if (info) this.handlers.onStreamError?.(info, error);
+			}
+		});
+		this.streams.set(streamId, stream);
+		this.streamTypes.set(streamId, type);
+		const info = {
+			id: streamId,
+			type,
+			direction: streamOptions.direction,
+			priority: streamOptions.priority ?? StreamPriority.NORMAL,
+			state: "connecting",
+			createdAt: Date.now(),
+			bytesTransferred: 0,
+			metadata: options.metadata
+		};
+		this.streamInfos.set(streamId, info);
+		this.handlers.onStreamCreate?.(info);
+		this.handlers.onStreamCountChange?.(this.streams.size);
+		this.resetIdleTimeout();
+		return stream;
+	}
+	/**
+	* Create a bulk transfer stream
+	*/
+	createBulkStream(direction, metadata, config, handlers) {
+		this.createStream({
+			type: StreamType.BULK,
+			direction: direction === "upload" ? "outbound" : "inbound",
+			priority: StreamPriority.NORMAL,
+			metadata: metadata.custom
+		});
+		return this.bulkManager.createTransfer(direction, metadata, config, handlers);
+	}
+	/**
+	* Create a realtime stream
+	*/
+	createRealtimeStream(config, handlers) {
+		const stream = this.createStream({
+			type: StreamType.REALTIME,
+			direction: "bidirectional",
+			priority: StreamPriority.HIGH
+		});
+		return this.realtimeManager.createStream(stream, config, handlers);
+	}
+	/**
+	* Get a stream by ID
+	*/
+	getStream(id) {
+		return this.streams.get(id);
+	}
+	/**
+	* Get stream info by ID
+	*/
+	getStreamInfo(id) {
+		return this.streamInfos.get(id);
+	}
+	/**
+	* Get stream type by ID
+	*/
+	getStreamType(id) {
+		return this.streamTypes.get(id);
+	}
+	/**
+	* Get bulk transfer by ID
+	*/
+	getBulkTransfer(id) {
+		return this.bulkManager.getTransfer(id);
+	}
+	/**
+	* Get realtime stream by ID
+	*/
+	getRealtimeStream(id) {
+		return this.realtimeManager.getStream(id);
+	}
+	/**
+	* Close a specific stream
+	*/
+	async closeStream(id) {
+		const stream = this.streams.get(id);
+		if (!stream) return false;
+		await stream.close();
+		this.removeStream(id);
+		return true;
+	}
+	/**
+	* Close all streams
+	*/
+	async closeAllStreams() {
+		const closePromises = [];
+		for (const [_id, stream] of this.streams) closePromises.push(stream.close().catch(() => {}));
+		await Promise.all(closePromises);
+		this.streams.clear();
+		this.streamTypes.clear();
+		this.streamInfos.clear();
+		this.bulkManager.closeAll();
+		this.realtimeManager.stopAll();
+		this.handlers.onStreamCountChange?.(0);
+	}
+	/**
+	* Get streams by type
+	*/
+	getStreamsByType(type) {
+		return this.allStreamInfos.filter((info) => info.type === type);
+	}
+	/**
+	* Get streams by state
+	*/
+	getStreamsByState(state) {
+		return this.allStreamInfos.filter((info) => info.state === state);
+	}
+	/**
+	* Get statistics
+	*/
+	getStatistics() {
+		const infos = this.allStreamInfos;
+		const active = infos.filter((i) => i.state === "open");
+		const byType = {
+			[StreamType.STANDARD]: 0,
+			[StreamType.BULK]: 0,
+			[StreamType.REALTIME]: 0
+		};
+		const byState = {
+			connecting: 0,
+			open: 0,
+			closing: 0,
+			closed: 0,
+			error: 0
+		};
+		let totalBytes = 0;
+		for (const info of infos) {
+			byType[info.type]++;
+			byState[info.state]++;
+			totalBytes += info.bytesTransferred;
+		}
+		return {
+			totalStreams: infos.length,
+			activeStreams: active.length,
+			streamsByType: byType,
+			streamsByState: byState,
+			totalBytesTransferred: totalBytes
+		};
+	}
+	/**
+	* Update stream priority
+	*/
+	updatePriority(id, priority) {
+		const info = this.streamInfos.get(id);
+		if (!info) return false;
+		info.priority = priority;
+		return true;
+	}
+	/**
+	* Pause all streams (backpressure)
+	*/
+	pauseAll() {
+		for (const _stream of this.streams.values());
+	}
+	/**
+	* Resume all streams
+	*/
+	resumeAll() {
+		for (const _stream of this.streams.values());
+	}
+	removeStream(id) {
+		this.streams.delete(id);
+		this.streamTypes.delete(id);
+		this.streamInfos.delete(id);
+		this.handlers.onStreamCountChange?.(this.streams.size);
+		this.resetIdleTimeout();
+	}
+	updateStreamState(id, state) {
+		const info = this.streamInfos.get(id);
+		if (info) info.state = state;
+	}
+	resetIdleTimeout() {
+		if (this.idleTimeout) clearTimeout(this.idleTimeout);
+		if (!this.isRunning || this.streams.size > 0) return;
+		this.idleTimeout = setTimeout(() => {
+			if (this.streams.size === 0) {}
+		}, this.config.idleTimeoutMs);
+	}
+};
+/**
+* Create a stream manager
+*/
+function createStreamManager(config, handlers) {
+	return new StreamManager(config, handlers);
+}
+
+//#endregion
+//#region src/rpc/streaming-connection.ts
+/** Default streaming capabilities */
+const DEFAULT_STREAMING_CAPABILITIES = {
+	standardStreams: true,
+	bulkTransfer: true,
+	realtimeStreams: true,
+	maxConcurrentStreams: 100,
+	maxWindowSize: 1048576,
+	flowControlAlgorithms: ["sliding-window", "rate-based"]
+};
+/**
+* Extended RPC connection with streaming support
+*
+* This class wraps RpcConnection and adds stream management capabilities.
+* It can be used as a drop-in replacement for RpcConnection.
+*/
+var StreamingRpcConnection = class extends require_rpc_connection.RpcConnection {
+	streamManager;
+	localCapabilities;
+	remoteCapabilities;
+	streamingEnabled;
+	constructor(transport, options = {}) {
+		super(transport, options);
+		this.streamingEnabled = options.enableStreaming ?? true;
+		this.localCapabilities = {
+			...DEFAULT_STREAMING_CAPABILITIES,
+			...options.localCapabilities
+		};
+		this.streamManager = new StreamManager(options.streamManagerConfig, options.streamManagerHandlers);
+		this.streamManager.attach(this, transport);
+		if (this.streamingEnabled) this.negotiateCapabilities();
+	}
+	/** Get the stream manager */
+	get streams() {
+		return this.streamManager;
+	}
+	/** Get local streaming capabilities */
+	get capabilities() {
+		return this.localCapabilities;
+	}
+	/** Get remote streaming capabilities (if negotiated) */
+	get remoteStreamingCapabilities() {
+		return this.remoteCapabilities;
+	}
+	/** Check if streaming is enabled */
+	get isStreamingEnabled() {
+		return this.streamingEnabled;
+	}
+	/**
+	* Create a new standard stream
+	*/
+	createStream(options) {
+		this.ensureStreamingEnabled();
+		return this.streamManager.createStream(options);
+	}
+	/**
+	* Create a bulk transfer stream
+	*/
+	createBulkTransfer(direction, metadata, config, handlers) {
+		this.ensureStreamingEnabled();
+		this.ensureCapability("bulkTransfer");
+		return this.streamManager.createBulkStream(direction, metadata, config, handlers);
+	}
+	/**
+	* Create a realtime stream
+	*/
+	createRealtimeStream(config, handlers) {
+		this.ensureStreamingEnabled();
+		this.ensureCapability("realtimeStreams");
+		return this.streamManager.createRealtimeStream(config, handlers);
+	}
+	/**
+	* Get stream statistics
+	*/
+	getStreamStatistics() {
+		return this.streamManager.getStatistics();
+	}
+	/**
+	* Close all streams gracefully
+	*/
+	async closeAllStreams() {
+		await this.streamManager.closeAllStreams();
+	}
+	/**
+	* Override stop to properly clean up streams
+	*/
+	async stop() {
+		await this.closeAllStreams();
+		this.streamManager.detach();
+		await super.stop();
+	}
+	/**
+	* Negotiate streaming capabilities with remote peer
+	*
+	* This would typically be done during bootstrap or connection setup.
+	* For now, we assume the remote has the same capabilities.
+	*/
+	async negotiateCapabilities() {
+		this.remoteCapabilities = { ...this.localCapabilities };
+	}
+	/**
+	* Update remote capabilities (called when received from peer)
+	*/
+	setRemoteCapabilities(capabilities) {
+		this.remoteCapabilities = capabilities;
+	}
+	/**
+	* Check if a specific capability is supported by both peers
+	*/
+	isCapabilitySupported(capability) {
+		const localValue = this.localCapabilities[capability];
+		const remoteValue = this.remoteCapabilities?.[capability];
+		if (typeof localValue === "boolean" && typeof remoteValue === "boolean") return localValue && remoteValue;
+		if (typeof localValue === "number" && typeof remoteValue === "number") return localValue > 0 && remoteValue > 0;
+		return false;
+	}
+	/**
+	* Create a stream for pipeline results
+	*
+	* This allows large pipeline results to be streamed instead of buffered.
+	*/
+	createPipelineStream(questionId, options) {
+		this.ensureStreamingEnabled();
+		return this.createStream({
+			...options,
+			type: StreamType.STANDARD,
+			metadata: {
+				...options?.metadata,
+				pipelineQuestionId: questionId.toString()
+			}
+		});
+	}
+	/**
+	* Associate a stream with a capability
+	*
+	* This enables streaming data to/from a capability.
+	*/
+	associateStreamWithCapability(streamId, _importId) {
+		if (!this.streamManager.getStream(streamId)) throw new Error(`Stream ${streamId} not found`);
+	}
+	ensureStreamingEnabled() {
+		if (!this.streamingEnabled) throw new Error("Streaming is not enabled on this connection");
+	}
+	ensureCapability(capability) {
+		if (!this.isCapabilitySupported(capability)) throw new Error(`Capability '${capability}' is not supported by both peers`);
+	}
+};
+/**
+* Create a streaming RPC connection
+*/
+function createStreamingConnection(transport, options) {
+	return new StreamingRpcConnection(transport, options);
+}
+/**
+* Check if a connection supports streaming
+*/
+function supportsStreaming(connection) {
+	return connection instanceof StreamingRpcConnection;
+}
+
+//#endregion
+exports.AnswerTable = require_rpc_connection.AnswerTable;
+exports.BaseCapabilityClient = BaseCapabilityClient;
+exports.BulkTransfer = BulkTransfer;
+exports.BulkTransferManager = BulkTransferManager;
+exports.ConnectionManager = ConnectionManager;
+exports.DEFAULT_BULK_CONFIG = DEFAULT_BULK_CONFIG;
+exports.DEFAULT_ESCROW_CONFIG = DEFAULT_ESCROW_CONFIG;
+exports.DEFAULT_FLOW_CONTROL = DEFAULT_FLOW_CONTROL;
+exports.DEFAULT_JOIN_OPTIONS = DEFAULT_JOIN_OPTIONS;
+exports.DEFAULT_JOIN_SECURITY_POLICY = DEFAULT_JOIN_SECURITY_POLICY;
+exports.DEFAULT_REALTIME_CONFIG = DEFAULT_REALTIME_CONFIG;
+exports.DEFAULT_STREAMING_CAPABILITIES = DEFAULT_STREAMING_CAPABILITIES;
+exports.DropPolicy = DropPolicy;
 exports.ElementSize = ElementSize;
+exports.ExportTable = require_rpc_connection.ExportTable;
+exports.ImportTable = require_rpc_connection.ImportTable;
+exports.Level3Handlers = Level3Handlers;
+exports.Level4Handlers = Level4Handlers;
 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 = require_rpc_connection.PIPELINE_CLIENT_SYMBOL;
+exports.PipelineOpTracker = require_rpc_connection.PipelineOpTracker;
+exports.PipelineResolutionTracker = require_rpc_connection.PipelineResolutionTracker;
 exports.PointerTag = PointerTag;
+exports.QuestionTable = require_rpc_connection.QuestionTable;
+exports.QueuedCallManager = require_rpc_connection.QueuedCallManager;
+exports.RealtimeStream = RealtimeStream;
+exports.RealtimeStreamManager = RealtimeStreamManager;
+exports.RestoreHandler = RestoreHandler;
+exports.RpcConnection = require_rpc_connection.RpcConnection;
 exports.Segment = Segment;
+exports.Stream = Stream;
+exports.StreamManager = StreamManager;
+exports.StreamPriority = StreamPriority;
+exports.StreamType = StreamType;
+exports.StreamingRpcConnection = StreamingRpcConnection;
 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.createBulkTransferManager = createBulkTransferManager;
+exports.createPipelineClient = require_rpc_connection.createPipelineClient;
+exports.createProvisionId = createProvisionId;
+exports.createRealtimeStreamManager = createRealtimeStreamManager;
+exports.createRecipientId = createRecipientId;
+exports.createStream = createStream;
+exports.createStreamManager = createStreamManager;
+exports.createStreamingConnection = createStreamingConnection;
+exports.createSturdyRef = createSturdyRef;
+exports.createThirdPartyCapId = createThirdPartyCapId;
 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.generateProvisionId = generateProvisionId;
+exports.generateVatId = generateVatId;
+exports.getGlobalMemoryPool = getGlobalMemoryPool;
+exports.isPipelineClient = require_rpc_connection.isPipelineClient;
+exports.isSameBuffer = isSameBuffer;
+exports.isStream = isStream;
+exports.isSturdyRefValid = isSturdyRefValid;
+exports.serializeRpcMessage = serializeRpcMessage;
+exports.serializeSturdyRef = serializeSturdyRef;
+exports.supportsStreaming = supportsStreaming;
 //# sourceMappingURL=index.cjs.map