@naeemo/capnp 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_rpc_connection = require('./rpc-connection-BKWQQ7f9.js');
+const require_rpc_connection = require('./rpc-connection-CnyIwb0Z.js');
 
 //#region src/core/pointer.ts
 /**
@@ -2306,7 +2306,7 @@ var ConnectionManager = class {
 		}
 	}
 	async doEstablishConnection(vatId, address) {
-		const { RpcConnection } = await Promise.resolve().then(() => require("./rpc-connection-BKWQQ7f9.js")).then((n) => n.rpc_connection_exports);
+		const { RpcConnection } = await Promise.resolve().then(() => require("./rpc-connection-CnyIwb0Z.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);
@@ -4901,6 +4901,934 @@ function supportsStreaming(connection) {
 	return connection instanceof StreamingRpcConnection;
 }
 
+//#endregion
+//#region src/rpc/dynamic-reader.ts
+/**
+* Create a dynamic reader from schema and buffer
+*
+* @param schema - The schema node describing the struct type
+* @param buffer - The Cap'n Proto message buffer
+* @returns A DynamicReader for accessing the message fields
+*/
+function createDynamicReader(schema, buffer) {
+	const messageReader = new MessageReader(buffer);
+	if (!schema.structInfo) throw new Error(`Schema node ${schema.displayName} is not a struct`);
+	const { dataWordCount, pointerCount } = schema.structInfo;
+	return new DynamicReaderImpl(schema, messageReader.getRoot(dataWordCount, pointerCount), messageReader);
+}
+/**
+* Create a dynamic reader from an existing StructReader
+*
+* @param schema - The schema node describing the struct type
+* @param structReader - The StructReader to wrap
+* @param messageReader - The underlying MessageReader
+* @returns A DynamicReader for accessing the message fields
+*/
+function createDynamicReaderFromStruct(schema, structReader, messageReader) {
+	return new DynamicReaderImpl(schema, structReader, messageReader);
+}
+/**
+* Implementation of DynamicReader
+*/
+var DynamicReaderImpl = class {
+	fieldCache;
+	pointerOffset;
+	constructor(schema, structReader, messageReader) {
+		this.schema = schema;
+		this.structReader = structReader;
+		this.messageReader = messageReader;
+		this.fieldCache = /* @__PURE__ */ new Map();
+		this.pointerOffset = schema.structInfo?.dataWordCount ?? 0;
+		if (schema.structInfo?.fields) for (const field of schema.structInfo.fields) this.fieldCache.set(field.name, field);
+	}
+	get(fieldName) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		return this.readFieldValue(field);
+	}
+	has(fieldName) {
+		return this.fieldCache.has(fieldName);
+	}
+	getFieldNames() {
+		return Array.from(this.fieldCache.keys());
+	}
+	getSchema() {
+		return this.schema;
+	}
+	getStruct(fieldName) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) return;
+		if (field.type.kind.type !== "struct") return;
+		const pointerIndex = this.getPointerIndex(field);
+		const nestedStruct = this.structReader.getStruct(pointerIndex, 0, 0);
+		if (!nestedStruct) return;
+		return new DynamicStructReaderWithoutSchema(nestedStruct, this.messageReader);
+	}
+	getList(fieldName) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) return;
+		if (field.type.kind.type !== "list") return;
+		const pointerIndex = this.getPointerIndex(field);
+		const elementType = field.type.kind.elementType;
+		return this.readListField(pointerIndex, elementType);
+	}
+	getRawReader() {
+		return this.structReader;
+	}
+	/**
+	* Read a field value based on its type
+	*/
+	readFieldValue(field) {
+		const kind = field.type.kind;
+		switch (kind.type) {
+			case "void": return;
+			case "bool": return this.structReader.getBool(field.offset);
+			case "int8": return this.structReader.getInt8(field.offset);
+			case "int16": return this.structReader.getInt16(field.offset);
+			case "int32": return this.structReader.getInt32(field.offset);
+			case "int64": return this.structReader.getInt64(field.offset);
+			case "uint8": return this.structReader.getUint8(field.offset);
+			case "uint16": return this.structReader.getUint16(field.offset);
+			case "uint32": return this.structReader.getUint32(field.offset);
+			case "uint64": return this.structReader.getUint64(field.offset);
+			case "float32": return this.structReader.getFloat32(field.offset);
+			case "float64": return this.structReader.getFloat64(field.offset);
+			case "text": return this.readTextField(field);
+			case "data": return this.readDataField(field);
+			case "list": return this.readListFieldBySchema(field);
+			case "enum": return this.readEnumField(field);
+			case "struct": return this.readStructField(field);
+			case "interface": return this.readInterfaceField(field);
+			case "anyPointer": return this.readAnyPointerField(field);
+			default: throw new Error(`Unsupported field type: ${kind.type}`);
+		}
+	}
+	/**
+	* Get the pointer index for a field
+	* In Cap'n Proto, pointer fields have offsets that start from 0 for the first pointer
+	* The offset is measured in bits from the start of the data section
+	* For pointer fields, offset = dataWordCount * 64 + pointerIndex * 64
+	* So pointerIndex = (offset - dataWordCount * 64) / 64
+	*/
+	getPointerIndex(field) {
+		const dataSectionBits = (this.schema.structInfo?.dataWordCount ?? 0) * 64;
+		return (field.offset - dataSectionBits) / 64;
+	}
+	/**
+	* Read a text field
+	*/
+	readTextField(field) {
+		const pointerIndex = this.getPointerIndex(field);
+		return this.structReader.getText(pointerIndex);
+	}
+	/**
+	* Read a data field
+	*/
+	readDataField(field) {
+		const pointerIndex = this.getPointerIndex(field);
+		const text = this.structReader.getText(pointerIndex);
+		return new TextEncoder().encode(text);
+	}
+	/**
+	* Read a list field using schema information
+	*/
+	readListFieldBySchema(field) {
+		if (field.type.kind.type !== "list") throw new Error(`Field '${field.name}' is not a list type`);
+		const pointerIndex = this.getPointerIndex(field);
+		const elementType = field.type.kind.elementType;
+		return this.readListField(pointerIndex, elementType);
+	}
+	/**
+	* Read a list field
+	*/
+	readListField(pointerIndex, elementType) {
+		const elementSize = this.mapTypeToElementSize(elementType);
+		const listReader = this.structReader.getList(pointerIndex, elementSize);
+		if (!listReader) return [];
+		const result = [];
+		const length = listReader.length;
+		for (let i = 0; i < length; i++) result.push(this.readListElement(listReader, i, elementType));
+		return result;
+	}
+	/**
+	* Map schema type to ElementSize
+	*/
+	mapTypeToElementSize(type) {
+		switch (type.kind.type) {
+			case "void": return ElementSize.VOID;
+			case "bool": return ElementSize.BIT;
+			case "int8":
+			case "uint8": return ElementSize.BYTE;
+			case "int16":
+			case "uint16": return ElementSize.TWO_BYTES;
+			case "int32":
+			case "uint32":
+			case "float32": return ElementSize.FOUR_BYTES;
+			case "int64":
+			case "uint64":
+			case "float64": return ElementSize.EIGHT_BYTES;
+			case "struct": return ElementSize.COMPOSITE;
+			default: return ElementSize.POINTER;
+		}
+	}
+	/**
+	* Read a single list element
+	*/
+	readListElement(listReader, index, elementType) {
+		switch (elementType.kind.type) {
+			case "void": return;
+			case "bool": return listReader.getPrimitive(index) !== 0;
+			case "int8": return listReader.getPrimitive(index);
+			case "int16": return listReader.getPrimitive(index);
+			case "int32": return listReader.getPrimitive(index);
+			case "int64": return listReader.getPrimitive(index);
+			case "uint8": return listReader.getPrimitive(index);
+			case "uint16": return listReader.getPrimitive(index);
+			case "uint32": return listReader.getPrimitive(index);
+			case "uint64": return listReader.getPrimitive(index);
+			case "float32": return listReader.getPrimitive(index);
+			case "float64": return listReader.getPrimitive(index);
+			case "struct": {
+				const structReader = listReader.getStruct(index);
+				if (!structReader) return void 0;
+				return new DynamicStructReaderWithoutSchema(structReader, this.messageReader);
+			}
+			default: return;
+		}
+	}
+	/**
+	* Read an enum field
+	*/
+	readEnumField(field) {
+		return this.structReader.getUint16(field.offset);
+	}
+	/**
+	* Read a struct field
+	*/
+	readStructField(field) {
+		const pointerIndex = this.getPointerIndex(field);
+		const nestedStruct = this.structReader.getStruct(pointerIndex, 0, 0);
+		if (!nestedStruct) return;
+		return new DynamicStructReaderWithoutSchema(nestedStruct, this.messageReader);
+	}
+	/**
+	* Read an interface field (capability)
+	*/
+	readInterfaceField(_field) {
+		throw new Error("Interface fields not yet supported in dynamic reader");
+	}
+	/**
+	* Read an anyPointer field
+	*/
+	readAnyPointerField(_field) {
+		throw new Error("anyPointer fields not yet supported in dynamic reader");
+	}
+};
+/**
+* A limited dynamic reader for structs without schema information
+* Provides basic field access but no type information
+*/
+var DynamicStructReaderWithoutSchema = class {
+	constructor(structReader, messageReader) {
+		this.structReader = structReader;
+		this.messageReader = messageReader;
+	}
+	get(_fieldName) {
+		throw new Error("Cannot access fields without schema information");
+	}
+	has(_fieldName) {
+		return false;
+	}
+	getFieldNames() {
+		return [];
+	}
+	getSchema() {
+		throw new Error("No schema information available");
+	}
+	getStruct(_fieldName) {}
+	getList(_fieldName) {}
+	getRawReader() {
+		return this.structReader;
+	}
+};
+/**
+* Create a dynamic reader for a specific type ID
+* This looks up the schema in a registry and creates the appropriate reader
+*
+* @param typeId - The type ID of the struct
+* @param buffer - The Cap'n Proto message buffer
+* @param schemaRegistry - A map of type IDs to schema nodes
+* @returns A DynamicReader for the message
+*/
+function createDynamicReaderByTypeId(typeId, buffer, schemaRegistry) {
+	const schema = schemaRegistry.get(typeId);
+	if (!schema) throw new Error(`Schema not found for type ID: ${typeId}`);
+	if (schema.type !== require_rpc_connection.SchemaNodeType.STRUCT) throw new Error(`Type ${typeId} is not a struct`);
+	return createDynamicReader(schema, buffer);
+}
+/**
+* Utility function to dump all fields from a dynamic reader
+* Useful for debugging and exploration
+*
+* @param reader - The DynamicReader to dump
+* @returns An object with all field names and values
+*/
+function dumpDynamicReader(reader) {
+	const result = {};
+	for (const fieldName of reader.getFieldNames()) try {
+		result[fieldName] = reader.get(fieldName);
+	} catch (error) {
+		result[fieldName] = `<error: ${error}>`;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/rpc/dynamic-writer.ts
+/**
+* Create a dynamic writer from schema
+*
+* @param schema - The schema node describing the struct type
+* @returns A DynamicWriter for setting message fields
+*/
+function createDynamicWriter(schema) {
+	if (!schema.structInfo) throw new Error(`Schema node ${schema.displayName} is not a struct`);
+	const { dataWordCount, pointerCount } = schema.structInfo;
+	const messageBuilder = new MessageBuilder();
+	return new DynamicWriterImpl(schema, messageBuilder.initRoot(dataWordCount, pointerCount), messageBuilder);
+}
+/**
+* Create a dynamic writer for a nested struct
+*
+* @param schema - The schema node describing the struct type
+* @param structBuilder - The StructBuilder to wrap
+* @param messageBuilder - The underlying MessageBuilder
+* @returns A DynamicWriter for setting message fields
+*/
+function createNestedDynamicWriter(schema, structBuilder, messageBuilder) {
+	return new DynamicWriterImpl(schema, structBuilder, messageBuilder);
+}
+/**
+* Implementation of DynamicWriter
+*/
+var DynamicWriterImpl = class {
+	fieldCache;
+	pointerOffset;
+	constructor(schema, structBuilder, messageBuilder) {
+		this.schema = schema;
+		this.structBuilder = structBuilder;
+		this.messageBuilder = messageBuilder;
+		this.fieldCache = /* @__PURE__ */ new Map();
+		this.pointerOffset = schema.structInfo?.dataWordCount ?? 0;
+		if (schema.structInfo?.fields) for (const field of schema.structInfo.fields) this.fieldCache.set(field.name, field);
+	}
+	set(fieldName, value) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		this.writeFieldValue(field, value);
+	}
+	setFields(fields) {
+		for (const [name, value] of Object.entries(fields)) this.set(name, value);
+	}
+	initStruct(fieldName) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		if (field.type.kind.type !== "struct") throw new Error(`Field '${fieldName}' is not a struct type`);
+		const pointerIndex = this.getPointerIndex(field);
+		return new DynamicWriterWithoutSchema(this.structBuilder.initStruct(pointerIndex, 0, 0), this.messageBuilder);
+	}
+	initList(fieldName, size) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		if (field.type.kind.type !== "list") throw new Error(`Field '${fieldName}' is not a list type`);
+		const pointerIndex = this.getPointerIndex(field);
+		const elementType = field.type.kind.elementType;
+		return this.createListWriter(pointerIndex, size, elementType);
+	}
+	setText(fieldName, value) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		if (field.type.kind.type !== "text") throw new Error(`Field '${fieldName}' is not a text type`);
+		const pointerIndex = this.getPointerIndex(field);
+		this.structBuilder.setText(pointerIndex, value);
+	}
+	setData(fieldName, value) {
+		const field = this.fieldCache.get(fieldName);
+		if (!field) throw new Error(`Field '${fieldName}' not found in schema ${this.schema.displayName}`);
+		if (field.type.kind.type !== "data") throw new Error(`Field '${fieldName}' is not a data type`);
+		const pointerIndex = this.getPointerIndex(field);
+		const textValue = new TextDecoder().decode(value);
+		this.structBuilder.setText(pointerIndex, `${textValue}\0`);
+	}
+	getSchema() {
+		return this.schema;
+	}
+	getRawBuilder() {
+		return this.structBuilder;
+	}
+	toBuffer() {
+		return this.messageBuilder.toArrayBuffer();
+	}
+	/**
+	* Write a field value based on its type
+	*/
+	writeFieldValue(field, value) {
+		const kind = field.type.kind;
+		switch (kind.type) {
+			case "void": break;
+			case "bool":
+				this.structBuilder.setBool(field.offset, Boolean(value));
+				break;
+			case "int8":
+				this.structBuilder.setInt8(field.offset, Number(value));
+				break;
+			case "int16":
+				this.structBuilder.setInt16(field.offset, Number(value));
+				break;
+			case "int32":
+				this.structBuilder.setInt32(field.offset, Number(value));
+				break;
+			case "int64":
+				this.structBuilder.setInt64(field.offset, BigInt(value));
+				break;
+			case "uint8":
+				this.structBuilder.setUint8(field.offset, Number(value));
+				break;
+			case "uint16":
+				this.structBuilder.setUint16(field.offset, Number(value));
+				break;
+			case "uint32":
+				this.structBuilder.setUint32(field.offset, Number(value));
+				break;
+			case "uint64":
+				this.structBuilder.setUint64(field.offset, BigInt(value));
+				break;
+			case "float32":
+				this.structBuilder.setFloat32(field.offset, Number(value));
+				break;
+			case "float64":
+				this.structBuilder.setFloat64(field.offset, Number(value));
+				break;
+			case "text":
+				this.setText(field.name, String(value));
+				break;
+			case "data":
+				if (value instanceof Uint8Array) this.setData(field.name, value);
+				else throw new Error(`Field '${field.name}' expects Uint8Array`);
+				break;
+			case "list":
+				if (Array.isArray(value)) this.initList(field.name, value.length).setAll(value);
+				else throw new Error(`Field '${field.name}' expects an array`);
+				break;
+			case "enum":
+				this.structBuilder.setUint16(field.offset, Number(value));
+				break;
+			case "struct":
+				if (typeof value === "object" && value !== null) {
+					const structWriter = this.initStruct(field.name);
+					if (!(value instanceof Uint8Array) && !Array.isArray(value)) structWriter.setFields(value);
+				} else throw new Error(`Field '${field.name}' expects an object`);
+				break;
+			case "interface": throw new Error("Interface fields not yet supported in dynamic writer");
+			case "anyPointer": throw new Error("anyPointer fields not yet supported in dynamic writer");
+			default: throw new Error(`Unsupported field type: ${kind.type}`);
+		}
+	}
+	/**
+	* Get the pointer index for a field
+	* In Cap'n Proto, pointer fields have offsets that start from 0 for the first pointer
+	* The offset is measured in bits from the start of the data section
+	* For pointer fields, offset = dataWordCount * 64 + pointerIndex * 64
+	* So pointerIndex = (offset - dataWordCount * 64) / 64
+	*/
+	getPointerIndex(field) {
+		const dataSectionBits = (this.schema.structInfo?.dataWordCount ?? 0) * 64;
+		return (field.offset - dataSectionBits) / 64;
+	}
+	/**
+	* Create a list writer for a field
+	*/
+	createListWriter(pointerIndex, size, elementType) {
+		const elementSize = this.mapTypeToElementSize(elementType);
+		let structSize;
+		if (elementSize === ElementSize.COMPOSITE) structSize = {
+			dataWords: 0,
+			pointerCount: 0
+		};
+		return new DynamicListWriterImpl(this.structBuilder.initList(pointerIndex, elementSize, size, structSize), elementType, this.messageBuilder);
+	}
+	/**
+	* Map schema type to ElementSize
+	*/
+	mapTypeToElementSize(type) {
+		switch (type.kind.type) {
+			case "void": return ElementSize.VOID;
+			case "bool": return ElementSize.BIT;
+			case "int8":
+			case "uint8": return ElementSize.BYTE;
+			case "int16":
+			case "uint16": return ElementSize.TWO_BYTES;
+			case "int32":
+			case "uint32":
+			case "float32": return ElementSize.FOUR_BYTES;
+			case "int64":
+			case "uint64":
+			case "float64": return ElementSize.EIGHT_BYTES;
+			case "struct": return ElementSize.COMPOSITE;
+			default: return ElementSize.POINTER;
+		}
+	}
+};
+/**
+* Implementation of DynamicListWriter
+*/
+var DynamicListWriterImpl = class {
+	constructor(listBuilder, elementType, messageBuilder) {
+		this.listBuilder = listBuilder;
+		this.elementType = elementType;
+		this.messageBuilder = messageBuilder;
+	}
+	set(index, value) {
+		if (index < 0 || index >= this.listBuilder.length) throw new Error(`Index ${index} out of bounds`);
+		const kind = this.elementType.kind;
+		switch (kind.type) {
+			case "void": break;
+			case "bool":
+				this.listBuilder.setPrimitive(index, value ? 1 : 0);
+				break;
+			case "int8":
+			case "uint8":
+			case "int16":
+			case "uint16":
+			case "int32":
+			case "uint32":
+			case "float32":
+				this.listBuilder.setPrimitive(index, Number(value));
+				break;
+			case "int64":
+			case "uint64":
+			case "float64":
+				this.listBuilder.setPrimitive(index, BigInt(value));
+				break;
+			case "struct":
+				if (typeof value === "object" && value !== null && !(value instanceof Uint8Array)) this.initStruct(index).setFields(value);
+				break;
+			default: throw new Error(`Unsupported list element type: ${kind.type}`);
+		}
+	}
+	getSize() {
+		return this.listBuilder.length;
+	}
+	getLength() {
+		return this.listBuilder.length;
+	}
+	initStruct(index) {
+		return new DynamicWriterWithoutSchema(this.listBuilder.getStruct(index), this.messageBuilder);
+	}
+	setAll(values) {
+		if (values.length > this.getSize()) throw new Error(`Cannot set ${values.length} values in list of size ${this.getSize()}`);
+		for (let i = 0; i < values.length; i++) this.set(i, values[i]);
+	}
+};
+/**
+* A limited dynamic writer for structs without full schema information
+* Provides basic field setting but no type validation
+*/
+var DynamicWriterWithoutSchema = class {
+	constructor(structBuilder, messageBuilder) {
+		this.structBuilder = structBuilder;
+		this.messageBuilder = messageBuilder;
+	}
+	set(fieldName, _value) {
+		throw new Error(`Cannot set field '${fieldName}' without schema information`);
+	}
+	setFields(_fields) {
+		throw new Error("Cannot set fields without schema information");
+	}
+	initStruct(_fieldName) {
+		throw new Error("Cannot init struct without schema information");
+	}
+	initList(_fieldName, _size) {
+		throw new Error("Cannot init list without schema information");
+	}
+	setText(_fieldName, _value) {
+		throw new Error("Cannot set text without schema information");
+	}
+	setData(_fieldName, _value) {
+		throw new Error("Cannot set data without schema information");
+	}
+	getSchema() {
+		throw new Error("No schema information available");
+	}
+	getRawBuilder() {
+		return this.structBuilder;
+	}
+	toBuffer() {
+		return this.messageBuilder.toArrayBuffer();
+	}
+};
+/**
+* Create a dynamic writer for a specific type ID
+* This looks up the schema in a registry and creates the appropriate writer
+*
+* @param typeId - The type ID of the struct
+* @param schemaRegistry - A map of type IDs to schema nodes
+* @returns A DynamicWriter for the message
+*/
+function createDynamicWriterByTypeId(typeId, schemaRegistry) {
+	const schema = schemaRegistry.get(typeId);
+	if (!schema) throw new Error(`Schema not found for type ID: ${typeId}`);
+	if (schema.type !== require_rpc_connection.SchemaNodeType.STRUCT) throw new Error(`Type ${typeId} is not a struct`);
+	return createDynamicWriter(schema);
+}
+/**
+* Utility function to create a message from a plain object
+* Uses schema information to properly serialize the data
+*
+* @param schema - The schema node describing the struct type
+* @param data - The data object to serialize
+* @returns The serialized message buffer
+*/
+function serializeDynamic(schema, data) {
+	const writer = createDynamicWriter(schema);
+	writer.setFields(data);
+	return writer.toBuffer();
+}
+/**
+* Utility function to create a message from a plain object using type ID
+*
+* @param typeId - The type ID of the struct
+* @param data - The data object to serialize
+* @param schemaRegistry - A map of type IDs to schema nodes
+* @returns The serialized message buffer
+*/
+function serializeDynamicByTypeId(typeId, data, schemaRegistry) {
+	const writer = createDynamicWriterByTypeId(typeId, schemaRegistry);
+	writer.setFields(data);
+	return writer.toBuffer();
+}
+
+//#endregion
+//#region src/rpc/schema-capability.ts
+/**
+* Server-side implementation of the SchemaCapability interface.
+* Provides schema information to remote clients.
+*/
+var SchemaCapabilityServer = class {
+	registry;
+	schemasByName;
+	/**
+	* Create a new SchemaCapabilityServer
+	* @param initialSchemas - Optional map of schemas to register initially
+	*/
+	constructor(initialSchemas) {
+		this.registry = new Map(initialSchemas);
+		this.schemasByName = /* @__PURE__ */ new Map();
+		for (const schema of this.registry.values()) this.schemasByName.set(schema.displayName, schema);
+	}
+	/**
+	* Register a schema node
+	* @param node - The schema node to register
+	*/
+	registerSchema(node) {
+		this.registry.set(node.id, node);
+		this.schemasByName.set(node.displayName, node);
+	}
+	/**
+	* Unregister a schema by ID
+	* @param typeId - The type ID to unregister
+	*/
+	unregisterSchema(typeId) {
+		const node = this.registry.get(typeId);
+		if (node) {
+			this.registry.delete(typeId);
+			this.schemasByName.delete(node.displayName);
+		}
+	}
+	/**
+	* Get schema information based on target specification
+	* @param params - GetSchemaParams containing target and format
+	* @returns GetSchemaResults with the schema payload
+	*/
+	async getSchema(params) {
+		const { target, format = require_rpc_connection.SchemaFormat.BINARY } = params;
+		let schemaData;
+		let dependencies = [];
+		switch (target.type) {
+			case "byTypeId": {
+				const node = this.registry.get(target.typeId);
+				if (!node) throw new Error(`Schema not found for type ID: ${target.typeId.toString(16)}`);
+				schemaData = this.serializeSchemaNode(node, format);
+				dependencies = this.collectDependencies(node);
+				break;
+			}
+			case "byTypeName": {
+				const node = this.schemasByName.get(target.typeName);
+				if (!node) throw new Error(`Schema not found for type name: ${target.typeName}`);
+				schemaData = this.serializeSchemaNode(node, format);
+				dependencies = this.collectDependencies(node);
+				break;
+			}
+			case "byFileId": {
+				const nodes = this.getSchemasByFileId(target.fileId);
+				schemaData = this.serializeSchemaNodes(nodes, format);
+				break;
+			}
+			case "byFileName": {
+				const nodes = this.getSchemasByFileName(target.fileName);
+				schemaData = this.serializeSchemaNodes(nodes, format);
+				break;
+			}
+			case "allSchemas": {
+				const nodes = Array.from(this.registry.values());
+				schemaData = this.serializeSchemaNodes(nodes, format);
+				break;
+			}
+			case "bootstrapInterface": {
+				const bootstrapSchema = this.findBootstrapSchema();
+				if (!bootstrapSchema) throw new Error("Bootstrap interface schema not available");
+				schemaData = this.serializeSchemaNode(bootstrapSchema, format);
+				dependencies = this.collectDependencies(bootstrapSchema);
+				break;
+			}
+			default: throw new Error(`Unsupported schema target type: ${target.type}`);
+		}
+		return { payload: {
+			schemaData,
+			format,
+			dependencies
+		} };
+	}
+	/**
+	* List all available schemas
+	* @returns ListSchemasResults with available schema information
+	*/
+	async listAvailableSchemas() {
+		const schemas = [];
+		for (const node of this.registry.values()) schemas.push({
+			typeId: node.id,
+			displayName: node.displayName,
+			fileId: node.scopeId,
+			fileName: this.inferFileName(node),
+			isInterface: node.type === require_rpc_connection.SchemaNodeType.INTERFACE,
+			isStruct: node.type === require_rpc_connection.SchemaNodeType.STRUCT,
+			isEnum: node.type === require_rpc_connection.SchemaNodeType.ENUM
+		});
+		return { schemas };
+	}
+	/**
+	* Handle a raw schema request (for RPC integration)
+	* @param requestData - The serialized SchemaRequest
+	* @returns The serialized SchemaResponse
+	*/
+	handleRequest(requestData) {
+		try {
+			const request = require_rpc_connection.deserializeSchemaRequest(requestData);
+			this.getSchema({ target: request.targetSchema });
+			throw new Error("Async handling not implemented in handleRequest");
+		} catch (error) {
+			return require_rpc_connection.serializeSchemaResponse({
+				answerId: 0,
+				result: {
+					type: "exception",
+					exception: {
+						reason: error instanceof Error ? error.message : "Unknown error",
+						type: "failed",
+						obsoleteIsCallersFault: false,
+						obsoleteDurability: 0
+					}
+				}
+			});
+		}
+	}
+	/**
+	* Get the number of registered schemas
+	*/
+	getSchemaCount() {
+		return this.registry.size;
+	}
+	/**
+	* Check if a schema is registered
+	*/
+	hasSchema(typeId) {
+		return this.registry.has(typeId);
+	}
+	serializeSchemaNode(node, format) {
+		switch (format) {
+			case require_rpc_connection.SchemaFormat.BINARY: return this.serializeToBinary([node]);
+			case require_rpc_connection.SchemaFormat.JSON: return this.serializeToJson([node]);
+			case require_rpc_connection.SchemaFormat.CAPNP: return this.serializeToCapnp([node]);
+			default: throw new Error(`Unsupported schema format: ${format}`);
+		}
+	}
+	serializeSchemaNodes(nodes, format) {
+		switch (format) {
+			case require_rpc_connection.SchemaFormat.BINARY: return this.serializeToBinary(nodes);
+			case require_rpc_connection.SchemaFormat.JSON: return this.serializeToJson(nodes);
+			case require_rpc_connection.SchemaFormat.CAPNP: return this.serializeToCapnp(nodes);
+			default: throw new Error(`Unsupported schema format: ${format}`);
+		}
+	}
+	serializeToBinary(nodes) {
+		const encoder = new TextEncoder();
+		const json = JSON.stringify(nodes, (_key, value) => {
+			if (typeof value === "bigint") return value.toString();
+			return value;
+		});
+		return encoder.encode(json);
+	}
+	serializeToJson(nodes) {
+		const encoder = new TextEncoder();
+		const json = JSON.stringify({ nodes: nodes.map((node) => ({
+			id: node.id.toString(),
+			displayName: node.displayName,
+			displayNamePrefixLength: node.displayNamePrefixLength,
+			scopeId: node.scopeId.toString(),
+			type: node.type,
+			structInfo: node.structInfo,
+			enumInfo: node.enumInfo,
+			interfaceInfo: node.interfaceInfo
+		})) });
+		return encoder.encode(json);
+	}
+	serializeToCapnp(nodes) {
+		const lines = [];
+		for (const node of nodes) if (node.structInfo) {
+			lines.push(`struct ${node.displayName} {`);
+			for (const field of node.structInfo.fields) lines.push(`  ${field.name} @${field.codeOrder} :${this.typeToCapnp(field.type)};`);
+			lines.push("}");
+		}
+		return new TextEncoder().encode(lines.join("\n"));
+	}
+	typeToCapnp(type) {
+		switch (type.kind.type) {
+			case "void": return "Void";
+			case "bool": return "Bool";
+			case "int8": return "Int8";
+			case "int16": return "Int16";
+			case "int32": return "Int32";
+			case "int64": return "Int64";
+			case "uint8": return "UInt8";
+			case "uint16": return "UInt16";
+			case "uint32": return "UInt32";
+			case "uint64": return "UInt64";
+			case "float32": return "Float32";
+			case "float64": return "Float64";
+			case "text": return "Text";
+			case "data": return "Data";
+			case "list": return "List";
+			case "enum": return "UInt16";
+			case "struct": return "AnyPointer";
+			case "interface": return "Capability";
+			default: return "AnyPointer";
+		}
+	}
+	collectDependencies(_node) {
+		return [];
+	}
+	getSchemasByFileId(fileId) {
+		return Array.from(this.registry.values()).filter((node) => node.scopeId === fileId);
+	}
+	getSchemasByFileName(fileName) {
+		return Array.from(this.registry.values()).filter((node) => {
+			return this.inferFileName(node) === fileName || node.displayName.startsWith(fileName);
+		});
+	}
+	inferFileName(node) {
+		const parts = node.displayName.split(".");
+		if (parts.length > 1) return `${parts.slice(0, -1).join("/")}.capnp`;
+		return "unknown.capnp";
+	}
+	findBootstrapSchema() {
+		for (const node of this.registry.values()) if (node.type === require_rpc_connection.SchemaNodeType.INTERFACE) return node;
+	}
+};
+/**
+* Client-side implementation for accessing remote SchemaCapability
+*/
+var SchemaCapabilityClient = class {
+	connection;
+	/**
+	* Create a new SchemaCapabilityClient
+	* @param connection - The RPC connection to use
+	*/
+	constructor(connection) {
+		this.connection = connection;
+	}
+	/**
+	* Fetch schema information from the remote server
+	* @param target - The schema target specification
+	* @param format - The desired format (defaults to BINARY)
+	* @returns The schema node
+	*/
+	async getSchema(target, format = require_rpc_connection.SchemaFormat.BINARY) {
+		if (target.type === "byTypeId") return this.connection.getDynamicSchema(target.typeId);
+		if (target.type === "byTypeName") return this.connection.getDynamicSchemaByName(target.typeName);
+		throw new Error(`Schema target type not implemented: ${target.type}`);
+	}
+	/**
+	* Fetch schema by type ID
+	* @param typeId - The type ID
+	* @returns The schema node
+	*/
+	async getSchemaById(typeId) {
+		return this.connection.getDynamicSchema(typeId);
+	}
+	/**
+	* Fetch schema by type name
+	* @param typeName - The fully qualified type name
+	* @returns The schema node
+	*/
+	async getSchemaByName(typeName) {
+		return this.connection.getDynamicSchemaByName(typeName);
+	}
+	/**
+	* List all available schemas from the remote server
+	* @returns Array of available schema information
+	*/
+	async listAvailableSchemas() {
+		return (await this.connection.listAvailableSchemas()).map((s) => ({
+			typeId: s.typeId,
+			displayName: s.displayName,
+			fileId: BigInt(0),
+			fileName: "",
+			isInterface: false,
+			isStruct: true,
+			isEnum: false
+		}));
+	}
+	/**
+	* Fetch multiple schemas at once
+	* @param typeIds - Array of type IDs to fetch
+	* @returns Map of type ID to schema node
+	*/
+	async getSchemas(typeIds) {
+		const results = /* @__PURE__ */ new Map();
+		await Promise.all(typeIds.map(async (typeId) => {
+			try {
+				const schema = await this.getSchemaById(typeId);
+				results.set(typeId, schema);
+			} catch (error) {
+				console.warn(`Failed to fetch schema ${typeId.toString(16)}:`, error);
+			}
+		}));
+		return results;
+	}
+	/**
+	* Check if a schema is available on the remote server
+	* @param typeId - The type ID to check
+	* @returns True if the schema is available
+	*/
+	async hasSchema(typeId) {
+		try {
+			await this.getSchemaById(typeId);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+
 //#endregion
 exports.AnswerTable = require_rpc_connection.AnswerTable;
 exports.BaseCapabilityClient = BaseCapabilityClient;
@@ -4937,6 +5865,10 @@ exports.RealtimeStream = RealtimeStream;
 exports.RealtimeStreamManager = RealtimeStreamManager;
 exports.RestoreHandler = RestoreHandler;
 exports.RpcConnection = require_rpc_connection.RpcConnection;
+exports.SCHEMA_MESSAGE_TYPES = require_rpc_connection.SCHEMA_MESSAGE_TYPES;
+exports.SchemaCapabilityClient = SchemaCapabilityClient;
+exports.SchemaCapabilityServer = SchemaCapabilityServer;
+exports.SchemaFormat = require_rpc_connection.SchemaFormat;
 exports.Segment = Segment;
 exports.Stream = Stream;
 exports.StreamManager = StreamManager;
@@ -4952,10 +5884,17 @@ exports.WORD_SIZE = WORD_SIZE;
 exports.WebSocketTransport = WebSocketTransport;
 exports.configureGlobalMemoryPool = configureGlobalMemoryPool;
 exports.createBulkTransferManager = createBulkTransferManager;
+exports.createDynamicReader = createDynamicReader;
+exports.createDynamicReaderByTypeId = createDynamicReaderByTypeId;
+exports.createDynamicReaderFromStruct = createDynamicReaderFromStruct;
+exports.createDynamicWriter = createDynamicWriter;
+exports.createDynamicWriterByTypeId = createDynamicWriterByTypeId;
+exports.createNestedDynamicWriter = createNestedDynamicWriter;
 exports.createPipelineClient = require_rpc_connection.createPipelineClient;
 exports.createProvisionId = createProvisionId;
 exports.createRealtimeStreamManager = createRealtimeStreamManager;
 exports.createRecipientId = createRecipientId;
+exports.createSchemaRegistry = require_rpc_connection.createSchemaRegistry;
 exports.createStream = createStream;
 exports.createStreamManager = createStreamManager;
 exports.createStreamingConnection = createStreamingConnection;
@@ -4966,7 +5905,10 @@ exports.createUnionReader = createUnionReader;
 exports.createZeroCopyView = createZeroCopyView;
 exports.decodePointer = decodePointer;
 exports.deserializeRpcMessage = deserializeRpcMessage;
+exports.deserializeSchemaRequest = require_rpc_connection.deserializeSchemaRequest;
+exports.deserializeSchemaResponse = require_rpc_connection.deserializeSchemaResponse;
 exports.deserializeSturdyRef = deserializeSturdyRef;
+exports.dumpDynamicReader = dumpDynamicReader;
 exports.encodeListPointer = encodeListPointer;
 exports.encodeStructPointer = encodeStructPointer;
 exports.fastCopy = fastCopy;
@@ -4977,7 +5919,15 @@ exports.isPipelineClient = require_rpc_connection.isPipelineClient;
 exports.isSameBuffer = isSameBuffer;
 exports.isStream = isStream;
 exports.isSturdyRefValid = isSturdyRefValid;
+exports.parseSchemaNodes = require_rpc_connection.parseSchemaNodes;
+exports.serializeDynamic = serializeDynamic;
+exports.serializeDynamicByTypeId = serializeDynamicByTypeId;
+exports.serializeGetSchemaParams = require_rpc_connection.serializeGetSchemaParams;
+exports.serializeGetSchemaResults = require_rpc_connection.serializeGetSchemaResults;
+exports.serializeListSchemasResults = require_rpc_connection.serializeListSchemasResults;
 exports.serializeRpcMessage = serializeRpcMessage;
+exports.serializeSchemaRequest = require_rpc_connection.serializeSchemaRequest;
+exports.serializeSchemaResponse = require_rpc_connection.serializeSchemaResponse;
 exports.serializeSturdyRef = serializeSturdyRef;
 exports.supportsStreaming = supportsStreaming;
 //# sourceMappingURL=index.cjs.map