@naeemo/capnp 0.3.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
 /**
@@ -1693,771 +1694,6 @@ var WebSocketTransport = class WebSocketTransport {
 	}
 };
 
-//#endregion
-//#region src/rpc/four-tables.ts
-/** Manages the question table for outbound calls */
-var QuestionTable = class {
-	questions = /* @__PURE__ */ new Map();
-	nextId = 1;
-	/** Create a new question entry */
-	create() {
-		const id = this.allocateId();
-		let resolveCompletion;
-		let rejectCompletion;
-		const question = {
-			id,
-			isComplete: false,
-			finishSent: false,
-			completionPromise: new Promise((resolve, reject) => {
-				resolveCompletion = resolve;
-				rejectCompletion = reject;
-			}),
-			resolveCompletion,
-			rejectCompletion
-		};
-		this.questions.set(id, question);
-		return question;
-	}
-	/** Get a question by ID */
-	get(id) {
-		return this.questions.get(id);
-	}
-	/** Mark a question as complete */
-	complete(id, result) {
-		const question = this.questions.get(id);
-		if (question && !question.isComplete) {
-			question.isComplete = true;
-			question.resolveCompletion(result);
-		}
-	}
-	/** Mark a question as canceled */
-	cancel(id, error) {
-		const question = this.questions.get(id);
-		if (question && !question.isComplete) {
-			question.isComplete = true;
-			question.rejectCompletion(error);
-		}
-	}
-	/** Mark that Finish has been sent for a question */
-	markFinishSent(id) {
-		const question = this.questions.get(id);
-		if (question) question.finishSent = true;
-	}
-	/** Remove a question from the table (when both sides are done) */
-	remove(id) {
-		const question = this.questions.get(id);
-		if (question?.isComplete && question.finishSent) this.questions.delete(id);
-	}
-	/** Clean up all questions (e.g., on disconnect) */
-	clear() {
-		for (const question of this.questions.values()) if (!question.isComplete) question.rejectCompletion(/* @__PURE__ */ new Error("Connection closed"));
-		this.questions.clear();
-		this.nextId = 1;
-	}
-	allocateId() {
-		return this.nextId++;
-	}
-};
-/** Manages the answer table for inbound calls */
-var AnswerTable = class {
-	answers = /* @__PURE__ */ new Map();
-	/** Create a new answer entry */
-	create(id) {
-		const answer = {
-			id,
-			isComplete: false,
-			returnSent: false,
-			finishReceived: false
-		};
-		this.answers.set(id, answer);
-		return answer;
-	}
-	/** Get an answer by ID */
-	get(id) {
-		return this.answers.get(id);
-	}
-	/** Mark that Return has been sent */
-	markReturnSent(id) {
-		const answer = this.answers.get(id);
-		if (answer) answer.returnSent = true;
-	}
-	/** Mark that Finish has been received */
-	markFinishReceived(id) {
-		const answer = this.answers.get(id);
-		if (answer) answer.finishReceived = true;
-	}
-	/** Remove an answer from the table (when both sides are done) */
-	remove(id) {
-		const answer = this.answers.get(id);
-		if (answer?.returnSent && answer.finishReceived) this.answers.delete(id);
-	}
-	/** Clean up all answers (e.g., on disconnect) */
-	clear() {
-		this.answers.clear();
-	}
-};
-/** Manages the import table for capabilities received from remote */
-var ImportTable = class {
-	imports = /* @__PURE__ */ new Map();
-	/** Add a new import */
-	add(id, isPromise) {
-		const importEntry = {
-			id,
-			refCount: 1,
-			isPromise
-		};
-		this.imports.set(id, importEntry);
-		return importEntry;
-	}
-	/** Get an import by ID */
-	get(id) {
-		return this.imports.get(id);
-	}
-	/** Increment reference count */
-	addRef(id) {
-		const importEntry = this.imports.get(id);
-		if (importEntry) importEntry.refCount++;
-	}
-	/** Decrement reference count, returns true if refCount reached 0 */
-	release(id, count) {
-		const importEntry = this.imports.get(id);
-		if (importEntry) {
-			importEntry.refCount -= count;
-			if (importEntry.refCount <= 0) {
-				this.imports.delete(id);
-				return true;
-			}
-		}
-		return false;
-	}
-	/** Mark a promise as resolved */
-	markResolved(id) {
-		const importEntry = this.imports.get(id);
-		if (importEntry) importEntry.isPromise = false;
-	}
-	/** Clean up all imports (e.g., on disconnect) */
-	clear() {
-		this.imports.clear();
-	}
-};
-/** Manages the export table for capabilities sent to remote */
-var ExportTable = class {
-	exports = /* @__PURE__ */ new Map();
-	nextId = 1;
-	/** Add a new export */
-	add(capability, isPromise) {
-		const id = this.allocateId();
-		const exportEntry = {
-			id,
-			refCount: 1,
-			isPromise,
-			capability
-		};
-		this.exports.set(id, exportEntry);
-		return exportEntry;
-	}
-	/** Get an export by ID */
-	get(id) {
-		return this.exports.get(id);
-	}
-	/** Increment reference count */
-	addRef(id) {
-		const exportEntry = this.exports.get(id);
-		if (exportEntry) exportEntry.refCount++;
-	}
-	/** Decrement reference count, returns true if refCount reached 0 */
-	release(id, count) {
-		const exportEntry = this.exports.get(id);
-		if (exportEntry) {
-			exportEntry.refCount -= count;
-			if (exportEntry.refCount <= 0) {
-				this.exports.delete(id);
-				return true;
-			}
-		}
-		return false;
-	}
-	/** Mark a promise as resolved */
-	markResolved(id) {
-		const exportEntry = this.exports.get(id);
-		if (exportEntry) exportEntry.isPromise = false;
-	}
-	/** Clean up all exports (e.g., on disconnect) */
-	clear() {
-		this.exports.clear();
-		this.nextId = 1;
-	}
-	allocateId() {
-		return this.nextId++;
-	}
-};
-
-//#endregion
-//#region src/rpc/pipeline.ts
-/**
-* Tracks a chain of operations to apply to a promised answer.
-* This forms the "transform" field in PromisedAnswer.
-*/
-var PipelineOpTracker = class PipelineOpTracker {
-	ops = [];
-	/**
-	* Add a no-op (use the result as-is)
-	*/
-	addNoop() {
-		this.ops.push({ type: "noop" });
-	}
-	/**
-	* Add a pointer field access operation
-	*/
-	addGetPointerField(fieldIndex) {
-		this.ops.push({
-			type: "getPointerField",
-			fieldIndex
-		});
-	}
-	/**
-	* Get the current transform chain
-	*/
-	getTransform() {
-		return [...this.ops];
-	}
-	/**
-	* Clone this tracker (for creating derived pipelines)
-	*/
-	clone() {
-		const cloned = new PipelineOpTracker();
-		cloned.ops = [...this.ops];
-		return cloned;
-	}
-};
-/**
-* Symbol used to identify pipeline clients internally
-*/
-const PIPELINE_CLIENT_SYMBOL = Symbol("PipelineClient");
-/**
-* Creates a PipelineClient using JavaScript Proxy.
-* The proxy intercepts property accesses to build up the transform chain.
-*/
-function createPipelineClient(options) {
-	const { connection, questionId, opTracker = new PipelineOpTracker() } = options;
-	return {
-		[PIPELINE_CLIENT_SYMBOL]: true,
-		connection,
-		questionId,
-		opTracker,
-		call(interfaceId, methodId, params) {
-			return makePipelinedCall(connection, questionId, opTracker.getTransform(), interfaceId, methodId, params);
-		},
-		getPointerField(fieldIndex) {
-			const newTracker = opTracker.clone();
-			newTracker.addGetPointerField(fieldIndex);
-			return createPipelineClient({
-				connection,
-				questionId,
-				opTracker: newTracker
-			});
-		}
-	};
-}
-/**
-* Check if a value is a PipelineClient
-*/
-function isPipelineClient(value) {
-	return typeof value === "object" && value !== null && PIPELINE_CLIENT_SYMBOL in value;
-}
-/**
-* Makes a call on a promised answer (pipeline call).
-* This sends a Call message with target.type = 'promisedAnswer'.
-*/
-async function makePipelinedCall(connection, questionId, transform, interfaceId, methodId, params) {
-	const newQuestionId = connection.createQuestion();
-	const call = {
-		questionId: newQuestionId,
-		target: {
-			type: "promisedAnswer",
-			promisedAnswer: {
-				questionId,
-				transform
-			}
-		},
-		interfaceId,
-		methodId,
-		allowThirdPartyTailCall: false,
-		noPromisePipelining: false,
-		onlyPromisePipeline: false,
-		params,
-		sendResultsTo: { type: "caller" }
-	};
-	await connection.sendCall(call);
-	return connection.waitForAnswer(newQuestionId);
-}
-/**
-* Manages calls that were made on a pipeline client before the answer arrived.
-* When the answer arrives, these calls are dispatched to the actual capability.
-*/
-var QueuedCallManager = class {
-	queuedCalls = /* @__PURE__ */ new Map();
-	/**
-	* Queue a call for when the promise resolves
-	*/
-	queueCall(questionId, call) {
-		const calls = this.queuedCalls.get(questionId) ?? [];
-		calls.push(call);
-		this.queuedCalls.set(questionId, calls);
-	}
-	/**
-	* Get and clear all queued calls for a question
-	*/
-	dequeueCalls(questionId) {
-		const calls = this.queuedCalls.get(questionId) ?? [];
-		this.queuedCalls.delete(questionId);
-		return calls;
-	}
-	/**
-	* Check if there are queued calls for a question
-	*/
-	hasQueuedCalls(questionId) {
-		return (this.queuedCalls.get(questionId)?.length ?? 0) > 0;
-	}
-	/**
-	* Clear all queued calls (e.g., on disconnect)
-	*/
-	clear() {
-		for (const calls of this.queuedCalls.values()) for (const call of calls) call.reject(/* @__PURE__ */ new Error("Connection closed"));
-		this.queuedCalls.clear();
-	}
-};
-/**
-* Tracks pending pipeline resolutions
-*/
-var PipelineResolutionTracker = class {
-	pendingResolutions = /* @__PURE__ */ new Map();
-	/**
-	* Mark a question as resolved to a capability
-	*/
-	resolveToCapability(questionId, importId) {
-		this.pendingResolutions.set(questionId, {
-			type: "capability",
-			importId
-		});
-	}
-	/**
-	* Mark a question as resolved to an exception
-	*/
-	resolveToException(questionId, reason) {
-		this.pendingResolutions.set(questionId, {
-			type: "exception",
-			reason
-		});
-	}
-	/**
-	* Get the resolution for a question (if available)
-	*/
-	getResolution(questionId) {
-		return this.pendingResolutions.get(questionId);
-	}
-	/**
-	* Check if a question has been resolved
-	*/
-	isResolved(questionId) {
-		return this.pendingResolutions.has(questionId);
-	}
-	/**
-	* Remove a resolution entry
-	*/
-	remove(questionId) {
-		this.pendingResolutions.delete(questionId);
-	}
-	/**
-	* Clear all resolutions
-	*/
-	clear() {
-		this.pendingResolutions.clear();
-	}
-};
-
-//#endregion
-//#region src/rpc/rpc-connection.ts
-/**
-* RpcConnection
-*
-* Manages a single RPC connection, handling message routing and the Four Tables.
-* This is the core of the RPC implementation.
-*
-* Phase 2 Updates:
-* - Added Promise Pipelining support
-* - Added capability passing
-* - Added Resolve/Release/Disembargo message handling
-*/
-var RpcConnection = class {
-	transport;
-	options;
-	questions = new QuestionTable();
-	answers = new AnswerTable();
-	imports = new ImportTable();
-	exports = new ExportTable();
-	queuedCalls = new QueuedCallManager();
-	pipelineResolutions = new PipelineResolutionTracker();
-	running = false;
-	messageHandler;
-	constructor(transport, options = {}) {
-		this.transport = transport;
-		this.options = options;
-		this.transport.onClose = (reason) => {
-			this.handleDisconnect(reason);
-		};
-		this.transport.onError = (error) => {
-			this.handleError(error);
-		};
-	}
-	/** Start processing messages */
-	async start() {
-		if (this.running) return;
-		this.running = true;
-		this.messageHandler = this.messageLoop();
-	}
-	/** Stop the connection */
-	async stop() {
-		this.running = false;
-		this.transport.close();
-		if (this.messageHandler) try {
-			await this.messageHandler;
-		} catch {}
-	}
-	/** Send a bootstrap request and return the bootstrap capability */
-	async bootstrap() {
-		const question = this.questions.create();
-		const bootstrapMsg = {
-			type: "bootstrap",
-			bootstrap: { questionId: question.id }
-		};
-		await this.transport.send(bootstrapMsg);
-		await question.completionPromise;
-		return {};
-	}
-	/** Make a call to a remote capability */
-	async call(target, interfaceId, methodId, params) {
-		if (isPipelineClient(target)) return target.call(interfaceId, methodId, params);
-		const question = this.questions.create();
-		const callMsg = {
-			type: "call",
-			call: {
-				questionId: question.id,
-				target: {
-					type: "importedCap",
-					importId: target
-				},
-				interfaceId,
-				methodId,
-				allowThirdPartyTailCall: false,
-				noPromisePipelining: false,
-				onlyPromisePipeline: false,
-				params,
-				sendResultsTo: { type: "caller" }
-			}
-		};
-		await this.transport.send(callMsg);
-		return question.completionPromise;
-	}
-	/**
-	* Make a call that returns a PipelineClient for promise pipelining.
-	* This allows making calls on the result before it arrives.
-	*/
-	async callPipelined(target, interfaceId, methodId, params) {
-		const question = this.questions.create();
-		const callMsg = {
-			type: "call",
-			call: {
-				questionId: question.id,
-				target: {
-					type: "importedCap",
-					importId: target
-				},
-				interfaceId,
-				methodId,
-				allowThirdPartyTailCall: false,
-				noPromisePipelining: false,
-				onlyPromisePipeline: false,
-				params,
-				sendResultsTo: { type: "caller" }
-			}
-		};
-		await this.transport.send(callMsg);
-		return createPipelineClient({
-			connection: this,
-			questionId: question.id
-		});
-	}
-	/** Send a finish message to release a question */
-	async finish(questionId, releaseResultCaps = true) {
-		if (!this.questions.get(questionId)) return;
-		const finishMsg = {
-			type: "finish",
-			finish: {
-				questionId,
-				releaseResultCaps,
-				requireEarlyCancellationWorkaround: false
-			}
-		};
-		await this.transport.send(finishMsg);
-		this.questions.markFinishSent(questionId);
-		this.questions.remove(questionId);
-	}
-	/** Send a release message for an imported capability */
-	async release(importId, referenceCount = 1) {
-		const releaseMsg = {
-			type: "release",
-			release: {
-				id: importId,
-				referenceCount
-			}
-		};
-		await this.transport.send(releaseMsg);
-	}
-	/** Send a resolve message to indicate a promise has resolved */
-	async resolve(promiseId, cap) {
-		const resolveMsg = {
-			type: "resolve",
-			resolve: {
-				promiseId,
-				resolution: {
-					type: "cap",
-					cap
-				}
-			}
-		};
-		await this.transport.send(resolveMsg);
-	}
-	/** Send a resolve message indicating a promise was broken */
-	async resolveException(promiseId, reason) {
-		const resolveMsg = {
-			type: "resolve",
-			resolve: {
-				promiseId,
-				resolution: {
-					type: "exception",
-					exception: {
-						reason,
-						type: "failed"
-					}
-				}
-			}
-		};
-		await this.transport.send(resolveMsg);
-	}
-	/** Internal method: Create a new question (used by pipeline) */
-	createQuestion() {
-		return this.questions.create().id;
-	}
-	/** Internal method: Send a call message (used by pipeline) */
-	async sendCall(call) {
-		const callMsg = {
-			type: "call",
-			call
-		};
-		await this.transport.send(callMsg);
-	}
-	/** Internal method: Wait for an answer (used by pipeline) */
-	async waitForAnswer(questionId) {
-		const question = this.questions.get(questionId);
-		if (!question) throw new Error(`Question ${questionId} not found`);
-		return question.completionPromise;
-	}
-	/** Main message processing loop */
-	async messageLoop() {
-		while (this.running) try {
-			const message = await this.transport.receive();
-			if (message === null) break;
-			await this.handleMessage(message);
-		} catch (error) {
-			if (this.running) this.handleError(error);
-		}
-	}
-	/** Handle incoming messages */
-	async handleMessage(message) {
-		switch (message.type) {
-			case "bootstrap":
-				await this.handleBootstrap(message.bootstrap);
-				break;
-			case "call":
-				await this.handleCall(message.call);
-				break;
-			case "return":
-				await this.handleReturn(message.return);
-				break;
-			case "finish":
-				await this.handleFinish(message.finish);
-				break;
-			case "resolve":
-				await this.handleResolve(message.resolve);
-				break;
-			case "release":
-				await this.handleRelease(message.release);
-				break;
-			case "disembargo":
-				await this.handleDisembargo(message.disembargo);
-				break;
-			case "abort":
-				this.handleAbort(message.exception.reason);
-				break;
-			case "unimplemented": break;
-			default: await this.sendUnimplemented(message);
-		}
-	}
-	/** Handle bootstrap request */
-	async handleBootstrap(bootstrap) {
-		this.answers.create(bootstrap.questionId);
-		const returnMsg = {
-			type: "return",
-			return: {
-				answerId: bootstrap.questionId,
-				releaseParamCaps: true,
-				noFinishNeeded: false,
-				result: {
-					type: "results",
-					payload: {
-						content: new Uint8Array(0),
-						capTable: []
-					}
-				}
-			}
-		};
-		await this.transport.send(returnMsg);
-		this.answers.markReturnSent(bootstrap.questionId);
-	}
-	/** Handle incoming call */
-	async handleCall(call) {
-		this.answers.create(call.questionId);
-		const returnMsg = {
-			type: "return",
-			return: {
-				answerId: call.questionId,
-				releaseParamCaps: true,
-				noFinishNeeded: false,
-				result: {
-					type: "exception",
-					exception: {
-						reason: "Method not implemented",
-						type: "unimplemented"
-					}
-				}
-			}
-		};
-		await this.transport.send(returnMsg);
-		this.answers.markReturnSent(call.questionId);
-	}
-	/** Handle return message */
-	async handleReturn(ret) {
-		if (!this.questions.get(ret.answerId)) return;
-		if (ret.result.type === "results") {
-			const capTable = ret.result.payload.capTable;
-			if (capTable.length > 0) {
-				const cap = capTable[0];
-				if (cap.type === "receiverHosted") this.pipelineResolutions.resolveToCapability(ret.answerId, cap.importId);
-			}
-		} else if (ret.result.type === "exception") this.pipelineResolutions.resolveToException(ret.answerId, ret.result.exception.reason);
-		switch (ret.result.type) {
-			case "results":
-				this.questions.complete(ret.answerId, ret.result.payload);
-				break;
-			case "exception":
-				this.questions.cancel(ret.answerId, new Error(ret.result.exception.reason));
-				break;
-			case "canceled":
-				this.questions.cancel(ret.answerId, /* @__PURE__ */ new Error("Call canceled"));
-				break;
-			default: this.questions.cancel(ret.answerId, /* @__PURE__ */ new Error("Unknown return type"));
-		}
-	}
-	/** Handle finish message */
-	async handleFinish(finish) {
-		this.answers.markFinishReceived(finish.questionId);
-		this.answers.remove(finish.questionId);
-	}
-	/** Handle resolve message (Level 1) */
-	async handleResolve(resolve) {
-		const { promiseId, resolution } = resolve;
-		switch (resolution.type) {
-			case "cap":
-				this.imports.markResolved(promiseId);
-				break;
-			case "exception":
-				console.warn(`Promise ${promiseId} broken: ${resolution.exception.reason}`);
-				break;
-		}
-	}
-	/** Handle release message (Level 1) */
-	async handleRelease(release) {
-		const { id, referenceCount } = release;
-		if (this.exports.release(id, referenceCount)) console.log(`Export ${id} fully released`);
-	}
-	/** Handle disembargo message (Level 1) */
-	async handleDisembargo(disembargo) {
-		const { target, context } = disembargo;
-		if (context.type === "senderLoopback") {
-			const echoMsg = {
-				type: "disembargo",
-				disembargo: {
-					target,
-					context: {
-						type: "receiverLoopback",
-						embargoId: context.embargoId
-					}
-				}
-			};
-			await this.transport.send(echoMsg);
-		}
-	}
-	/** Handle abort message */
-	handleAbort(_reason) {
-		this.running = false;
-		this.questions.clear();
-		this.answers.clear();
-		this.imports.clear();
-		this.exports.clear();
-		this.queuedCalls.clear();
-		this.pipelineResolutions.clear();
-	}
-	/** Handle disconnect */
-	handleDisconnect(_reason) {
-		this.running = false;
-		this.questions.clear();
-		this.answers.clear();
-		this.imports.clear();
-		this.exports.clear();
-		this.queuedCalls.clear();
-		this.pipelineResolutions.clear();
-	}
-	/** Handle error */
-	handleError(error) {
-		console.error("RPC error:", error);
-	}
-	/** Send unimplemented response */
-	async sendUnimplemented(originalMessage) {
-		const msg = {
-			type: "unimplemented",
-			message: originalMessage
-		};
-		await this.transport.send(msg);
-	}
-	/** Import a capability from the remote peer */
-	importCapability(importId, isPromise = false) {
-		this.imports.add(importId, isPromise);
-	}
-	/** Export a capability to the remote peer */
-	exportCapability(capability, isPromise = false) {
-		return this.exports.add(capability, isPromise).id;
-	}
-	/** Get an imported capability */
-	getImport(importId) {
-		return this.imports.get(importId);
-	}
-	/** Get an exported capability */
-	getExport(exportId) {
-		return this.exports.get(exportId);
-	}
-};
-
 //#endregion
 //#region src/rpc/capability-client.ts
 /** Base class for capability client implementations */
