@naeemo/capnp 0.2.0 → 0.4.0

package/dist/rpc-connection-Dz3rYT1P.js

@@ -0,0 +1,870 @@
+//#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
+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;
+	level3Handlers;
+	level4Handlers;
+	constructor(transport, options = {}) {
+		this.transport = transport;
+		this.options = options;
+		this.level3Handlers = options.level3Handlers;
+		this.transport.onClose = (reason) => {
+			this.handleDisconnect(reason);
+		};
+		this.transport.onError = (error) => {
+			this.handleError(error);
+		};
+		this.level3Handlers = options.level3Handlers;
+		this.level4Handlers = options.level4Handlers;
+	}
+	/** 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);
+	}
+	/** Send a return message (internal use) */
+	async sendReturn(ret) {
+		const returnMsg = {
+			type: "return",
+			return: ret
+		};
+		await this.transport.send(returnMsg);
+	}
+	/** Send a disembargo message (internal use) */
+	async sendDisembargo(disembargo) {
+		const disembargoMsg = {
+			type: "disembargo",
+			disembargo
+		};
+		await this.transport.send(disembargoMsg);
+	}
+	/** 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 "provide":
+				await this.handleProvide(message.provide);
+				break;
+			case "accept":
+				await this.handleAccept(message.accept);
+				break;
+			case "join":
+				await this.handleJoin(message.join);
+				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 (cap.type === "thirdPartyHosted") await this.handleThirdPartyCapability(ret.answerId, cap.thirdPartyCapId);
+			}
+		} 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;
+			case "acceptFromThirdParty":
+				await this.handleAcceptFromThirdParty(ret.answerId, ret.result.thirdPartyCapId);
+				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 (this.level3Handlers) {
+			await this.level3Handlers.handleDisembargo(disembargo);
+			return;
+		}
+		if (context.type === "senderLoopback") {
+			const echoMsg = {
+				type: "disembargo",
+				disembargo: {
+					target,
+					context: {
+						type: "receiverLoopback",
+						embargoId: context.embargoId
+					}
+				}
+			};
+			await this.transport.send(echoMsg);
+		}
+	}
+	/** Handle provide message (Level 3) */
+	async handleProvide(provide) {
+		if (this.level3Handlers) await this.level3Handlers.handleProvide(provide);
+		else await this.sendReturnException(provide.questionId, "Level 3 RPC (Provide) not implemented");
+	}
+	/** Handle accept message (Level 3) */
+	async handleAccept(accept) {
+		if (this.level3Handlers) await this.level3Handlers.handleAccept(accept);
+		else await this.sendReturnException(accept.questionId, "Level 3 RPC (Accept) not implemented");
+	}
+	/** Handle third-party capability in return results (Level 3) */
+	async handleThirdPartyCapability(_questionId, thirdPartyCapId) {
+		if (this.level3Handlers) {
+			if (await this.level3Handlers.handleThirdPartyCapability(thirdPartyCapId) !== void 0) {}
+		}
+	}
+	/** Handle acceptFromThirdParty return type (Level 3) */
+	async handleAcceptFromThirdParty(questionId, thirdPartyCapId) {
+		if (this.level3Handlers) {
+			const importId = await this.level3Handlers.handleThirdPartyCapability(thirdPartyCapId);
+			if (importId !== void 0) this.questions.complete(questionId, { importId });
+			else this.questions.cancel(questionId, /* @__PURE__ */ new Error("Failed to resolve third-party capability"));
+		} else this.questions.cancel(questionId, /* @__PURE__ */ new Error("Level 3 RPC not enabled"));
+	}
+	/** 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);
+	}
+	/** Send return exception (helper) */
+	async sendReturnException(questionId, reason) {
+		const returnMsg = {
+			type: "return",
+			return: {
+				answerId: questionId,
+				releaseParamCaps: true,
+				noFinishNeeded: false,
+				result: {
+					type: "exception",
+					exception: {
+						reason,
+						type: "unimplemented"
+					}
+				}
+			}
+		};
+		await this.transport.send(returnMsg);
+	}
+	/**
+	* Set the Level 4 handlers for this connection.
+	* This enables reference equality verification support.
+	*/
+	setLevel4Handlers(handlers) {
+		this.level4Handlers = handlers;
+	}
+	/**
+	* Send a Join message to verify that two capabilities point to the same object.
+	* Requires Level 4 handlers to be set.
+	*/
+	async join(_target1, _target2) {
+		if (!this.level4Handlers) throw new Error("Level 4 handlers not set");
+	}
+	/** Handle join message (Level 4) */
+	async handleJoin(join) {
+		if (this.level4Handlers) await this.level4Handlers.handleJoin(join);
+		else await this.sendReturnException(join.questionId, "Level 4 RPC (Join) not implemented");
+	}
+	/** 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);
+	}
+	/**
+	* Set the Level 3 handlers for this connection.
+	* This enables three-way introduction support.
+	*/
+	setLevel3Handlers(handlers) {
+		this.level3Handlers = handlers;
+	}
+	/**
+	* Send a Provide message to offer a capability to a third party.
+	* Requires Level 3 handlers to be set.
+	*/
+	async provideToThirdParty(_target, _recipient) {
+		if (!this.level3Handlers) throw new Error("Level 3 handlers not set");
+	}
+};
+
+//#endregion
+export { QueuedCallManager as a, AnswerTable as c, QuestionTable as d, PipelineResolutionTracker as i, ExportTable as l, PIPELINE_CLIENT_SYMBOL as n, createPipelineClient as o, PipelineOpTracker as r, isPipelineClient as s, RpcConnection as t, ImportTable as u };
+//# sourceMappingURL=rpc-connection-Dz3rYT1P.js.map