@naeemo/capnp 0.4.0 → 0.5.2

package/dist/rpc-connection-_eHtWsk2.js

@@ -0,0 +1,2296 @@
+
+//#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/schema-types.ts
+/**
+* Supported schema serialization formats
+*/
+let SchemaFormat = /* @__PURE__ */ function(SchemaFormat) {
+	/** Standard Cap'n Proto binary format (schema.capnp structs) */
+	SchemaFormat[SchemaFormat["BINARY"] = 0] = "BINARY";
+	/** JSON representation of the schema */
+	SchemaFormat[SchemaFormat["JSON"] = 1] = "JSON";
+	/** Cap'n Proto schema language text format */
+	SchemaFormat[SchemaFormat["CAPNP"] = 2] = "CAPNP";
+	return SchemaFormat;
+}({});
+/**
+* Schema node types (mirroring schema.capnp Node union)
+*/
+let SchemaNodeType = /* @__PURE__ */ function(SchemaNodeType) {
+	SchemaNodeType[SchemaNodeType["FILE"] = 0] = "FILE";
+	SchemaNodeType[SchemaNodeType["STRUCT"] = 1] = "STRUCT";
+	SchemaNodeType[SchemaNodeType["ENUM"] = 2] = "ENUM";
+	SchemaNodeType[SchemaNodeType["INTERFACE"] = 3] = "INTERFACE";
+	SchemaNodeType[SchemaNodeType["CONST"] = 4] = "CONST";
+	SchemaNodeType[SchemaNodeType["ANNOTATION"] = 5] = "ANNOTATION";
+	return SchemaNodeType;
+}({});
+
+//#endregion
+//#region src/rpc/schema-parser.ts
+/**
+* Parse schema binary data into SchemaNode objects
+*
+* This parses the CodeGeneratorRequest format from schema.capnp
+*/
+function parseSchemaNodes(data) {
+	return new SchemaParser(data).parse();
+}
+/**
+* Schema parser class
+*/
+var SchemaParser = class {
+	data;
+	view;
+	textDecoder = new TextDecoder();
+	constructor(data) {
+		this.data = data;
+		this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	}
+	/**
+	* Parse the schema data and return all nodes
+	*/
+	parse() {
+		const nodes = [];
+		if (this.data.length < 8) return nodes;
+		const nodesPtr = this.readPointer(8);
+		if (nodesPtr.offset > 0 && nodesPtr.size > 0) {
+			const nodeList = this.readStructList(nodesPtr.offset, nodesPtr.size, (offset) => this.parseNode(offset));
+			nodes.push(...nodeList);
+		}
+		return nodes;
+	}
+	/**
+	* Parse a single Node structure
+	*/
+	parseNode(offset) {
+		const id = this.view.getBigUint64(offset, true);
+		const displayNamePtr = this.readPointer(offset + 8);
+		const displayName = this.readText(displayNamePtr.offset, displayNamePtr.size);
+		const displayNamePrefixLength = this.view.getUint32(offset + 16, true);
+		const scopeId = this.view.getBigUint64(offset + 24, true);
+		const nestedNodesPtr = this.readPointer(offset + 32);
+		const nestedNodes = nestedNodesPtr.offset > 0 && nestedNodesPtr.size > 0 ? this.readStructList(nestedNodesPtr.offset, nestedNodesPtr.size, (noffset) => this.parseNestedNode(noffset)) : [];
+		const annotationsPtr = this.readPointer(offset + 40);
+		const annotations = annotationsPtr.offset > 0 && annotationsPtr.size > 0 ? this.readStructList(annotationsPtr.offset, annotationsPtr.size, (aoffset) => this.parseAnnotation(aoffset)) : [];
+		const discriminant = this.view.getUint16(offset + 48, true);
+		const type = this.mapNodeType(discriminant);
+		const node = {
+			id,
+			displayName,
+			displayNamePrefixLength,
+			scopeId,
+			nestedNodes,
+			annotations,
+			type
+		};
+		const unionOffset = offset + 56;
+		switch (type) {
+			case SchemaNodeType.STRUCT:
+				node.structInfo = this.parseStructInfo(unionOffset);
+				break;
+			case SchemaNodeType.ENUM:
+				node.enumInfo = this.parseEnumInfo(unionOffset);
+				break;
+			case SchemaNodeType.INTERFACE:
+				node.interfaceInfo = this.parseInterfaceInfo(unionOffset);
+				break;
+			case SchemaNodeType.CONST:
+				node.constInfo = this.parseConstInfo(unionOffset);
+				break;
+			case SchemaNodeType.ANNOTATION:
+				node.annotationInfo = this.parseAnnotationInfo(unionOffset);
+				break;
+		}
+		return node;
+	}
+	/**
+	* Parse nested node reference
+	*/
+	parseNestedNode(offset) {
+		const namePtr = this.readPointer(offset);
+		return {
+			name: this.readText(namePtr.offset, namePtr.size),
+			id: this.view.getBigUint64(offset + 8, true)
+		};
+	}
+	/**
+	* Parse annotation
+	*/
+	parseAnnotation(offset) {
+		const id = this.view.getBigUint64(offset, true);
+		const valuePtr = this.readPointer(offset + 8);
+		const value = this.parseValue(valuePtr.offset);
+		const brandPtr = this.readPointer(offset + 16);
+		return {
+			id,
+			value,
+			brand: brandPtr.offset > 0 ? this.parseBrand(brandPtr.offset) : { scopes: [] }
+		};
+	}
+	/**
+	* Parse struct-specific info
+	*/
+	parseStructInfo(offset) {
+		const dataWordCount = this.view.getUint16(offset, true);
+		const pointerCount = this.view.getUint16(offset + 2, true);
+		const preferredListEncoding = this.view.getUint16(offset + 4, true);
+		const isGroup = this.view.getUint8(offset + 6) !== 0;
+		const discriminantCount = this.view.getUint16(offset + 8, true);
+		const discriminantOffset = this.view.getUint32(offset + 12, true);
+		const fieldsPtr = this.readPointer(offset + 16);
+		return {
+			dataWordCount,
+			pointerCount,
+			preferredListEncoding,
+			isGroup,
+			discriminantCount,
+			discriminantOffset,
+			fields: fieldsPtr.offset > 0 && fieldsPtr.size > 0 ? this.readStructList(fieldsPtr.offset, fieldsPtr.size, (foffset) => this.parseField(foffset)) : []
+		};
+	}
+	/**
+	* Parse field definition
+	*/
+	parseField(offset) {
+		const namePtr = this.readPointer(offset);
+		const name = this.readText(namePtr.offset, namePtr.size);
+		const codeOrder = this.view.getUint16(offset + 8, true);
+		const discriminantValue = this.view.getUint16(offset + 12, true);
+		const slotOffset = this.view.getUint32(offset + 24, true);
+		const typePtr = this.readPointer(offset + 32);
+		const type = this.parseType(typePtr.offset);
+		const defaultValuePtr = this.readPointer(offset + 40);
+		return {
+			name,
+			codeOrder,
+			discriminantValue,
+			offset: slotOffset,
+			type,
+			defaultValue: defaultValuePtr.offset > 0 ? this.parseValue(defaultValuePtr.offset) : void 0,
+			hadExplicitDefault: this.view.getUint8(offset + 48) !== 0
+		};
+	}
+	/**
+	* Parse type definition
+	*/
+	parseType(offset) {
+		const discriminant = this.view.getUint16(offset, true);
+		return { kind: this.parseTypeKind(discriminant, offset + 8) };
+	}
+	/**
+	* Parse type kind based on discriminant
+	*/
+	parseTypeKind(discriminant, offset) {
+		switch (discriminant) {
+			case 0: return { type: "void" };
+			case 1: return { type: "bool" };
+			case 2: return { type: "int8" };
+			case 3: return { type: "int16" };
+			case 4: return { type: "int32" };
+			case 5: return { type: "int64" };
+			case 6: return { type: "uint8" };
+			case 7: return { type: "uint16" };
+			case 8: return { type: "uint32" };
+			case 9: return { type: "uint64" };
+			case 10: return { type: "float32" };
+			case 11: return { type: "float64" };
+			case 12: return { type: "text" };
+			case 13: return { type: "data" };
+			case 14: {
+				const elementTypePtr = this.readPointer(offset);
+				return {
+					type: "list",
+					elementType: this.parseType(elementTypePtr.offset)
+				};
+			}
+			case 15: {
+				const typeId = this.view.getBigUint64(offset, true);
+				const brandPtr = this.readPointer(offset + 8);
+				return {
+					type: "enum",
+					typeId,
+					brand: brandPtr.offset > 0 ? this.parseBrand(brandPtr.offset) : void 0
+				};
+			}
+			case 16: {
+				const typeId = this.view.getBigUint64(offset, true);
+				const brandPtr = this.readPointer(offset + 8);
+				return {
+					type: "struct",
+					typeId,
+					brand: brandPtr.offset > 0 ? this.parseBrand(brandPtr.offset) : void 0
+				};
+			}
+			case 17: {
+				const typeId = this.view.getBigUint64(offset, true);
+				const brandPtr = this.readPointer(offset + 8);
+				return {
+					type: "interface",
+					typeId,
+					brand: brandPtr.offset > 0 ? this.parseBrand(brandPtr.offset) : void 0
+				};
+			}
+			case 18: {
+				const anyPtrDisc = this.view.getUint16(offset, true);
+				return this.parseAnyPointerKind(anyPtrDisc, offset + 8);
+			}
+			default: return { type: "void" };
+		}
+	}
+	/**
+	* Parse anyPointer constraint
+	*/
+	parseAnyPointerKind(discriminant, offset) {
+		switch (discriminant) {
+			case 0: return {
+				type: "anyPointer",
+				constraint: {
+					type: "unconstrained",
+					kind: [
+						"anyKind",
+						"struct",
+						"list",
+						"capability"
+					][this.view.getUint16(offset, true)] ?? "anyKind"
+				}
+			};
+			case 1: return {
+				type: "anyPointer",
+				constraint: {
+					type: "parameter",
+					scopeId: this.view.getBigUint64(offset, true),
+					parameterIndex: this.view.getUint16(offset + 8, true)
+				}
+			};
+			case 2: return {
+				type: "anyPointer",
+				constraint: {
+					type: "implicitMethodParameter",
+					parameterIndex: this.view.getUint16(offset, true)
+				}
+			};
+			default: return {
+				type: "anyPointer",
+				constraint: {
+					type: "unconstrained",
+					kind: "anyKind"
+				}
+			};
+		}
+	}
+	/**
+	* Parse brand (generic type bindings)
+	*/
+	parseBrand(offset) {
+		const scopesPtr = this.readPointer(offset);
+		return { scopes: scopesPtr.offset > 0 && scopesPtr.size > 0 ? this.readStructList(scopesPtr.offset, scopesPtr.size, (soffset) => this.parseBrandScope(soffset)) : [] };
+	}
+	/**
+	* Parse brand scope
+	*/
+	parseBrandScope(offset) {
+		const scopeId = this.view.getBigUint64(offset, true);
+		const discriminant = this.view.getUint16(offset + 8, true);
+		let bindings = [];
+		if (discriminant === 0) {
+			const bindingsPtr = this.readPointer(offset + 16);
+			bindings = bindingsPtr.offset > 0 && bindingsPtr.size > 0 ? this.readStructList(bindingsPtr.offset, bindingsPtr.size, (boffset) => this.parseBrandBinding(boffset)) : [];
+		}
+		return {
+			scopeId,
+			bindings
+		};
+	}
+	/**
+	* Parse brand binding
+	*/
+	parseBrandBinding(offset) {
+		if (this.view.getUint16(offset, true) === 0) return { type: "unbound" };
+		const typePtr = this.readPointer(offset + 8);
+		return {
+			type: "type",
+			value: this.parseType(typePtr.offset)
+		};
+	}
+	/**
+	* Parse value
+	*/
+	parseValue(offset) {
+		const discriminant = this.view.getUint16(offset, true);
+		const dataOffset = offset + 8;
+		switch (discriminant) {
+			case 0: return { type: "void" };
+			case 1: return {
+				type: "bool",
+				value: this.view.getUint8(dataOffset) !== 0
+			};
+			case 2: return {
+				type: "int8",
+				value: this.view.getInt8(dataOffset)
+			};
+			case 3: return {
+				type: "int16",
+				value: this.view.getInt16(dataOffset, true)
+			};
+			case 4: return {
+				type: "int32",
+				value: this.view.getInt32(dataOffset, true)
+			};
+			case 5: return {
+				type: "int64",
+				value: this.view.getBigInt64(dataOffset, true)
+			};
+			case 6: return {
+				type: "uint8",
+				value: this.view.getUint8(dataOffset)
+			};
+			case 7: return {
+				type: "uint16",
+				value: this.view.getUint16(dataOffset, true)
+			};
+			case 8: return {
+				type: "uint32",
+				value: this.view.getUint32(dataOffset, true)
+			};
+			case 9: return {
+				type: "uint64",
+				value: this.view.getBigUint64(dataOffset, true)
+			};
+			case 10: return {
+				type: "float32",
+				value: this.view.getFloat32(dataOffset, true)
+			};
+			case 11: return {
+				type: "float64",
+				value: this.view.getFloat64(dataOffset, true)
+			};
+			case 12: {
+				const ptr = this.readPointer(dataOffset);
+				return {
+					type: "text",
+					value: this.readText(ptr.offset, ptr.size)
+				};
+			}
+			case 13: {
+				const ptr = this.readPointer(dataOffset);
+				return {
+					type: "data",
+					value: this.data.slice(ptr.offset, ptr.offset + ptr.size)
+				};
+			}
+			case 14: return {
+				type: "list",
+				value: null
+			};
+			case 15: return {
+				type: "enum",
+				value: this.view.getUint16(dataOffset, true)
+			};
+			case 16: return {
+				type: "struct",
+				value: null
+			};
+			case 17: return { type: "interface" };
+			case 18: return {
+				type: "anyPointer",
+				value: null
+			};
+			default: return { type: "void" };
+		}
+	}
+	/**
+	* Parse enum-specific info
+	*/
+	parseEnumInfo(offset) {
+		const enumerantsPtr = this.readPointer(offset);
+		return { enumerants: enumerantsPtr.offset > 0 && enumerantsPtr.size > 0 ? this.readStructList(enumerantsPtr.offset, enumerantsPtr.size, (eoffset) => this.parseEnumerant(eoffset)) : [] };
+	}
+	/**
+	* Parse enumerant
+	*/
+	parseEnumerant(offset) {
+		const namePtr = this.readPointer(offset);
+		const name = this.readText(namePtr.offset, namePtr.size);
+		const codeOrder = this.view.getUint16(offset + 8, true);
+		const annotationsPtr = this.readPointer(offset + 16);
+		return {
+			name,
+			codeOrder,
+			annotations: annotationsPtr.offset > 0 && annotationsPtr.size > 0 ? this.readStructList(annotationsPtr.offset, annotationsPtr.size, (aoffset) => this.parseAnnotation(aoffset)) : []
+		};
+	}
+	/**
+	* Parse interface-specific info
+	*/
+	parseInterfaceInfo(offset) {
+		const methodsPtr = this.readPointer(offset);
+		const methods = methodsPtr.offset > 0 && methodsPtr.size > 0 ? this.readStructList(methodsPtr.offset, methodsPtr.size, (moffset) => this.parseMethod(moffset)) : [];
+		const superclassesPtr = this.readPointer(offset + 8);
+		return {
+			methods,
+			superclasses: superclassesPtr.offset > 0 && superclassesPtr.size > 0 ? this.readStructList(superclassesPtr.offset, superclassesPtr.size, (soffset) => this.parseSuperclass(soffset)) : []
+		};
+	}
+	/**
+	* Parse method
+	*/
+	parseMethod(offset) {
+		const namePtr = this.readPointer(offset);
+		const name = this.readText(namePtr.offset, namePtr.size);
+		const codeOrder = this.view.getUint16(offset + 8, true);
+		const paramStructType = this.view.getBigUint64(offset + 16, true);
+		const resultStructType = this.view.getBigUint64(offset + 24, true);
+		const annotationsPtr = this.readPointer(offset + 32);
+		return {
+			name,
+			codeOrder,
+			paramStructType,
+			resultStructType,
+			annotations: annotationsPtr.offset > 0 && annotationsPtr.size > 0 ? this.readStructList(annotationsPtr.offset, annotationsPtr.size, (aoffset) => this.parseAnnotation(aoffset)) : []
+		};
+	}
+	/**
+	* Parse superclass
+	*/
+	parseSuperclass(offset) {
+		const id = this.view.getBigUint64(offset, true);
+		const brandPtr = this.readPointer(offset + 8);
+		return {
+			id,
+			brand: brandPtr.offset > 0 ? this.parseBrand(brandPtr.offset) : { scopes: [] }
+		};
+	}
+	/**
+	* Parse const-specific info
+	*/
+	parseConstInfo(offset) {
+		const typePtr = this.readPointer(offset);
+		const type = this.parseType(typePtr.offset);
+		const valuePtr = this.readPointer(offset + 8);
+		return {
+			type,
+			value: this.parseValue(valuePtr.offset)
+		};
+	}
+	/**
+	* Parse annotation-specific info
+	*/
+	parseAnnotationInfo(offset) {
+		const typePtr = this.readPointer(offset);
+		const type = this.parseType(typePtr.offset);
+		const flags = this.view.getUint16(offset + 8, true);
+		return {
+			type,
+			targetsFile: (flags & 1) !== 0,
+			targetsConst: (flags & 2) !== 0,
+			targetsEnum: (flags & 4) !== 0,
+			targetsEnumerant: (flags & 8) !== 0,
+			targetsStruct: (flags & 16) !== 0,
+			targetsField: (flags & 32) !== 0,
+			targetsUnion: (flags & 64) !== 0,
+			targetsGroup: (flags & 128) !== 0,
+			targetsInterface: (flags & 256) !== 0,
+			targetsMethod: (flags & 512) !== 0,
+			targetsParam: (flags & 1024) !== 0,
+			targetsAnnotation: (flags & 2048) !== 0
+		};
+	}
+	/**
+	* Map node type discriminant to SchemaNodeType
+	*/
+	mapNodeType(discriminant) {
+		return [
+			SchemaNodeType.FILE,
+			SchemaNodeType.FILE,
+			SchemaNodeType.FILE,
+			SchemaNodeType.FILE,
+			SchemaNodeType.FILE,
+			SchemaNodeType.FILE,
+			SchemaNodeType.FILE,
+			SchemaNodeType.STRUCT,
+			SchemaNodeType.ENUM,
+			SchemaNodeType.INTERFACE,
+			SchemaNodeType.CONST,
+			SchemaNodeType.ANNOTATION
+		][discriminant] ?? SchemaNodeType.FILE;
+	}
+	/**
+	* Read a pointer value
+	*/
+	readPointer(offset) {
+		const wordOffset = this.view.getInt32(offset, true);
+		const sizeAndType = this.view.getUint32(offset + 4, true);
+		const size = sizeAndType & 16777215;
+		sizeAndType >> 24 & 7;
+		if (wordOffset === 0 && size === 0) return {
+			offset: 0,
+			size: 0
+		};
+		return {
+			offset: offset + 8 + wordOffset * 8,
+			size
+		};
+	}
+	/**
+	* Read text from offset
+	*/
+	readText(offset, size) {
+		if (size === 0) return "";
+		const actualSize = size > 0 ? size - 1 : 0;
+		const bytes = this.data.slice(offset, offset + actualSize);
+		return this.textDecoder.decode(bytes);
+	}
+	/**
+	* Read a list of structs
+	*/
+	readStructList(offset, count, parser) {
+		const result = [];
+		let currentOffset = offset;
+		const structSize = 64;
+		for (let i = 0; i < count; i++) {
+			result.push(parser(currentOffset));
+			currentOffset += structSize;
+		}
+		return result;
+	}
+};
+/**
+* Create a schema registry for managing parsed schemas
+*/
+function createSchemaRegistry() {
+	const nodesById = /* @__PURE__ */ new Map();
+	const nodesByName = /* @__PURE__ */ new Map();
+	const nodesByFile = /* @__PURE__ */ new Map();
+	return {
+		registerNode(node) {
+			nodesById.set(node.id, node);
+			nodesByName.set(node.displayName, node);
+			const fileNodes = nodesByFile.get(node.scopeId) ?? [];
+			fileNodes.push(node);
+			nodesByFile.set(node.scopeId, fileNodes);
+		},
+		getNode(id) {
+			return nodesById.get(id);
+		},
+		getNodeByName(name) {
+			return nodesByName.get(name);
+		},
+		getNodesByFile(fileId) {
+			return nodesByFile.get(fileId) ?? [];
+		},
+		hasNode(id) {
+			return nodesById.has(id);
+		},
+		clear() {
+			nodesById.clear();
+			nodesByName.clear();
+			nodesByFile.clear();
+		}
+	};
+}
+
+//#endregion
+//#region src/rpc/schema-serializer.ts
+const SCHEMA_MESSAGE_TYPES = {
+	SCHEMA_REQUEST: 14,
+	SCHEMA_RESPONSE: 15
+};
+/**
+* Serialize a SchemaRequest to binary format
+*/
+function serializeSchemaRequest(request) {
+	const totalSize = 8 + getSchemaTargetSize(request.targetSchema);
+	const buffer = new ArrayBuffer(totalSize);
+	const view = new DataView(buffer);
+	const bytes = new Uint8Array(buffer);
+	view.setUint32(0, request.questionId, true);
+	let offset = 8;
+	offset = writeSchemaTarget(bytes, offset, request.targetSchema);
+	return bytes;
+}
+/**
+* Deserialize a SchemaRequest from binary format
+*/
+function deserializeSchemaRequest(data) {
+	return {
+		questionId: new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true),
+		targetSchema: readSchemaTarget(data, 8).value
+	};
+}
+/**
+* Get the serialized size of a SchemaTarget
+*/
+function getSchemaTargetSize(target) {
+	switch (target.type) {
+		case "allSchemas":
+		case "bootstrapInterface": return 8;
+		case "byTypeId":
+		case "byFileId": return 16;
+		case "byTypeName":
+		case "byFileName": return 16 + align8(target.type === "byTypeName" ? target.typeName.length : target.fileName.length);
+		default: return 8;
+	}
+}
+/**
+* Write a SchemaTarget to binary format
+*/
+function writeSchemaTarget(bytes, offset, target) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset);
+	switch (target.type) {
+		case "allSchemas":
+			view.setUint16(offset, 0, true);
+			break;
+		case "byTypeId":
+			view.setUint16(offset, 1, true);
+			view.setBigUint64(offset + 8, target.typeId, true);
+			break;
+		case "byTypeName": {
+			view.setUint16(offset, 2, true);
+			const strBytes = new TextEncoder().encode(target.typeName);
+			writePointer(bytes, offset + 8, strBytes.length);
+			bytes.set(strBytes, offset + 16);
+			return offset + 16 + align8(strBytes.length);
+		}
+		case "byFileId":
+			view.setUint16(offset, 3, true);
+			view.setBigUint64(offset + 8, target.fileId, true);
+			break;
+		case "byFileName": {
+			view.setUint16(offset, 4, true);
+			const strBytes = new TextEncoder().encode(target.fileName);
+			writePointer(bytes, offset + 8, strBytes.length);
+			bytes.set(strBytes, offset + 16);
+			return offset + 16 + align8(strBytes.length);
+		}
+		case "bootstrapInterface":
+			view.setUint16(offset, 5, true);
+			break;
+	}
+	return offset + 8;
+}
+/**
+* Read a SchemaTarget from binary format
+*/
+function readSchemaTarget(data, offset) {
+	const view = new DataView(data.buffer, data.byteOffset);
+	switch (view.getUint16(offset, true)) {
+		case 0: return {
+			value: { type: "allSchemas" },
+			nextOffset: offset + 8
+		};
+		case 1: return {
+			value: {
+				type: "byTypeId",
+				typeId: view.getBigUint64(offset + 8, true)
+			},
+			nextOffset: offset + 16
+		};
+		case 2: {
+			const strLen = readPointer(data, offset + 8);
+			const strBytes = data.slice(offset + 16, offset + 16 + strLen);
+			return {
+				value: {
+					type: "byTypeName",
+					typeName: new TextDecoder().decode(strBytes)
+				},
+				nextOffset: offset + 16 + align8(strLen)
+			};
+		}
+		case 3: return {
+			value: {
+				type: "byFileId",
+				fileId: view.getBigUint64(offset + 8, true)
+			},
+			nextOffset: offset + 16
+		};
+		case 4: {
+			const strLen = readPointer(data, offset + 8);
+			const strBytes = data.slice(offset + 16, offset + 16 + strLen);
+			return {
+				value: {
+					type: "byFileName",
+					fileName: new TextDecoder().decode(strBytes)
+				},
+				nextOffset: offset + 16 + align8(strLen)
+			};
+		}
+		case 5: return {
+			value: { type: "bootstrapInterface" },
+			nextOffset: offset + 8
+		};
+		default: return {
+			value: { type: "allSchemas" },
+			nextOffset: offset + 8
+		};
+	}
+}
+/**
+* Serialize a SchemaResponse to binary format
+*/
+function serializeSchemaResponse(response) {
+	const totalSize = 8 + getSchemaResponseResultSize(response.result);
+	const buffer = new ArrayBuffer(totalSize);
+	const view = new DataView(buffer);
+	const bytes = new Uint8Array(buffer);
+	view.setUint32(0, response.answerId, true);
+	writeSchemaResponseResult(bytes, 8, response.result);
+	return bytes;
+}
+/**
+* Deserialize a SchemaResponse from binary format
+*/
+function deserializeSchemaResponse(data) {
+	return {
+		answerId: new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0, true),
+		result: readSchemaResponseResult(data, 8).value
+	};
+}
+/**
+* Get the serialized size of a SchemaResponseResult
+*/
+function getSchemaResponseResultSize(result) {
+	switch (result.type) {
+		case "success": return 8 + getSchemaPayloadSize(result.payload);
+		case "exception": return 8 + getExceptionSize(result.exception);
+		default: return 8;
+	}
+}
+/**
+* Write a SchemaResponseResult to binary format
+*/
+function writeSchemaResponseResult(bytes, offset, result) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset);
+	switch (result.type) {
+		case "success":
+			view.setUint16(offset, 0, true);
+			return writeSchemaPayload(bytes, offset + 8, result.payload);
+		case "exception":
+			view.setUint16(offset, 1, true);
+			return writeException(bytes, offset + 8, result.exception);
+		default:
+			view.setUint16(offset, 0, true);
+			return offset + 8;
+	}
+}
+/**
+* Read a SchemaResponseResult from binary format
+*/
+function readSchemaResponseResult(data, offset) {
+	switch (new DataView(data.buffer, data.byteOffset).getUint16(offset, true)) {
+		case 0: {
+			const payload = readSchemaPayload(data, offset + 8);
+			return {
+				value: {
+					type: "success",
+					payload: payload.value
+				},
+				nextOffset: payload.nextOffset
+			};
+		}
+		case 1: {
+			const exception = readException(data, offset + 8);
+			return {
+				value: {
+					type: "exception",
+					exception: exception.value
+				},
+				nextOffset: exception.nextOffset
+			};
+		}
+		default: return {
+			value: {
+				type: "success",
+				payload: {
+					schemaData: new Uint8Array(),
+					format: SchemaFormat.BINARY,
+					dependencies: []
+				}
+			},
+			nextOffset: offset + 8
+		};
+	}
+}
+/**
+* Get the serialized size of a SchemaPayload
+*/
+function getSchemaPayloadSize(payload) {
+	let size = 32;
+	size += align8(payload.schemaData.length);
+	if (payload.sourceInfo) size += align8(payload.sourceInfo.length);
+	size += getSchemaDependenciesSize(payload.dependencies);
+	return size;
+}
+/**
+* Write a SchemaPayload to binary format
+*/
+function writeSchemaPayload(bytes, offset, payload) {
+	new DataView(bytes.buffer, bytes.byteOffset).setUint32(offset, payload.format, true);
+	let currentOffset = offset + 8;
+	writePointer(bytes, currentOffset, payload.schemaData.length);
+	currentOffset += 8;
+	bytes.set(payload.schemaData, currentOffset);
+	currentOffset += align8(payload.schemaData.length);
+	if (payload.sourceInfo) {
+		writePointer(bytes, currentOffset, payload.sourceInfo.length);
+		currentOffset += 8;
+		bytes.set(payload.sourceInfo, currentOffset);
+		currentOffset += align8(payload.sourceInfo.length);
+	} else {
+		writePointer(bytes, currentOffset, 0);
+		currentOffset += 8;
+	}
+	currentOffset = writeSchemaDependencies(bytes, currentOffset, payload.dependencies);
+	return currentOffset;
+}
+/**
+* Read a SchemaPayload from binary format
+*/
+function readSchemaPayload(data, offset) {
+	const format = new DataView(data.buffer, data.byteOffset).getUint32(offset, true);
+	let currentOffset = offset + 8;
+	const schemaDataLen = readPointer(data, currentOffset);
+	currentOffset += 8;
+	const schemaData = data.slice(currentOffset, currentOffset + schemaDataLen);
+	currentOffset += align8(schemaDataLen);
+	const sourceInfoLen = readPointer(data, currentOffset);
+	currentOffset += 8;
+	let sourceInfo;
+	if (sourceInfoLen > 0) {
+		sourceInfo = data.slice(currentOffset, currentOffset + sourceInfoLen);
+		currentOffset += align8(sourceInfoLen);
+	}
+	const deps = readSchemaDependencies(data, currentOffset);
+	return {
+		value: {
+			schemaData,
+			format,
+			sourceInfo,
+			dependencies: deps.value
+		},
+		nextOffset: deps.nextOffset
+	};
+}
+/**
+* Get the serialized size of SchemaDependency array
+*/
+function getSchemaDependenciesSize(deps) {
+	let size = 8;
+	for (const dep of deps) {
+		size += 32;
+		size += align8(dep.fileName.length + 1);
+		if (dep.schemaHash) size += align8(dep.schemaHash.length);
+	}
+	return size;
+}
+/**
+* Write SchemaDependency array to binary format
+*/
+function writeSchemaDependencies(bytes, offset, deps) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset);
+	writePointer(bytes, offset, deps.length);
+	let currentOffset = offset + 8;
+	for (const dep of deps) {
+		view.setBigUint64(currentOffset, dep.fileId, true);
+		currentOffset += 8;
+		const fileNameBytes = new TextEncoder().encode(`${dep.fileName}\0`);
+		writePointer(bytes, currentOffset, fileNameBytes.length);
+		currentOffset += 8;
+		bytes.set(fileNameBytes, currentOffset);
+		currentOffset += align8(fileNameBytes.length);
+		if (dep.schemaHash && dep.schemaHash.length > 0) {
+			writePointer(bytes, currentOffset, dep.schemaHash.length);
+			currentOffset += 8;
+			bytes.set(dep.schemaHash, currentOffset);
+			currentOffset += align8(dep.schemaHash.length);
+		} else {
+			writePointer(bytes, currentOffset, 0);
+			currentOffset += 8;
+		}
+	}
+	return currentOffset;
+}
+/**
+* Read SchemaDependency array from binary format
+*/
+function readSchemaDependencies(data, offset) {
+	const view = new DataView(data.buffer, data.byteOffset);
+	const count = readPointer(data, offset);
+	let currentOffset = offset + 8;
+	const deps = [];
+	for (let i = 0; i < count; i++) {
+		const fileId = view.getBigUint64(currentOffset, true);
+		currentOffset += 8;
+		const fileNameLen = readPointer(data, currentOffset);
+		currentOffset += 8;
+		const fileNameBytes = data.slice(currentOffset, currentOffset + fileNameLen);
+		const fileName = new TextDecoder().decode(fileNameBytes).replace(/\0$/, "");
+		currentOffset += align8(fileNameLen);
+		const schemaHashLen = readPointer(data, currentOffset);
+		currentOffset += 8;
+		let schemaHash;
+		if (schemaHashLen > 0) {
+			schemaHash = data.slice(currentOffset, currentOffset + schemaHashLen);
+			currentOffset += align8(schemaHashLen);
+		}
+		deps.push({
+			fileId,
+			fileName,
+			schemaHash
+		});
+	}
+	return {
+		value: deps,
+		nextOffset: currentOffset
+	};
+}
+/**
+* Get the serialized size of an Exception
+*/
+function getExceptionSize(exception) {
+	let size = 24;
+	size += align8(exception.reason.length);
+	return size;
+}
+/**
+* Write an Exception to binary format
+*/
+function writeException(bytes, offset, exception) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset);
+	const reasonBytes = new TextEncoder().encode(exception.reason);
+	writePointer(bytes, offset, reasonBytes.length);
+	bytes.set(reasonBytes, offset + 8);
+	let currentOffset = offset + 8 + align8(reasonBytes.length);
+	view.setUint16(currentOffset, exception.type, true);
+	currentOffset += 8;
+	view.setUint8(currentOffset, exception.obsoleteIsCallersFault ? 1 : 0);
+	view.setUint16(currentOffset + 1, exception.obsoleteDurability ?? 0, true);
+	currentOffset += 8;
+	return currentOffset;
+}
+/**
+* Read an Exception from binary format
+*/
+function readException(data, offset) {
+	const view = new DataView(data.buffer, data.byteOffset);
+	const reasonLen = readPointer(data, offset);
+	const reasonBytes = data.slice(offset + 8, offset + 8 + reasonLen);
+	const reason = new TextDecoder().decode(reasonBytes);
+	let currentOffset = offset + 8 + align8(reasonLen);
+	const type = view.getUint16(currentOffset, true);
+	currentOffset += 8;
+	const obsoleteIsCallersFault = view.getUint8(currentOffset) !== 0;
+	const obsoleteDurability = view.getUint16(currentOffset + 1, true);
+	currentOffset += 8;
+	return {
+		value: {
+			reason,
+			type,
+			obsoleteIsCallersFault,
+			obsoleteDurability
+		},
+		nextOffset: currentOffset
+	};
+}
+/**
+* Helper: Align size to 8-byte boundary
+*/
+function align8(size) {
+	return size + 7 & -8;
+}
+/**
+* Helper: Write a pointer (list/struct offset and size)
+*/
+function writePointer(bytes, offset, size) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset);
+	view.setUint32(offset, size, true);
+	view.setUint32(offset + 4, 0, true);
+}
+/**
+* Helper: Read a pointer
+*/
+function readPointer(data, offset) {
+	return new DataView(data.buffer, data.byteOffset).getUint32(offset, true);
+}
+/**
+* Serialize GetSchemaParams
+*/
+function serializeGetSchemaParams(params) {
+	const totalSize = 12 + getSchemaTargetSize(params.target);
+	const buffer = new ArrayBuffer(totalSize);
+	const view = new DataView(buffer);
+	const bytes = new Uint8Array(buffer);
+	view.setUint32(0, params.format ?? SchemaFormat.BINARY, true);
+	writeSchemaTarget(bytes, 8, params.target);
+	return bytes;
+}
+/**
+* Serialize GetSchemaResults
+*/
+function serializeGetSchemaResults(results) {
+	const totalSize = 8 + getSchemaPayloadSize(results.payload);
+	const buffer = new ArrayBuffer(totalSize);
+	const bytes = new Uint8Array(buffer);
+	writeSchemaPayload(bytes, 8, results.payload);
+	return bytes;
+}
+/**
+* Serialize ListSchemasResults
+*/
+function serializeListSchemasResults(results) {
+	let totalSize = 16;
+	for (const schema of results.schemas) {
+		totalSize += 32;
+		totalSize += align8(schema.displayName.length);
+		totalSize += align8(schema.fileName.length);
+	}
+	const buffer = new ArrayBuffer(totalSize);
+	const view = new DataView(buffer);
+	const bytes = new Uint8Array(buffer);
+	writePointer(bytes, 8, results.schemas.length);
+	let offset = 16;
+	for (const schema of results.schemas) {
+		view.setBigUint64(offset, schema.typeId, true);
+		offset += 8;
+		const displayNameBytes = new TextEncoder().encode(schema.displayName);
+		writePointer(bytes, offset, displayNameBytes.length);
+		offset += 8;
+		bytes.set(displayNameBytes, offset);
+		offset += align8(displayNameBytes.length);
+		view.setBigUint64(offset, schema.fileId, true);
+		offset += 8;
+		const fileNameBytes = new TextEncoder().encode(schema.fileName);
+		writePointer(bytes, offset, fileNameBytes.length);
+		offset += 8;
+		bytes.set(fileNameBytes, offset);
+		offset += align8(fileNameBytes.length);
+		let flags = 0;
+		if (schema.isInterface) flags |= 1;
+		if (schema.isStruct) flags |= 2;
+		if (schema.isEnum) flags |= 4;
+		view.setUint8(offset, flags);
+		offset += 8;
+	}
+	return bytes;
+}
+
+//#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;
+	schemaCache = /* @__PURE__ */ new Map();
+	schemaRegistry = createSchemaRegistry();
+	schemaQuestionIdCounter = 1e6;
+	schemaProvider;
+	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");
+	}
+	/**
+	* Get dynamic schema information for a type from the remote server.
+	* This allows runtime discovery of schema information for types not known at compile time.
+	*
+	* Results are cached to avoid repeated network requests for the same type.
+	*
+	* @param typeId - The unique type ID of the schema to fetch
+	* @returns The schema node for the requested type
+	* @throws Error if the schema cannot be fetched or parsed
+	*
+	* @example
+	* ```typescript
+	* const schema = await connection.getDynamicSchema(0x1234567890abcdefn);
+	* console.log('Struct fields:', schema.structInfo?.fields);
+	* ```
+	*/
+	async getDynamicSchema(typeId) {
+		const cached = this.schemaCache.get(typeId);
+		if (cached) return cached;
+		const registered = this.schemaRegistry.getNode(typeId);
+		if (registered) {
+			this.schemaCache.set(typeId, registered);
+			return registered;
+		}
+		const nodes = parseSchemaNodes((await this.fetchSchemaFromRemote({
+			type: "byTypeId",
+			typeId
+		})).schemaData);
+		for (const node of nodes) {
+			this.schemaRegistry.registerNode(node);
+			this.schemaCache.set(node.id, node);
+		}
+		const result = this.schemaRegistry.getNode(typeId);
+		if (!result) throw new Error(`Schema for type ${typeId.toString(16)} not found in response`);
+		return result;
+	}
+	/**
+	* Get dynamic schema by type name.
+	*
+	* @param typeName - The fully qualified type name (e.g., "foo.bar.MyStruct")
+	* @returns The schema node for the requested type
+	* @throws Error if the schema cannot be fetched or parsed
+	*/
+	async getDynamicSchemaByName(typeName) {
+		const registered = this.schemaRegistry.getNodeByName(typeName);
+		if (registered) {
+			this.schemaCache.set(registered.id, registered);
+			return registered;
+		}
+		const nodes = parseSchemaNodes((await this.fetchSchemaFromRemote({
+			type: "byTypeName",
+			typeName
+		})).schemaData);
+		for (const node of nodes) {
+			this.schemaRegistry.registerNode(node);
+			this.schemaCache.set(node.id, node);
+		}
+		const result = this.schemaRegistry.getNodeByName(typeName);
+		if (!result) throw new Error(`Schema for type "${typeName}" not found in response`);
+		return result;
+	}
+	/**
+	* Fetch schema information from the remote vat.
+	* This is an internal method used by getDynamicSchema.
+	*
+	* @param target - The schema target specification
+	* @returns The schema payload containing binary schema data
+	* @throws Error if the request fails
+	*/
+	async fetchSchemaFromRemote(target) {
+		if (!this.running) throw new Error("Connection is not running");
+		const questionId = this.schemaQuestionIdCounter++;
+		const requestData = serializeSchemaRequest({
+			questionId,
+			targetSchema: target
+		});
+		const schemaRequestMsg = {
+			type: "call",
+			call: {
+				questionId,
+				target: {
+					type: "importedCap",
+					importId: 0
+				},
+				interfaceId: BigInt("0x1234567890abcdef"),
+				methodId: 0,
+				allowThirdPartyTailCall: false,
+				noPromisePipelining: false,
+				onlyPromisePipeline: false,
+				params: {
+					content: requestData,
+					capTable: []
+				},
+				sendResultsTo: { type: "caller" }
+			}
+		};
+		await this.transport.send(schemaRequestMsg);
+		const question = this.questions.create();
+		question.id = questionId;
+		try {
+			const result = await question.completionPromise;
+			if (result && typeof result === "object" && "content" in result) {
+				const response = deserializeSchemaResponse(result.content);
+				if (response.result.type === "success") return response.result.payload;
+				throw new Error(`Schema request failed: ${response.result.exception.reason}`);
+			}
+			throw new Error("Invalid schema response format");
+		} catch (error) {
+			this.questions.remove(questionId);
+			throw error;
+		}
+	}
+	/**
+	* Get the schema registry for this connection.
+	* The registry contains all schemas that have been fetched or registered.
+	*
+	* @returns The schema registry
+	*/
+	getSchemaRegistry() {
+		return this.schemaRegistry;
+	}
+	/**
+	* Register a schema node locally.
+	* This can be used to pre-populate the schema cache or add custom schemas.
+	*
+	* @param node - The schema node to register
+	*/
+	registerSchema(node) {
+		this.schemaRegistry.registerNode(node);
+		this.schemaCache.set(node.id, node);
+	}
+	/**
+	* Clear the schema cache.
+	* This forces subsequent getDynamicSchema calls to fetch from the remote server.
+	*/
+	clearSchemaCache() {
+		this.schemaCache.clear();
+	}
+	/**
+	* Check if a schema is cached locally.
+	*
+	* @param typeId - The type ID to check
+	* @returns True if the schema is in the cache
+	*/
+	hasCachedSchema(typeId) {
+		return this.schemaCache.has(typeId) || this.schemaRegistry.hasNode(typeId);
+	}
+	/**
+	* Register a schema provider for serving schema requests.
+	* This allows the connection to respond to schema requests from remote peers.
+	*
+	* @param provider - The schema capability server to register
+	*/
+	registerSchemaProvider(provider) {
+		this.schemaProvider = provider;
+	}
+	/**
+	* List all available schemas from the remote vat.
+	* This requires the remote to support the schema listing capability.
+	*
+	* @returns Array of available schema information
+	* @throws Error if the request fails or is not supported
+	*/
+	async listAvailableSchemas() {
+		if (!this.running) throw new Error("Connection is not running");
+		const questionId = this.schemaQuestionIdCounter++;
+		const requestData = serializeSchemaRequest({
+			questionId,
+			targetSchema: { type: "allSchemas" }
+		});
+		const listRequestMsg = {
+			type: "call",
+			call: {
+				questionId,
+				target: {
+					type: "importedCap",
+					importId: 0
+				},
+				interfaceId: BigInt("0x1234567890abcdef"),
+				methodId: 1,
+				allowThirdPartyTailCall: false,
+				noPromisePipelining: false,
+				onlyPromisePipeline: false,
+				params: {
+					content: requestData,
+					capTable: []
+				},
+				sendResultsTo: { type: "caller" }
+			}
+		};
+		await this.transport.send(listRequestMsg);
+		const question = this.questions.create();
+		question.id = questionId;
+		try {
+			const result = await question.completionPromise;
+			if (result && typeof result === "object" && "content" in result) {
+				const response = deserializeSchemaResponse(result.content);
+				if (response.result.type === "success") return parseSchemaNodes(response.result.payload.schemaData).map((node) => ({
+					typeId: node.id,
+					displayName: node.displayName
+				}));
+				throw new Error(`List schemas failed: ${response.result.exception.reason}`);
+			}
+			throw new Error("Invalid list schemas response format");
+		} catch (error) {
+			this.questions.remove(questionId);
+			throw error;
+		}
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'AnswerTable', {
+  enumerable: true,
+  get: function () {
+    return AnswerTable;
+  }
+});
+Object.defineProperty(exports, 'ExportTable', {
+  enumerable: true,
+  get: function () {
+    return ExportTable;
+  }
+});
+Object.defineProperty(exports, 'ImportTable', {
+  enumerable: true,
+  get: function () {
+    return ImportTable;
+  }
+});
+Object.defineProperty(exports, 'PIPELINE_CLIENT_SYMBOL', {
+  enumerable: true,
+  get: function () {
+    return PIPELINE_CLIENT_SYMBOL;
+  }
+});
+Object.defineProperty(exports, 'PipelineOpTracker', {
+  enumerable: true,
+  get: function () {
+    return PipelineOpTracker;
+  }
+});
+Object.defineProperty(exports, 'PipelineResolutionTracker', {
+  enumerable: true,
+  get: function () {
+    return PipelineResolutionTracker;
+  }
+});
+Object.defineProperty(exports, 'QuestionTable', {
+  enumerable: true,
+  get: function () {
+    return QuestionTable;
+  }
+});
+Object.defineProperty(exports, 'QueuedCallManager', {
+  enumerable: true,
+  get: function () {
+    return QueuedCallManager;
+  }
+});
+Object.defineProperty(exports, 'RpcConnection', {
+  enumerable: true,
+  get: function () {
+    return RpcConnection;
+  }
+});
+Object.defineProperty(exports, 'SCHEMA_MESSAGE_TYPES', {
+  enumerable: true,
+  get: function () {
+    return SCHEMA_MESSAGE_TYPES;
+  }
+});
+Object.defineProperty(exports, 'SchemaFormat', {
+  enumerable: true,
+  get: function () {
+    return SchemaFormat;
+  }
+});
+Object.defineProperty(exports, 'SchemaNodeType', {
+  enumerable: true,
+  get: function () {
+    return SchemaNodeType;
+  }
+});
+Object.defineProperty(exports, 'createPipelineClient', {
+  enumerable: true,
+  get: function () {
+    return createPipelineClient;
+  }
+});
+Object.defineProperty(exports, 'createSchemaRegistry', {
+  enumerable: true,
+  get: function () {
+    return createSchemaRegistry;
+  }
+});
+Object.defineProperty(exports, 'deserializeSchemaRequest', {
+  enumerable: true,
+  get: function () {
+    return deserializeSchemaRequest;
+  }
+});
+Object.defineProperty(exports, 'deserializeSchemaResponse', {
+  enumerable: true,
+  get: function () {
+    return deserializeSchemaResponse;
+  }
+});
+Object.defineProperty(exports, 'isPipelineClient', {
+  enumerable: true,
+  get: function () {
+    return isPipelineClient;
+  }
+});
+Object.defineProperty(exports, 'parseSchemaNodes', {
+  enumerable: true,
+  get: function () {
+    return parseSchemaNodes;
+  }
+});
+Object.defineProperty(exports, 'serializeGetSchemaParams', {
+  enumerable: true,
+  get: function () {
+    return serializeGetSchemaParams;
+  }
+});
+Object.defineProperty(exports, 'serializeGetSchemaResults', {
+  enumerable: true,
+  get: function () {
+    return serializeGetSchemaResults;
+  }
+});
+Object.defineProperty(exports, 'serializeListSchemasResults', {
+  enumerable: true,
+  get: function () {
+    return serializeListSchemasResults;
+  }
+});
+Object.defineProperty(exports, 'serializeSchemaRequest', {
+  enumerable: true,
+  get: function () {
+    return serializeSchemaRequest;
+  }
+});
+Object.defineProperty(exports, 'serializeSchemaResponse', {
+  enumerable: true,
+  get: function () {
+    return serializeSchemaResponse;
+  }
+});
+//# sourceMappingURL=rpc-connection-_eHtWsk2.js.map