@@ -3000,11 +2236,2690 @@ function configureGlobalMemoryPool(options) {
 }
 
 //#endregion
-exports.AnswerTable = AnswerTable;
+//#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 = ExportTable;
-exports.ImportTable = ImportTable;
+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;
@@ -3012,15 +4927,22 @@ exports.MessageBuilder = MessageBuilder;
 exports.MessageReader = MessageReader;
 exports.MultiSegmentMessageBuilder = MultiSegmentMessageBuilder;
 exports.OptimizedRpcMessageBuilder = OptimizedRpcMessageBuilder;
-exports.PIPELINE_CLIENT_SYMBOL = PIPELINE_CLIENT_SYMBOL;
-exports.PipelineOpTracker = PipelineOpTracker;
-exports.PipelineResolutionTracker = PipelineResolutionTracker;
+exports.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 = QuestionTable;
-exports.QueuedCallManager = QueuedCallManager;
+exports.QuestionTable = require_rpc_connection.QuestionTable;
+exports.QueuedCallManager = require_rpc_connection.QueuedCallManager;
+exports.RealtimeStream = RealtimeStream;
+exports.RealtimeStreamManager = RealtimeStreamManager;
 exports.RestoreHandler = RestoreHandler;
-exports.RpcConnection = RpcConnection;
+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;
@@ -3029,8 +4951,16 @@ exports.UnionReader = UnionReader;
 exports.WORD_SIZE = WORD_SIZE;
 exports.WebSocketTransport = WebSocketTransport;
 exports.configureGlobalMemoryPool = configureGlobalMemoryPool;
-exports.createPipelineClient = createPipelineClient;
+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;
@@ -3040,10 +4970,14 @@ exports.deserializeSturdyRef = deserializeSturdyRef;
 exports.encodeListPointer = encodeListPointer;
 exports.encodeStructPointer = encodeStructPointer;
 exports.fastCopy = fastCopy;
+exports.generateProvisionId = generateProvisionId;
+exports.generateVatId = generateVatId;
 exports.getGlobalMemoryPool = getGlobalMemoryPool;
-exports.isPipelineClient = isPipelineClient;
+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