@naeemo/capnp 0.4.0 → 0.5.0

package/dist/cli.js

@@ -1,328 +1,1704 @@
 #!/usr/bin/env node
 #!/usr/bin/env node
-import { readFileSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
 import { parseArgs } from "node:util";
 
-//#region src/codegen/enum-gen.ts
+//#region src/codegen/generator.ts
+const DEFAULT_OPTIONS = { runtimeImportPath: "@naeemo/capnp" };
 /**
-* Enum generator
+* 从 CodeGeneratorRequest 生成 TypeScript 代码
 */
-function generateEnum(enum_, lines) {
-	lines.push(`export enum ${enum_.name} {`);
-	for (const value of enum_.values) lines.push(`  ${value.name} = ${value.index},`);
+function generateFromRequest(request, options) {
+	const opts = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	const files = /* @__PURE__ */ new Map();
+	const nodes = request.nodes;
+	const requestedFiles = request.requestedFiles;
+	for (const file of requestedFiles) {
+		const filename = file.filename.replace(/\.capnp$/, ".ts");
+		const code = generateFile(file.id, nodes, opts);
+		files.set(filename, code);
+	}
+	return files;
+}
+/**
+* 生成单个文件的 TypeScript 代码
+*/
+function generateFile(fileId, allNodes, options) {
+	const lines = [];
+	lines.push("// Generated by @naeemo/capnp");
+	lines.push("// DO NOT EDIT MANUALLY");
+	lines.push("");
+	lines.push(`import { MessageReader, MessageBuilder, StructReader, StructBuilder, createUnionReader, createUnionBuilder } from "${options.runtimeImportPath}";`);
+	lines.push("");
+	lines.push("// XOR helpers for default value encoding");
+	lines.push("function xorFloat32(a: number, b: number): number {");
+	lines.push("  const view = new DataView(new ArrayBuffer(4));");
+	lines.push("  view.setFloat32(0, a, true);");
+	lines.push("  const aBits = view.getUint32(0, true);");
+	lines.push("  view.setFloat32(0, b, true);");
+	lines.push("  const bBits = view.getUint32(0, true);");
+	lines.push("  view.setUint32(0, aBits ^ bBits, true);");
+	lines.push("  return view.getFloat32(0, true);");
 	lines.push("}");
 	lines.push("");
+	lines.push("function xorFloat64(a: number, b: number): number {");
+	lines.push("  const view = new DataView(new ArrayBuffer(8));");
+	lines.push("  view.setFloat64(0, a, true);");
+	lines.push("  const aBits = view.getBigUint64(0, true);");
+	lines.push("  view.setFloat64(0, b, true);");
+	lines.push("  const bBits = view.getBigUint64(0, true);");
+	lines.push("  view.setBigUint64(0, aBits ^ bBits, true);");
+	lines.push("  return view.getFloat64(0, true);");
+	lines.push("}");
+	lines.push("");
+	let filePrefix = "";
+	try {
+		filePrefix = allNodes.find((n) => n.id === fileId)?.displayName || "";
+	} catch (_e) {}
+	const fileNodes = allNodes.filter((n) => {
+		try {
+			if (n.scopeId === fileId) return true;
+			if (n.scopeId === 0n && filePrefix && n.displayName.startsWith(`${filePrefix}:`)) return n.displayName.substring(filePrefix.length + 1).includes("$");
+		} catch (_e) {}
+		return false;
+	});
+	for (const node of fileNodes) {
+		if (node.isStruct) lines.push(generateStruct(node, allNodes));
+		else if (node.isEnum) lines.push(generateEnum(node));
+		else if (node.isInterface) lines.push(generateInterface(node, allNodes));
+		lines.push("");
+	}
+	return lines.join("\n");
 }
-
-//#endregion
-//#region src/codegen/type-utils.ts
-function isPointerType(type) {
-	if (typeof type === "string") return type === "Text" || type === "Data";
-	return type.kind === "list" || type.kind === "struct";
-}
-function getTypeSize(type) {
-	if (typeof type !== "string") return 8;
-	switch (type) {
-		case "Void": return 0;
-		case "Bool": return 1;
-		case "Int8":
-		case "UInt8": return 1;
-		case "Int16":
-		case "UInt16": return 2;
-		case "Int32":
-		case "UInt32":
-		case "Float32": return 4;
-		case "Int64":
-		case "UInt64":
-		case "Float64": return 8;
-		default: return 8;
-	}
-}
-function mapTypeToTs(type) {
-	if (typeof type !== "string") {
-		if (type.kind === "list") return `${mapTypeToTs(type.elementType)}[]`;
-		return type.name;
-	}
-	switch (type) {
-		case "Void": return "void";
-		case "Bool": return "boolean";
-		case "Int8":
-		case "Int16":
-		case "Int32":
-		case "UInt8":
-		case "UInt16":
-		case "UInt32":
-		case "Float32":
-		case "Float64": return "number";
-		case "Int64":
-		case "UInt64": return "bigint";
-		case "Text": return "string";
-		case "Data": return "Uint8Array";
-		default: return "unknown";
+/**
+* 生成 Struct 的 TypeScript 代码
+*/
+function generateStruct(node, allNodes) {
+	const lines = [];
+	const structName = getShortName(node.displayName);
+	let unionGroups = [];
+	let regularFields = [];
+	let groupFields = [];
+	try {
+		const analysis = analyzeFields(node, allNodes);
+		unionGroups = analysis.unionGroups;
+		regularFields = analysis.regularFields;
+		groupFields = analysis.groupFields;
+	} catch (_e) {
+		lines.push(`export interface ${structName} {`);
+		lines.push("  // Note: Could not parse struct fields");
+		lines.push("}");
+		lines.push("");
+		lines.push(`export class ${structName}Reader {`);
+		lines.push("  constructor(private reader: StructReader) {}");
+		lines.push("}");
+		lines.push("");
+		lines.push(`export class ${structName}Builder {`);
+		lines.push("  constructor(private builder: StructBuilder) {}");
+		lines.push("}");
+		return lines.join("\n");
+	}
+	lines.push(`export interface ${structName} {`);
+	for (const field of regularFields) {
+		if (!field.isSlot) continue;
+		const tsType = getTypeScriptType(field.slotType, allNodes);
+		lines.push(`  ${field.name}: ${tsType};`);
+	}
+	for (const { field: groupField, groupNode } of groupFields) {
+		const groupName = groupField.name;
+		try {
+			for (const field of groupNode.structFields) {
+				if (!field.isSlot) continue;
+				const tsType = getTypeScriptType(field.slotType, allNodes);
+				lines.push(`  ${groupName}${capitalize(field.name)}: ${tsType};`);
+			}
+		} catch (_e) {}
+	}
+	for (const [groupIndex, group] of unionGroups.entries()) {
+		const unionName = group.fields.length > 0 ? `${capitalize(group.fields[0].name)}Union` : `Union${groupIndex}`;
+		lines.push(`  ${unionName}: ${generateUnionVariantType(group, allNodes)};`);
+	}
+	lines.push("}");
+	lines.push("");
+	lines.push(`export class ${structName}Reader {`);
+	lines.push("  constructor(private reader: StructReader) {}");
+	lines.push("");
+	for (const field of regularFields) {
+		if (!field.isSlot) continue;
+		const getter = generateFieldGetter(field);
+		lines.push(`  ${getter}`);
+		lines.push("");
+	}
+	for (const { field: groupField, groupNode } of groupFields) {
+		const groupName = groupField.name;
+		try {
+			for (const field of groupNode.structFields) {
+				if (!field.isSlot) continue;
+				const getter = generateGroupFieldGetter(field, groupName);
+				lines.push(`  ${getter}`);
+				lines.push("");
+			}
+		} catch (_e) {}
+	}
+	for (const [groupIndex, group] of unionGroups.entries()) {
+		const unionName = group.fields.length > 0 ? `${capitalize(group.fields[0].name)}Union` : `Union${groupIndex}`;
+		const variants = {};
+		for (const field of group.fields) variants[field.discriminantValue] = field.name;
+		const variantsStr = JSON.stringify(variants).replace(/"/g, "'");
+		lines.push(`  get${unionName}Tag(): number {`);
+		lines.push(`    return this.reader.getUint16(${group.discriminantOffset * 2});`);
+		lines.push("  }");
+		lines.push("");
+		lines.push(`  get${unionName}Variant(): string | undefined {`);
+		lines.push(`    const tag = this.get${unionName}Tag();`);
+		lines.push(`    const variants = ${variantsStr};`);
+		lines.push("    return variants[tag];");
+		lines.push("  }");
+		lines.push("");
+		for (const field of group.fields) {
+			const getter = generateUnionFieldGetter(field, unionName, field.discriminantValue);
+			lines.push(`  ${getter}`);
+			lines.push("");
+		}
+		for (const field of group.fields) {
+			const setter = generateUnionFieldSetter(field, unionName, field.discriminantValue, group.discriminantOffset * 2);
+			lines.push(`  ${setter}`);
+			lines.push("");
+		}
+	}
+	lines.push("}");
+	lines.push("");
+	lines.push(`export class ${structName}Builder {`);
+	lines.push("  constructor(private builder: StructBuilder) {}");
+	lines.push("");
+	for (const field of regularFields) {
+		if (!field.isSlot) continue;
+		const setter = generateFieldSetter(field);
+		lines.push(`  ${setter}`);
+		lines.push("");
+	}
+	for (const { field: groupField, groupNode } of groupFields) {
+		const groupName = groupField.name;
+		try {
+			for (const field of groupNode.structFields) {
+				if (!field.isSlot) continue;
+				const setter = generateGroupFieldSetter(field, groupName);
+				lines.push(`  ${setter}`);
+				lines.push("");
+			}
+		} catch (_e) {}
+	}
+	for (const [groupIndex, group] of unionGroups.entries()) {
+		const unionName = group.fields.length > 0 ? `${capitalize(group.fields[0].name)}Union` : `Union${groupIndex}`;
+		for (const field of group.fields) {
+			const setter = generateUnionFieldSetter(field, unionName, field.discriminantValue, group.discriminantOffset * 2);
+			lines.push(`  ${setter}`);
+			lines.push("");
+		}
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+/**
+* 分析字段，分离 Union 字段和普通字段，展开 Group 字段
+*/
+function analyzeFields(node, allNodes) {
+	const fields = node.structFields;
+	const unionGroups = /* @__PURE__ */ new Map();
+	const regularFields = [];
+	const groupFields = [];
+	for (const field of fields) {
+		if (field.isGroup) {
+			const groupNode = allNodes.find((n) => n.id === field.groupTypeId);
+			if (groupNode?.isStruct) groupFields.push({
+				field,
+				groupNode
+			});
+			continue;
+		}
+		if (node.structDiscriminantCount > 0 && field.discriminantValue !== 65535 && field.discriminantValue !== 0) {
+			const discriminantOffset = node.structDiscriminantOffset;
+			if (!unionGroups.has(discriminantOffset)) unionGroups.set(discriminantOffset, {
+				discriminantOffset,
+				fields: []
+			});
+			unionGroups.get(discriminantOffset).fields.push(field);
+		} else regularFields.push(field);
+	}
+	return {
+		unionGroups: Array.from(unionGroups.values()),
+		regularFields,
+		groupFields
+	};
+}
+/**
+* 生成 Union variant 类型
+*/
+function generateUnionVariantType(group, allNodes) {
+	return group.fields.map((f) => {
+		const tsType = f.isSlot ? getTypeScriptType(f.slotType, allNodes) : "unknown";
+		return `{ tag: ${f.discriminantValue}; variant: '${f.name}'; value: ${tsType} }`;
+	}).join(" | ");
+}
+/**
+* 生成 Union 字段的 getter
+*/
+function generateUnionFieldGetter(field, unionName, discriminantValue) {
+	const name = field.name;
+	const type = field.slotType;
+	if (!type || !field.isSlot) return `get${capitalize(name)}(): unknown | undefined { return this.get${unionName}Tag() === ${discriminantValue} ? undefined : undefined; }`;
+	const returnType = getTypeScriptTypeForSetter(type);
+	let body;
+	switch (type.kind) {
+		case "void":
+			body = "return undefined;";
+			break;
+		case "bool":
+			body = `return this.reader.getBool(${field.slotOffset * 8});`;
+			break;
+		case "int8":
+			body = `return this.reader.getInt8(${field.slotOffset});`;
+			break;
+		case "int16":
+			body = `return this.reader.getInt16(${field.slotOffset * 2});`;
+			break;
+		case "int32":
+			body = `return this.reader.getInt32(${field.slotOffset * 4});`;
+			break;
+		case "int64":
+			body = `return this.reader.getInt64(${field.slotOffset * 8});`;
+			break;
+		case "uint8":
+			body = `return this.reader.getUint8(${field.slotOffset});`;
+			break;
+		case "uint16":
+			body = `return this.reader.getUint16(${field.slotOffset * 2});`;
+			break;
+		case "uint32":
+			body = `return this.reader.getUint32(${field.slotOffset * 4});`;
+			break;
+		case "uint64":
+			body = `return this.reader.getUint64(${field.slotOffset * 8});`;
+			break;
+		case "float32":
+			body = `return this.reader.getFloat32(${field.slotOffset * 4});`;
+			break;
+		case "float64":
+			body = `return this.reader.getFloat64(${field.slotOffset * 8});`;
+			break;
+		case "text":
+			body = `return this.reader.getText(${field.slotOffset});`;
+			break;
+		case "data":
+			body = `return this.reader.getData(${field.slotOffset});`;
+			break;
+		default: body = "return undefined;";
+	}
+	return `get${capitalize(name)}(): ${returnType} | undefined {
+    if (this.get${unionName}Tag() !== ${discriminantValue}) return undefined;
+    ${body}
+  }`;
+}
+/**
+* 生成 Group 字段的 getter
+* Group 字段在父 struct 的 data/pointer section 中，但命名空间是 Group 的名字
+*/
+function generateGroupFieldGetter(field, groupName) {
+	const name = field.name;
+	const type = field.slotType;
+	if (!type) return `get${capitalize(groupName)}${capitalize(name)}(): unknown { return undefined; }`;
+	switch (type.kind) {
+		case "void": return `get${capitalize(groupName)}${capitalize(name)}(): void { return undefined; }`;
+		case "bool": return `get${capitalize(groupName)}${capitalize(name)}(): boolean { return this.reader.getBool(${field.slotOffset * 8}); }`;
+		case "int8": return `get${capitalize(groupName)}${capitalize(name)}(): number { return this.reader.getInt8(${field.slotOffset}); }`;
+		case "int16": return `get${capitalize(groupName)}${capitalize(name)}(): number { return this.reader.getInt16(${field.slotOffset * 2}); }`;
+		case "int32": return `get${capitalize(groupName)}${capitalize(name)}(): number { return this.reader.getInt32(${field.slotOffset * 4}); }`;
+		case "int64": return `get${capitalize(groupName)}${capitalize(name)}(): bigint { return this.reader.getInt64(${field.slotOffset * 8}); }`;
+		case "uint8": return `get${capitalize(groupName)}${capitalize(name)}(): number { return this.reader.getUint8(${field.slotOffset}); }`;
+		case "uint16": return `get${capitalize(groupName)}${capitalize(name)}(): number { return this.reader.getUint16(${field.slotOffset * 2}); }`;
+		case "uint32": return `get${capitalize(groupName)}${capitalize(name)}(): number { return this.reader.getUint32(${field.slotOffset * 4}); }`;
+		case "uint64": return `get${capitalize(groupName)}${capitalize(name)}(): bigint { return this.reader.getUint64(${field.slotOffset * 8}); }`;
+		case "float32": return `get${capitalize(groupName)}${capitalize(name)}(): number { return this.reader.getFloat32(${field.slotOffset * 4}); }`;
+		case "float64": return `get${capitalize(groupName)}${capitalize(name)}(): number { return this.reader.getFloat64(${field.slotOffset * 8}); }`;
+		case "text": return `get${capitalize(groupName)}${capitalize(name)}(): string { return this.reader.getText(${field.slotOffset}); }`;
+		case "data": return `get${capitalize(groupName)}${capitalize(name)}(): Uint8Array { return this.reader.getData(${field.slotOffset}); }`;
+		default: return `get${capitalize(groupName)}${capitalize(name)}(): unknown { return undefined; }`;
+	}
+}
+/**
+* 生成 Group 字段的 setter
+*/
+function generateGroupFieldSetter(field, groupName) {
+	const name = field.name;
+	const type = field.slotType;
+	const paramType = getTypeScriptTypeForSetter(type);
+	if (!type || !field.isSlot) return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { /* TODO */ }`;
+	switch (type.kind) {
+		case "void": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { }`;
+		case "bool": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setBool(${field.slotOffset * 8}, value); }`;
+		case "int8": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setInt8(${field.slotOffset}, value); }`;
+		case "int16": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setInt16(${field.slotOffset * 2}, value); }`;
+		case "int32": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setInt32(${field.slotOffset * 4}, value); }`;
+		case "int64": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setInt64(${field.slotOffset * 8}, value); }`;
+		case "uint8": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setUint8(${field.slotOffset}, value); }`;
+		case "uint16": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setUint16(${field.slotOffset * 2}, value); }`;
+		case "uint32": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setUint32(${field.slotOffset * 4}, value); }`;
+		case "uint64": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setUint64(${field.slotOffset * 8}, value); }`;
+		case "float32": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setFloat32(${field.slotOffset * 4}, value); }`;
+		case "float64": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setFloat64(${field.slotOffset * 8}, value); }`;
+		case "text": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setText(${field.slotOffset}, value); }`;
+		case "data": return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { this.builder.setData(${field.slotOffset}, value); }`;
+		default: return `set${capitalize(groupName)}${capitalize(name)}(value: ${paramType}): void { /* TODO */ }`;
+	}
+}
+/**
+* 生成 Union 字段的 setter
+*/
+function generateUnionFieldSetter(field, _unionName, discriminantValue, discriminantOffset) {
+	const name = field.name;
+	const type = field.slotType;
+	const paramType = getTypeScriptTypeForSetter(type);
+	if (!type || !field.isSlot) return `set${capitalize(name)}(value: ${paramType}): void {
+    this.builder.setUint16(${discriminantOffset}, ${discriminantValue});
+  }`;
+	let body;
+	switch (type.kind) {
+		case "void":
+			body = "";
+			break;
+		case "bool":
+			body = `this.builder.setBool(${field.slotOffset * 8}, value);`;
+			break;
+		case "int8":
+			body = `this.builder.setInt8(${field.slotOffset}, value);`;
+			break;
+		case "int16":
+			body = `this.builder.setInt16(${field.slotOffset * 2}, value);`;
+			break;
+		case "int32":
+			body = `this.builder.setInt32(${field.slotOffset * 4}, value);`;
+			break;
+		case "int64":
+			body = `this.builder.setInt64(${field.slotOffset * 8}, value);`;
+			break;
+		case "uint8":
+			body = `this.builder.setUint8(${field.slotOffset}, value);`;
+			break;
+		case "uint16":
+			body = `this.builder.setUint16(${field.slotOffset * 2}, value);`;
+			break;
+		case "uint32":
+			body = `this.builder.setUint32(${field.slotOffset * 4}, value);`;
+			break;
+		case "uint64":
+			body = `this.builder.setUint64(${field.slotOffset * 8}, value);`;
+			break;
+		case "float32":
+			body = `this.builder.setFloat32(${field.slotOffset * 4}, value);`;
+			break;
+		case "float64":
+			body = `this.builder.setFloat64(${field.slotOffset * 8}, value);`;
+			break;
+		case "text":
+			body = `this.builder.setText(${field.slotOffset}, value);`;
+			break;
+		case "data":
+			body = `this.builder.setData(${field.slotOffset}, value);`;
+			break;
+		default: body = "";
+	}
+	return `set${capitalize(name)}(value: ${paramType}): void {
+    this.builder.setUint16(${discriminantOffset}, ${discriminantValue});
+    ${body}
+  }`;
+}
+/**
+* 从 ValueReader 提取默认值，用于代码生成
+*/
+function extractDefaultValue(field) {
+	const defaultValue = field.defaultValue;
+	if (!defaultValue) return void 0;
+	const type = field.slotType;
+	if (!type) return void 0;
+	switch (type.kind) {
+		case "bool":
+			if (defaultValue.isBool) return defaultValue.boolValue ? "true" : "false";
+			return;
+		case "int8":
+			if (defaultValue.isInt8) return `${defaultValue.int8Value}`;
+			return;
+		case "int16":
+			if (defaultValue.isInt16) return `${defaultValue.int16Value}`;
+			return;
+		case "int32":
+			if (defaultValue.isInt32) return `${defaultValue.int32Value}`;
+			return;
+		case "int64":
+			if (defaultValue.isInt64) return `${defaultValue.int64Value}n`;
+			return;
+		case "uint8":
+			if (defaultValue.isUint8) return `${defaultValue.uint8Value}`;
+			return;
+		case "uint16":
+			if (defaultValue.isUint16) return `${defaultValue.uint16Value}`;
+			return;
+		case "uint32":
+			if (defaultValue.isUint32) return `${defaultValue.uint32Value}`;
+			return;
+		case "uint64":
+			if (defaultValue.isUint64) return `${defaultValue.uint64Value}n`;
+			return;
+		case "float32":
+			if (defaultValue.isFloat32) {
+				const val = defaultValue.float32Value;
+				if (Number.isNaN(val)) return "NaN";
+				if (val === Number.POSITIVE_INFINITY) return "Infinity";
+				if (val === Number.NEGATIVE_INFINITY) return "-Infinity";
+				return `${val}`;
+			}
+			return;
+		case "float64":
+			if (defaultValue.isFloat64) {
+				const val = defaultValue.float64Value;
+				if (Number.isNaN(val)) return "NaN";
+				if (val === Number.POSITIVE_INFINITY) return "Infinity";
+				if (val === Number.NEGATIVE_INFINITY) return "-Infinity";
+				return `${val}`;
+			}
+			return;
+		case "enum":
+			if (defaultValue.isEnum) return `${defaultValue.enumValue}`;
+			return;
+		default: return;
+	}
+}
+/**
+* 生成 XOR 解码表达式（用于 getter）
+* stored ^ default = actual
+*/
+function generateXorDecode(expr, defaultValue, typeKind) {
+	switch (typeKind) {
+		case "bool": return `${expr} !== ${defaultValue}`;
+		case "int8":
+		case "int16":
+		case "int32": return `(${expr} ^ ${defaultValue}) | 0`;
+		case "uint8":
+		case "uint16":
+		case "uint32": return `${expr} ^ ${defaultValue}`;
+		case "int64":
+		case "uint64": return `${expr} ^ ${defaultValue}`;
+		case "float32": return `xorFloat32(${expr}, ${defaultValue})`;
+		case "float64": return `xorFloat64(${expr}, ${defaultValue})`;
+		case "enum": return `${expr} ^ ${defaultValue}`;
+		default: return expr;
+	}
+}
+/**
+* 生成 XOR 编码表达式（用于 setter）
+* actual ^ default = stored
+*/
+function generateXorEncode(valueExpr, defaultValue, typeKind) {
+	switch (typeKind) {
+		case "bool": return `${valueExpr} !== ${defaultValue}`;
+		case "int8":
+		case "int16":
+		case "int32": return `(${valueExpr} >>> 0) ^ ${defaultValue}`;
+		case "uint8":
+		case "uint16":
+		case "uint32": return `${valueExpr} ^ ${defaultValue}`;
+		case "int64":
+		case "uint64": return `${valueExpr} ^ ${defaultValue}`;
+		case "float32": return `xorFloat32(${valueExpr}, ${defaultValue})`;
+		case "float64": return `xorFloat64(${valueExpr}, ${defaultValue})`;
+		case "enum": return `${valueExpr} ^ ${defaultValue}`;
+		default: return valueExpr;
+	}
+}
+/**
+* 生成字段 getter
+*/
+function generateFieldGetter(field) {
+	const name = field.name;
+	const type = field.slotType;
+	const defaultValue = extractDefaultValue(field);
+	if (!type) return `get ${name}(): unknown { return undefined; }`;
+	if (defaultValue !== void 0 && type.kind !== "text" && type.kind !== "data") {
+		const decodedExpr = generateXorDecode(`this.reader.get${capitalize(type.kind)}(${getByteOffset(field, type.kind)})`, defaultValue, type.kind);
+		return `get ${name}(): ${getTypeScriptTypeForSetter(type)} { return ${decodedExpr}; }`;
+	}
+	switch (type.kind) {
+		case "void": return `get ${name}(): void { return undefined; }`;
+		case "bool": return `get ${name}(): boolean { return this.reader.getBool(${field.slotOffset * 8}); }`;
+		case "int8": return `get ${name}(): number { return this.reader.getInt8(${field.slotOffset}); }`;
+		case "int16": return `get ${name}(): number { return this.reader.getInt16(${field.slotOffset * 2}); }`;
+		case "int32": return `get ${name}(): number { return this.reader.getInt32(${field.slotOffset * 4}); }`;
+		case "int64": return `get ${name}(): bigint { return this.reader.getInt64(${field.slotOffset * 8}); }`;
+		case "uint8": return `get ${name}(): number { return this.reader.getUint8(${field.slotOffset}); }`;
+		case "uint16": return `get ${name}(): number { return this.reader.getUint16(${field.slotOffset * 2}); }`;
+		case "uint32": return `get ${name}(): number { return this.reader.getUint32(${field.slotOffset * 4}); }`;
+		case "uint64": return `get ${name}(): bigint { return this.reader.getUint64(${field.slotOffset * 8}); }`;
+		case "float32": return `get ${name}(): number { return this.reader.getFloat32(${field.slotOffset * 4}); }`;
+		case "float64": return `get ${name}(): number { return this.reader.getFloat64(${field.slotOffset * 8}); }`;
+		case "text": return `get ${name}(): string { return this.reader.getText(${field.slotOffset}); }`;
+		case "data": return `get ${name}(): Uint8Array { return this.reader.getData(${field.slotOffset}); }`;
+		default: return `get ${name}(): unknown { return undefined; }`;
+	}
+}
+/**
+* 获取字节偏移量
+*/
+function getByteOffset(field, typeKind) {
+	switch (typeKind) {
+		case "bool": return field.slotOffset * 8;
+		case "int8":
+		case "uint8": return field.slotOffset;
+		case "int16":
+		case "uint16":
+		case "enum": return field.slotOffset * 2;
+		case "int32":
+		case "uint32":
+		case "float32": return field.slotOffset * 4;
+		case "int64":
+		case "uint64":
+		case "float64": return field.slotOffset * 8;
+		default: return field.slotOffset;
+	}
+}
+/**
+* 生成字段 setter
+*/
+function generateFieldSetter(field) {
+	const name = field.name;
+	const type = field.slotType;
+	const paramType = getTypeScriptTypeForSetter(type);
+	const defaultValue = extractDefaultValue(field);
+	if (!type) return `set${capitalize(name)}(value: unknown): void { /* TODO */ }`;
+	if (defaultValue !== void 0 && type.kind !== "text" && type.kind !== "data") {
+		const encodedExpr = generateXorEncode("value", defaultValue, type.kind);
+		const setterMethod = `set${capitalize(type.kind)}`;
+		return `set${capitalize(name)}(value: ${paramType}): void { this.builder.${setterMethod}(${getByteOffset(field, type.kind)}, ${encodedExpr}); }`;
+	}
+	switch (type.kind) {
+		case "void": return `set${capitalize(name)}(value: void): void { /* void */ }`;
+		case "bool": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setBool(${field.slotOffset * 8}, value); }`;
+		case "int8": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setInt8(${field.slotOffset}, value); }`;
+		case "int16": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setInt16(${field.slotOffset * 2}, value); }`;
+		case "int32": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setInt32(${field.slotOffset * 4}, value); }`;
+		case "int64": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setInt64(${field.slotOffset * 8}, value); }`;
+		case "uint8": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setUint8(${field.slotOffset}, value); }`;
+		case "uint16": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setUint16(${field.slotOffset * 2}, value); }`;
+		case "uint32": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setUint32(${field.slotOffset * 4}, value); }`;
+		case "uint64": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setUint64(${field.slotOffset * 8}, value); }`;
+		case "float32": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setFloat32(${field.slotOffset * 4}, value); }`;
+		case "float64": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setFloat64(${field.slotOffset * 8}, value); }`;
+		case "text": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setText(${field.slotOffset}, value); }`;
+		case "data": return `set${capitalize(name)}(value: ${paramType}): void { this.builder.setData(${field.slotOffset}, value); }`;
+		default: return `set${capitalize(name)}(value: ${paramType}): void { /* TODO */ }`;
 	}
 }
-function getGetterMethod(type) {
-	if (typeof type !== "string") {
-		if (type.kind === "list") return "getList";
-		return "getStruct";
-	}
-	switch (type) {
-		case "Void": return "getVoid";
-		case "Bool": return "getBool";
-		case "Int8": return "getInt8";
-		case "Int16": return "getInt16";
-		case "Int32": return "getInt32";
-		case "Int64": return "getInt64";
-		case "UInt8": return "getUint8";
-		case "UInt16": return "getUint16";
-		case "UInt32": return "getUint32";
-		case "UInt64": return "getUint64";
-		case "Float32": return "getFloat32";
-		case "Float64": return "getFloat64";
-		case "Text": return "getText";
-		case "Data": return "getData";
-		default: return "getUnknown";
-	}
-}
-function getSetterMethod(type) {
-	if (typeof type !== "string") {
-		if (type.kind === "list") return "initList";
-		return "initStruct";
-	}
-	switch (type) {
-		case "Void": return "setVoid";
-		case "Bool": return "setBool";
-		case "Int8": return "setInt8";
-		case "Int16": return "setInt16";
-		case "Int32": return "setInt32";
-		case "Int64": return "setInt64";
-		case "UInt8": return "setUint8";
-		case "UInt16": return "setUint16";
-		case "UInt32": return "setUint32";
-		case "UInt64": return "setUint64";
-		case "Float32": return "setFloat32";
-		case "Float64": return "setFloat64";
-		case "Text": return "setText";
-		case "Data": return "setData";
-		default: return "setUnknown";
+/**
+* 获取 TypeScript setter 参数类型
+*/
+function getTypeScriptTypeForSetter(type) {
+	if (!type) return "unknown";
+	switch (type.kind) {
+		case "void": return "void";
+		case "bool": return "boolean";
+		case "int8":
+		case "int16":
+		case "int32":
+		case "uint8":
+		case "uint16":
+		case "uint32":
+		case "float32":
+		case "float64": return "number";
+		case "int64":
+		case "uint64": return "bigint";
+		case "text": return "string";
+		case "data": return "Uint8Array";
+		default: return "unknown";
 	}
 }
+/**
+* 首字母大写
+*/
 function capitalize(str) {
 	return str.charAt(0).toUpperCase() + str.slice(1);
 }
-
-//#endregion
-//#region src/codegen/struct-gen.ts
-function generateStruct(struct, lines) {
-	let dataWords = 0;
-	let pointerCount = 0;
-	let dataOffset = 0;
-	for (const field of struct.fields) if (isPointerType(field.type)) pointerCount++;
-	else dataOffset += getTypeSize(field.type);
-	dataWords = Math.ceil(dataOffset / 8);
-	lines.push(`export interface ${struct.name} {`);
-	for (const field of struct.fields) lines.push(`  ${field.name}: ${mapTypeToTs(field.type)};`);
+/**
+* 生成 Enum 的 TypeScript 代码
+*/
+function generateEnum(node) {
+	const lines = [];
+	const enumName = getShortName(node.displayName);
+	lines.push(`export enum ${enumName} {`);
+	for (const enumerant of node.enumEnumerants) lines.push(`  ${enumerant.name} = ${enumerant.codeOrder},`);
 	lines.push("}");
-	lines.push("");
-	generateReader(struct, dataWords, pointerCount, lines);
-	generateBuilder(struct, dataWords, pointerCount, lines);
+	return lines.join("\n");
 }
-function generateReader(struct, _dataWords, _pointerCount, lines) {
-	lines.push(`export class ${struct.name}Reader {`);
-	lines.push("  private reader: StructReader;");
-	lines.push("");
-	lines.push("  constructor(reader: StructReader) {");
-	lines.push("    this.reader = reader;");
-	lines.push("  }");
-	lines.push("");
-	let dataOffset = 0;
-	let pointerIndex = 0;
-	for (const field of struct.fields) {
-		const tsType = mapTypeToTs(field.type);
-		if (isPointerType(field.type)) {
-			lines.push(`  get ${field.name}(): ${tsType} {`);
-			lines.push(`    return this.reader.${getGetterMethod(field.type)}(${pointerIndex});`);
-			lines.push("  }");
-			pointerIndex++;
-		} else {
-			lines.push(`  get ${field.name}(): ${tsType} {`);
-			lines.push(`    return this.reader.${getGetterMethod(field.type)}(${dataOffset});`);
-			lines.push("  }");
-			dataOffset += getTypeSize(field.type);
+/**
+* 获取 TypeScript 类型字符串
+*/
+function getTypeScriptType(type, allNodes) {
+	if (!type) return "unknown";
+	switch (type.kind) {
+		case "void": return "void";
+		case "bool": return "boolean";
+		case "int8":
+		case "int16":
+		case "int32":
+		case "uint8":
+		case "uint16":
+		case "uint32":
+		case "float32":
+		case "float64": return "number";
+		case "int64":
+		case "uint64": return "bigint";
+		case "text": return "string";
+		case "data": return "Uint8Array";
+		case "list": {
+			const elementType = type.listElementType;
+			if (!elementType) return "unknown[]";
+			return `${getTypeScriptType(elementType, allNodes)}[]`;
 		}
-		lines.push("");
+		case "struct": {
+			const structNode = allNodes.find((n) => n.id === type.typeId);
+			if (structNode) return getShortName(structNode.displayName);
+			return "unknown";
+		}
+		case "enum": {
+			const enumNode = allNodes.find((n) => n.id === type.typeId);
+			if (enumNode) return getShortName(enumNode.displayName);
+			return "unknown";
+		}
+		default: return "unknown";
+	}
+}
+/**
+* 从 displayName 获取短名称
+* 例如 "test-schema.capnp:Person" -> "Person"
+* 处理 auto-generated 名称如 "Calculator.evaluate$Params" -> "EvaluateParams"
+*/
+function getShortName(displayName) {
+	if (!displayName) return "Unknown";
+	const colonIndex = displayName.lastIndexOf(":");
+	let name = colonIndex >= 0 ? displayName.substring(colonIndex + 1) : displayName;
+	if (name.includes(".")) {
+		const parts = name.split(".");
+		if (parts.length === 2 && parts[1].includes("$")) {
+			const methodPart = parts[1];
+			const dollarIndex = methodPart.indexOf("$");
+			if (dollarIndex > 0) {
+				const methodName = methodPart.substring(0, dollarIndex);
+				const suffix = methodPart.substring(dollarIndex + 1);
+				name = capitalize(methodName) + suffix;
+			} else name = capitalize(parts[1]);
+		} else name = parts[parts.length - 1];
+	}
+	name = name.replace(/[^a-zA-Z0-9_]/g, "_");
+	return name;
+}
+/**
+* 生成 Interface 的 TypeScript 代码
+* 包括：Method Constants、Client Class、Server Interface、Server Stub
+*/
+function generateInterface(node, allNodes) {
+	const lines = [];
+	const interfaceName = getShortName(node.displayName);
+	const methods = node.interfaceMethods;
+	if (methods.length === 0) return `// Interface ${interfaceName} has no methods`;
+	lines.push(`// ${interfaceName} Method IDs`);
+	lines.push(`export const ${interfaceName}InterfaceId = ${node.id}n;`);
+	lines.push(`export const ${interfaceName}MethodIds = {`);
+	for (const method of methods) lines.push(`  ${method.name}: ${method.codeOrder},`);
+	lines.push("} as const;");
+	lines.push("");
+	lines.push(`// ${interfaceName} Server Interface`);
+	lines.push(`export interface ${interfaceName}Server {`);
+	for (const method of methods) {
+		const paramType = getTypeNameById(method.paramStructType, allNodes, "unknown");
+		const resultType = getTypeNameById(method.resultStructType, allNodes, "unknown");
+		lines.push(`  ${method.name}(context: CallContext<${paramType}Reader, ${resultType}Builder>): Promise<void> | void;`);
 	}
 	lines.push("}");
 	lines.push("");
-}
-function generateBuilder(struct, dataWords, pointerCount, lines) {
-	lines.push(`export class ${struct.name}Builder {`);
-	lines.push("  private builder: StructBuilder;");
+	lines.push(`// ${interfaceName} Server Stub`);
+	lines.push(`export class ${interfaceName}Stub {`);
+	lines.push(`  private server: ${interfaceName}Server;`);
 	lines.push("");
-	lines.push("  constructor(builder: StructBuilder) {");
-	lines.push("    this.builder = builder;");
+	lines.push(`  constructor(server: ${interfaceName}Server) {`);
+	lines.push("    this.server = server;");
 	lines.push("  }");
 	lines.push("");
-	lines.push(`  static create(message: MessageBuilder): ${struct.name}Builder {`);
-	lines.push(`    const root = message.initRoot(${dataWords}, ${pointerCount});`);
-	lines.push(`    return new ${struct.name}Builder(root);`);
+	lines.push(`  static readonly interfaceId = ${node.id}n;`);
+	lines.push("");
+	lines.push("  /** Dispatch a method call to the appropriate handler */");
+	lines.push("  async dispatch(methodId: number, context: CallContext<unknown, unknown>): Promise<void> {");
+	lines.push("    switch (methodId) {");
+	for (const method of methods) {
+		const paramType = getTypeNameById(method.paramStructType, allNodes, "unknown");
+		const resultType = getTypeNameById(method.resultStructType, allNodes, "unknown");
+		lines.push(`      case ${interfaceName}MethodIds.${method.name}:`);
+		lines.push(`        return this.server.${method.name}(context as CallContext<${paramType}Reader, ${resultType}Builder>);`);
+	}
+	lines.push("      default:");
+	lines.push("        throw new Error(`Unknown method ID: ${methodId}`);");
+	lines.push("    }");
 	lines.push("  }");
 	lines.push("");
-	let dataOffset = 0;
-	let pointerIndex = 0;
-	for (const field of struct.fields) {
-		const tsType = mapTypeToTs(field.type);
-		const method = getSetterMethod(field.type);
-		if (isPointerType(field.type)) {
-			lines.push(`  set${capitalize(field.name)}(value: ${tsType}): void {`);
-			lines.push(`    this.builder.${method}(${pointerIndex}, value);`);
-			lines.push("  }");
-			pointerIndex++;
-		} else {
-			lines.push(`  set${capitalize(field.name)}(value: ${tsType}): void {`);
-			lines.push(`    this.builder.${method}(${dataOffset}, value);`);
-			lines.push("  }");
-			dataOffset += getTypeSize(field.type);
-		}
+	lines.push("  /** Check if a method ID is valid */");
+	lines.push("  isValidMethod(methodId: number): boolean {");
+	lines.push("    return [");
+	for (const method of methods) lines.push(`      ${interfaceName}MethodIds.${method.name},`);
+	lines.push("    ].includes(methodId);");
+	lines.push("  }");
+	lines.push("}");
+	lines.push("");
+	lines.push(`// ${interfaceName} Client Class`);
+	lines.push(`export class ${interfaceName}Client extends BaseCapabilityClient {`);
+	lines.push(`  static readonly interfaceId = ${node.id}n;`);
+	lines.push("");
+	for (const method of methods) {
+		const paramType = getTypeNameById(method.paramStructType, allNodes, "unknown");
+		const resultType = getTypeNameById(method.resultStructType, allNodes, "unknown");
+		lines.push("  /**");
+		lines.push(`   * ${method.name}`);
+		lines.push(`   * @param params - ${paramType}`);
+		lines.push(`   * @returns PipelineClient<${resultType}Reader>`);
+		lines.push("   */");
+		lines.push(`  ${method.name}(params: ${paramType}Builder): PipelineClient<${resultType}Reader> {`);
+		lines.push("    return this._call(");
+		lines.push(`      ${interfaceName}Client.interfaceId,`);
+		lines.push(`      ${interfaceName}MethodIds.${method.name},`);
+		lines.push("      params");
+		lines.push(`    ) as PipelineClient<${resultType}Reader>;`);
+		lines.push("  }");
 		lines.push("");
 	}
 	lines.push("}");
-	lines.push("");
+	return lines.join("\n");
+}
+/**
+* 根据类型 ID 获取类型名称
+*/
+function getTypeNameById(id, allNodes, fallback) {
+	const node = allNodes.find((n) => n.id === id);
+	if (!node) return fallback;
+	return getShortName(node.displayName);
 }
 
 //#endregion
-//#region src/codegen/generator-v2.ts
+//#region src/core/pointer.ts
 /**
-* Main code generator v2
+* Cap'n Proto 指针编解码
+* 纯 TypeScript 实现
 */
-const DEFAULT_OPTIONS = { runtimeImportPath: "@naeemo/capnp" };
-function generateCode(schema, options) {
-	const opts = {
-		...DEFAULT_OPTIONS,
-		...options
-	};
-	const lines = [];
-	lines.push("// Generated by capnp-ts-codegen");
-	lines.push("// DO NOT EDIT MANUALLY");
-	lines.push("");
-	lines.push(`import { MessageReader, MessageBuilder, StructReader, StructBuilder } from "${opts.runtimeImportPath}";`);
-	lines.push("");
-	for (const enum_ of schema.enums) generateEnum(enum_, lines);
-	for (const struct of schema.structs) generateStruct(struct, lines);
-	return lines.join("\n");
+let PointerTag = /* @__PURE__ */ function(PointerTag) {
+	PointerTag[PointerTag["STRUCT"] = 0] = "STRUCT";
+	PointerTag[PointerTag["LIST"] = 1] = "LIST";
+	PointerTag[PointerTag["FAR"] = 2] = "FAR";
+	PointerTag[PointerTag["OTHER"] = 3] = "OTHER";
+	return PointerTag;
+}({});
+let ElementSize = /* @__PURE__ */ function(ElementSize) {
+	ElementSize[ElementSize["VOID"] = 0] = "VOID";
+	ElementSize[ElementSize["BIT"] = 1] = "BIT";
+	ElementSize[ElementSize["BYTE"] = 2] = "BYTE";
+	ElementSize[ElementSize["TWO_BYTES"] = 3] = "TWO_BYTES";
+	ElementSize[ElementSize["FOUR_BYTES"] = 4] = "FOUR_BYTES";
+	ElementSize[ElementSize["EIGHT_BYTES"] = 5] = "EIGHT_BYTES";
+	ElementSize[ElementSize["POINTER"] = 6] = "POINTER";
+	ElementSize[ElementSize["COMPOSITE"] = 7] = "COMPOSITE";
+	ElementSize[ElementSize["INLINE_COMPOSITE"] = 7] = "INLINE_COMPOSITE";
+	return ElementSize;
+}({});
+/**
+* 解码指针（64位）
+*/
+function decodePointer(ptr) {
+	const tag = Number(ptr & BigInt(3));
+	switch (tag) {
+		case PointerTag.STRUCT: {
+			const offset = Number(ptr >> BigInt(2)) & 1073741823;
+			return {
+				tag,
+				offset: offset >= 536870912 ? offset - 1073741824 : offset,
+				dataWords: Number(ptr >> BigInt(32) & BigInt(65535)),
+				pointerCount: Number(ptr >> BigInt(48) & BigInt(65535))
+			};
+		}
+		case PointerTag.LIST: {
+			const offset = Number(ptr >> BigInt(2)) & 1073741823;
+			return {
+				tag,
+				offset: offset >= 536870912 ? offset - 1073741824 : offset,
+				elementSize: Number(ptr >> BigInt(32) & BigInt(7)),
+				elementCount: Number(ptr >> BigInt(35) & BigInt(536870911))
+			};
+		}
+		case PointerTag.FAR: {
+			const doubleFar = Boolean(ptr >> BigInt(2) & BigInt(1));
+			const targetOffset = Number(ptr >> BigInt(3) & BigInt(536870911));
+			return {
+				tag,
+				doubleFar,
+				targetSegment: Number(ptr >> BigInt(32) & BigInt(4294967295)),
+				targetOffset
+			};
+		}
+		default: return { tag: PointerTag.OTHER };
+	}
 }
 
 //#endregion
-//#region src/codegen/parser-v2.ts
-const PRIMITIVE_TYPES = new Set([
-	"Void",
-	"Bool",
-	"Int8",
-	"Int16",
-	"Int32",
-	"Int64",
-	"UInt8",
-	"UInt16",
-	"UInt32",
-	"UInt64",
-	"Float32",
-	"Float64",
-	"Text",
-	"Data"
-]);
-function isPrimitive(type) {
-	return PRIMITIVE_TYPES.has(type);
-}
-/**
-* 解析 Cap'n Proto schema
+//#region src/core/segment.ts
+/**
+* Cap'n Proto Segment 管理
+* 纯 TypeScript 实现
+*/
+const WORD_SIZE = 8;
+var Segment = class Segment {
+	buffer;
+	view;
+	_size;
+	constructor(initialCapacity = 1024) {
+		this.buffer = new ArrayBuffer(initialCapacity);
+		this.view = new DataView(this.buffer);
+		this._size = 0;
+	}
+	/**
+	* 从现有 buffer 创建（用于读取）
+	*/
+	static fromBuffer(buffer) {
+		const seg = new Segment(0);
+		seg.buffer = buffer;
+		seg.view = new DataView(buffer);
+		seg._size = buffer.byteLength;
+		return seg;
+	}
+	/**
+	* 确保容量足够
+	*/
+	ensureCapacity(minBytes) {
+		if (this.buffer.byteLength >= minBytes) return;
+		let newCapacity = this.buffer.byteLength * 2;
+		while (newCapacity < minBytes) newCapacity *= 2;
+		const newBuffer = new ArrayBuffer(newCapacity);
+		new Uint8Array(newBuffer).set(new Uint8Array(this.buffer, 0, this._size));
+		this.buffer = newBuffer;
+		this.view = new DataView(newBuffer);
+	}
+	/**
+	* 分配空间，返回字偏移
+	*/
+	allocate(words) {
+		const bytes = words * WORD_SIZE;
+		const offset = this._size;
+		this.ensureCapacity(offset + bytes);
+		this._size = offset + bytes;
+		return offset / WORD_SIZE;
+	}
+	/**
+	* 获取字（64位）
+	*/
+	getWord(wordOffset) {
+		const byteOffset = wordOffset * WORD_SIZE;
+		const low = BigInt(this.view.getUint32(byteOffset, true));
+		return BigInt(this.view.getUint32(byteOffset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 设置字（64位）
+	*/
+	setWord(wordOffset, value) {
+		const byteOffset = wordOffset * WORD_SIZE;
+		this.view.setUint32(byteOffset, Number(value & BigInt(4294967295)), true);
+		this.view.setUint32(byteOffset + 4, Number(value >> BigInt(32)), true);
+	}
+	/**
+	* 获取原始 buffer（只读到 _size）
+	*/
+	asUint8Array() {
+		return new Uint8Array(this.buffer, 0, this._size);
+	}
+	/**
+	* 获取底层 ArrayBuffer
+	*/
+	getArrayBuffer() {
+		return this.buffer;
+	}
+	/**
+	* 获取字数量
+	*/
+	get wordCount() {
+		return this._size / WORD_SIZE;
+	}
+	/**
+	* 获取字节数量
+	*/
+	get byteLength() {
+		return this._size;
+	}
+	/**
+	* 获取 DataView
+	*/
+	get dataView() {
+		return this.view;
+	}
+};
+
+//#endregion
+//#region src/core/list.ts
+/**
+* ListReader - 读取列表
+*/
+var ListReader = class {
+	segment;
+	startOffset;
+	segmentIndex;
+	constructor(message, segmentIndex, elementSize, elementCount, structSize, wordOffset) {
+		this.message = message;
+		this.elementSize = elementSize;
+		this.elementCount = elementCount;
+		this.structSize = structSize;
+		this.segmentIndex = segmentIndex;
+		this.segment = message.getSegment(segmentIndex);
+		this.startOffset = wordOffset;
+	}
+	/**
+	* 列表长度
+	*/
+	get length() {
+		return this.elementCount;
+	}
+	/**
+	* 获取元素（基础类型）
+	*/
+	getPrimitive(index) {
+		if (index < 0 || index >= this.elementCount) throw new RangeError("Index out of bounds");
+		switch (this.elementSize) {
+			case ElementSize.BIT: {
+				const byteOffset = Math.floor(index / 8);
+				const bitInByte = index % 8;
+				return (this.segment.dataView.getUint8(this.startOffset * WORD_SIZE + byteOffset) & 1 << bitInByte) !== 0 ? 1 : 0;
+			}
+			case ElementSize.BYTE: return this.segment.dataView.getUint8(this.startOffset * WORD_SIZE + index);
+			case ElementSize.TWO_BYTES: return this.segment.dataView.getUint16(this.startOffset * WORD_SIZE + index * 2, true);
+			case ElementSize.FOUR_BYTES: return this.segment.dataView.getUint32(this.startOffset * WORD_SIZE + index * 4, true);
+			case ElementSize.EIGHT_BYTES: {
+				const offset = this.startOffset * WORD_SIZE + index * 8;
+				const low = BigInt(this.segment.dataView.getUint32(offset, true));
+				return BigInt(this.segment.dataView.getUint32(offset + 4, true)) << BigInt(32) | low;
+			}
+			default: throw new Error(`Unsupported element size: ${this.elementSize}`);
+		}
+	}
+	/**
+	* 获取结构元素
+	*/
+	getStruct(index) {
+		if (!this.structSize) throw new Error("Not a struct list");
+		const { dataWords, pointerCount } = this.structSize;
+		const size = dataWords + pointerCount;
+		const offset = this.startOffset + index * size;
+		return new StructReader(this.message, this.segmentIndex, offset, dataWords, pointerCount);
+	}
+	/**
+	* 迭代器
+	*/
+	*[Symbol.iterator]() {
+		for (let i = 0; i < this.elementCount; i++) yield this.getPrimitive(i);
+	}
+};
+
+//#endregion
+//#region src/core/message-reader.ts
+/**
+* Cap'n Proto MessageReader
+* 纯 TypeScript 实现
+*/
+var MessageReader = class {
+	segments;
+	constructor(buffer) {
+		const uint8Array = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+		this.segments = [];
+		if (uint8Array.byteLength < 8) return;
+		const view = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
+		const firstWordLow = view.getUint32(0, true);
+		const firstWordHigh = view.getUint32(4, true);
+		const segmentCount = (firstWordLow & 4294967295) + 1;
+		const firstSegmentSize = firstWordHigh;
+		let offset = 8;
+		const segmentSizes = [firstSegmentSize];
+		for (let i = 1; i < segmentCount; i++) {
+			if (offset + 4 > uint8Array.byteLength) {
+				this.segments = [];
+				return;
+			}
+			segmentSizes.push(view.getUint32(offset, true));
+			offset += 4;
+		}
+		offset = offset + 7 & -8;
+		if (offset > uint8Array.byteLength) {
+			this.segments = [];
+			return;
+		}
+		this.segments = [];
+		for (const size of segmentSizes) {
+			if (offset + size * WORD_SIZE > uint8Array.byteLength) break;
+			const segmentBuffer = uint8Array.slice(offset, offset + size * WORD_SIZE);
+			this.segments.push(Segment.fromBuffer(segmentBuffer.buffer));
+			offset += size * WORD_SIZE;
+		}
+	}
+	/**
+	* 获取根结构
+	*/
+	getRoot(_dataWords, _pointerCount) {
+		const segment = this.segments[0];
+		const ptr = decodePointer(segment.getWord(0));
+		if (ptr.tag === PointerTag.STRUCT) {
+			const structPtr = ptr;
+			const dataOffset = 1 + structPtr.offset;
+			return new StructReader(this, 0, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+		}
+		if (ptr.tag === PointerTag.FAR) {
+			const farPtr = ptr;
+			const targetSegment = this.getSegment(farPtr.targetSegment);
+			if (!targetSegment) throw new Error(`Far pointer references non-existent segment ${farPtr.targetSegment}`);
+			if (farPtr.doubleFar) {
+				const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+				if (landingPadPtr.tag !== PointerTag.FAR) throw new Error("Double-far landing pad is not a far pointer");
+				const innerFarPtr = landingPadPtr;
+				const finalSegment = this.getSegment(innerFarPtr.targetSegment);
+				if (!finalSegment) throw new Error(`Double-far references non-existent segment ${innerFarPtr.targetSegment}`);
+				const structPtr = decodePointer(finalSegment.getWord(innerFarPtr.targetOffset));
+				const dataOffset = innerFarPtr.targetOffset + 1 + structPtr.offset;
+				return new StructReader(this, innerFarPtr.targetSegment, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+			}
+			const structPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+			const dataOffset = farPtr.targetOffset + 1 + structPtr.offset;
+			return new StructReader(this, farPtr.targetSegment, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+		}
+		throw new Error(`Root pointer is not a struct or far pointer: ${ptr.tag}`);
+	}
+	/**
+	* 获取段
+	*/
+	getSegment(index) {
+		return this.segments[index];
+	}
+	/**
+	* 解析指针，处理 far pointer 间接寻址
+	* 返回 { segmentIndex, wordOffset, pointer }，其中 pointer 是实际的 struct/list 指针
+	*/
+	resolvePointer(segmentIndex, wordOffset) {
+		const segment = this.getSegment(segmentIndex);
+		if (!segment) return null;
+		const ptrValue = segment.getWord(wordOffset);
+		if (ptrValue === 0n) return null;
+		const ptr = decodePointer(ptrValue);
+		if (ptr.tag === PointerTag.STRUCT || ptr.tag === PointerTag.LIST) return {
+			segmentIndex,
+			wordOffset: wordOffset + 1 + ptr.offset,
+			pointer: ptr
+		};
+		if (ptr.tag === PointerTag.FAR) {
+			const farPtr = ptr;
+			const targetSegment = this.getSegment(farPtr.targetSegment);
+			if (!targetSegment) return null;
+			if (farPtr.doubleFar) {
+				const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+				if (landingPadPtr.tag !== PointerTag.FAR) return null;
+				const innerFarPtr = landingPadPtr;
+				const finalSegment = this.getSegment(innerFarPtr.targetSegment);
+				if (!finalSegment) return null;
+				const finalPtr = decodePointer(finalSegment.getWord(innerFarPtr.targetOffset));
+				if (finalPtr.tag !== PointerTag.STRUCT && finalPtr.tag !== PointerTag.LIST) return null;
+				const targetOffset = innerFarPtr.targetOffset + 1 + finalPtr.offset;
+				return {
+					segmentIndex: innerFarPtr.targetSegment,
+					wordOffset: targetOffset,
+					pointer: finalPtr
+				};
+			}
+			const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+			if (landingPadPtr.tag !== PointerTag.STRUCT && landingPadPtr.tag !== PointerTag.LIST) return null;
+			const targetOffset = farPtr.targetOffset + 1 + landingPadPtr.offset;
+			return {
+				segmentIndex: farPtr.targetSegment,
+				wordOffset: targetOffset,
+				pointer: landingPadPtr
+			};
+		}
+		return null;
+	}
+	/**
+	* 段数量
+	*/
+	get segmentCount() {
+		return this.segments.length;
+	}
+};
+/**
+* 结构读取器
+*/
+var StructReader = class StructReader {
+	constructor(message, segmentIndex, wordOffset, dataWords, pointerCount) {
+		this.message = message;
+		this.segmentIndex = segmentIndex;
+		this.wordOffset = wordOffset;
+		this.dataWords = dataWords;
+		this.pointerCount = pointerCount;
+	}
+	/**
+	* 获取 bool 字段
+	*/
+	getBool(bitOffset) {
+		const byteOffset = Math.floor(bitOffset / 8);
+		const bitInByte = bitOffset % 8;
+		return (this.message.getSegment(this.segmentIndex).dataView.getUint8(this.wordOffset * WORD_SIZE + byteOffset) & 1 << bitInByte) !== 0;
+	}
+	/**
+	* 获取 int8 字段
+	*/
+	getInt8(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt8(this.wordOffset * WORD_SIZE + byteOffset);
+	}
+	/**
+	* 获取 int16 字段
+	*/
+	getInt16(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt16(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 int32 字段
+	*/
+	getInt32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 int64 字段
+	*/
+	getInt64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		const low = BigInt(segment.dataView.getUint32(offset, true));
+		return BigInt(segment.dataView.getInt32(offset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 获取 uint8 字段
+	*/
+	getUint8(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint8(this.wordOffset * WORD_SIZE + byteOffset);
+	}
+	/**
+	* 获取 uint16 字段
+	*/
+	getUint16(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint16(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 uint32 字段
+	*/
+	getUint32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 uint64 字段
+	*/
+	getUint64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		const low = BigInt(segment.dataView.getUint32(offset, true));
+		return BigInt(segment.dataView.getUint32(offset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 获取 float32 字段
+	*/
+	getFloat32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getFloat32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 float64 字段
+	*/
+	getFloat64(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getFloat64(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取文本字段
+	*/
+	getText(pointerIndex) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return "";
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.LIST) return "";
+		const listPtr = pointer;
+		const segment = this.message.getSegment(segmentIndex);
+		const byteLength = listPtr.elementCount > 0 ? listPtr.elementCount - 1 : 0;
+		if (byteLength === 0) return "";
+		const bytes = new Uint8Array(segment.dataView.buffer, wordOffset * WORD_SIZE, byteLength);
+		return new TextDecoder().decode(bytes);
+	}
+	/**
+	* 获取嵌套结构
+	*/
+	getStruct(pointerIndex, _dataWords, _pointerCount) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return void 0;
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.STRUCT) return void 0;
+		const structPtr = pointer;
+		return new StructReader(this.message, segmentIndex, wordOffset, structPtr.dataWords, structPtr.pointerCount);
+	}
+	/**
+	* 获取列表
+	*/
+	getList(pointerIndex, _elementSize, structSize) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return void 0;
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.LIST) return void 0;
+		const listPtr = pointer;
+		let targetOffset = wordOffset;
+		let elementCount = listPtr.elementCount;
+		let actualStructSize = structSize;
+		const segment = this.message.getSegment(segmentIndex);
+		if (listPtr.elementSize === ElementSize.COMPOSITE) {
+			const tagWord = segment.getWord(targetOffset);
+			elementCount = Number(tagWord & BigInt(4294967295));
+			actualStructSize = {
+				dataWords: Number(tagWord >> BigInt(32) & BigInt(65535)),
+				pointerCount: Number(tagWord >> BigInt(48) & BigInt(65535))
+			};
+			targetOffset += 1;
+		}
+		return new ListReader(this.message, segmentIndex, listPtr.elementSize, elementCount, actualStructSize, targetOffset);
+	}
+};
+
+//#endregion
+//#region src/schema/schema-reader.ts
+/**
+* Cap'n Proto 编译后 Schema 的 TypeScript Reader
+* 基于官方 schema.capnp 手动编写
 *
-* 支持的语法：
-* - Struct 定义
-* - Enum 定义
-* - 基础类型字段
-* - List 类型
-* - 嵌套 struct 引用
+* 这是自举的基础：我们需要先能读取 schema 才能生成 schema 的代码
 *
-* 不支持的语法（会忽略或报错）：
-* - Union
-* - Group
-* - Interface
-* - Const
-* - Annotation
-* - 默认值
-*/
-function parseSchemaV2(source) {
-	const structs = [];
-	const enums = [];
-	const cleanSource = source.replace(/#.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-	const structRegex = /struct\s+(\w+)\s*\{([^}]*)\}/g;
-	let match;
-	while ((match = structRegex.exec(cleanSource)) !== null) {
-		const name = match[1];
-		const body = match[2];
-		const fields = parseFields(body);
-		structs.push({
-			name,
-			fields
+* 结构信息来自: capnp compile -ocapnp schema.capnp
+*/
+var NodeReader = class {
+	constructor(reader) {
+		this.reader = reader;
+	}
+	get id() {
+		return this.reader.getUint64(0);
+	}
+	get displayName() {
+		return this.reader.getText(0);
+	}
+	get displayNamePrefixLength() {
+		return this.reader.getUint32(8);
+	}
+	get scopeId() {
+		return this.reader.getUint64(16);
+	}
+	/** union tag 在 bits [96, 112) = bytes [12, 14) */
+	get unionTag() {
+		return this.reader.getUint16(12);
+	}
+	get isFile() {
+		return this.unionTag === 0;
+	}
+	get isStruct() {
+		return this.unionTag === 1;
+	}
+	get isEnum() {
+		return this.unionTag === 2;
+	}
+	get isInterface() {
+		return this.unionTag === 3;
+	}
+	get isConst() {
+		return this.unionTag === 4;
+	}
+	get isAnnotation() {
+		return this.unionTag === 5;
+	}
+	get structDataWordCount() {
+		return this.reader.getUint16(14);
+	}
+	get structPointerCount() {
+		return this.reader.getUint16(24);
+	}
+	get structPreferredListEncoding() {
+		return this.reader.getUint16(26);
+	}
+	get structIsGroup() {
+		return this.reader.getBool(224);
+	}
+	get structDiscriminantCount() {
+		return this.reader.getUint16(30);
+	}
+	get structDiscriminantOffset() {
+		return this.reader.getUint32(32);
+	}
+	get structFields() {
+		const listReader = this.reader.getList(3, ElementSize.INLINE_COMPOSITE, {
+			dataWords: 3,
+			pointerCount: 4
 		});
+		if (!listReader) return [];
+		const fields = [];
+		for (let i = 0; i < listReader.length; i++) {
+			const field = new FieldReader(listReader.getStruct(i));
+			if (!field.name && i > 0) break;
+			fields.push(field);
+		}
+		return fields;
 	}
-	const enumRegex = /enum\s+(\w+)\s*\{([^}]*)\}/g;
-	while ((match = enumRegex.exec(cleanSource)) !== null) {
-		const name = match[1];
-		const body = match[2];
-		const values = parseEnumValues(body);
-		enums.push({
-			name,
-			values
+	get enumEnumerants() {
+		const listReader = this.reader.getList(3, ElementSize.INLINE_COMPOSITE, {
+			dataWords: 1,
+			pointerCount: 2
 		});
+		if (!listReader) return [];
+		const enumerants = [];
+		for (let i = 0; i < Math.min(listReader.length, 10); i++) try {
+			const enumerant = new EnumerantReader(listReader.getStruct(i));
+			if (!enumerant.name) break;
+			enumerants.push(enumerant);
+		} catch (_e) {
+			break;
+		}
+		return enumerants;
 	}
-	return {
-		structs,
-		enums
-	};
-}
-function parseFields(body) {
-	const fields = [];
-	const fieldRegex = /(\w+)\s*@(\d+)\s*:\s*([^;]+);/g;
-	let match;
-	while ((match = fieldRegex.exec(body)) !== null) {
-		const name = match[1];
-		const index = Number.parseInt(match[2]);
-		const type = parseType(match[3].trim());
-		fields.push({
-			name,
-			index,
-			type
+	get interfaceMethods() {
+		const listReader = this.reader.getList(3, ElementSize.INLINE_COMPOSITE, {
+			dataWords: 5,
+			pointerCount: 2
 		});
+		if (!listReader) return [];
+		const methods = [];
+		for (let i = 0; i < listReader.length; i++) try {
+			const method = new MethodReader(listReader.getStruct(i));
+			if (!method.name && i > 0) break;
+			methods.push(method);
+		} catch (_e) {
+			break;
+		}
+		return methods;
 	}
-	return fields.sort((a, b) => a.index - b.index);
-}
-function parseType(typeStr) {
-	const listMatch = typeStr.match(/^List\((.+)\)$/);
-	if (listMatch) return {
-		kind: "list",
-		elementType: parseType(listMatch[1].trim())
-	};
-	if (isPrimitive(typeStr)) return typeStr;
-	return {
-		kind: "struct",
-		name: typeStr
-	};
-}
-function parseEnumValues(body) {
-	const values = [];
-	const valueRegex = /(\w+)\s*@(\d+)\s*;/g;
-	let match;
-	while ((match = valueRegex.exec(body)) !== null) {
-		const name = match[1];
-		const index = Number.parseInt(match[2]);
-		values.push({
-			name,
-			index
+	get nestedNodes() {
+		const listReader = this.reader.getList(1, ElementSize.INLINE_COMPOSITE, {
+			dataWords: 1,
+			pointerCount: 1
 		});
+		if (!listReader) return [];
+		const nodes = [];
+		for (let i = 0; i < listReader.length; i++) {
+			const itemReader = listReader.getStruct(i);
+			nodes.push(new NestedNodeReader(itemReader));
+		}
+		return nodes;
 	}
-	return values.sort((a, b) => a.index - b.index);
-}
+};
+var FieldReader = class {
+	constructor(reader) {
+		this.reader = reader;
+	}
+	get name() {
+		return this.reader.getText(0);
+	}
+	get codeOrder() {
+		return this.reader.getUint16(0);
+	}
+	get discriminantValue() {
+		return this.reader.getUint16(2);
+	}
+	/** union tag 在 bits [64, 80) = bytes [8, 10) */
+	get unionTag() {
+		return this.reader.getUint16(8);
+	}
+	get isSlot() {
+		return this.unionTag === 0;
+	}
+	get isGroup() {
+		return this.unionTag === 1;
+	}
+	get slotOffset() {
+		return this.reader.getUint32(4);
+	}
+	get slotType() {
+		const typeReader = this.reader.getStruct(2, 3, 1);
+		return typeReader ? new TypeReader(typeReader) : null;
+	}
+	get groupTypeId() {
+		return this.reader.getUint64(16);
+	}
+	get defaultValue() {
+		const valueReader = this.reader.getStruct(3, 2, 1);
+		return valueReader ? new ValueReader(valueReader) : null;
+	}
+};
+var TypeReader = class TypeReader {
+	constructor(reader) {
+		this.reader = reader;
+	}
+	get kind() {
+		return TYPE_KIND_MAP[this.reader.getUint16(0)] ?? "unknown";
+	}
+	get isPrimitive() {
+		const k = this.kind;
+		return k !== "list" && k !== "enum" && k !== "struct" && k !== "interface" && k !== "anyPointer";
+	}
+	get listElementType() {
+		if (this.kind !== "list") return null;
+		const elementReader = this.reader.getStruct(0, 3, 1);
+		return elementReader ? new TypeReader(elementReader) : null;
+	}
+	get typeId() {
+		const k = this.kind;
+		if (k === "enum" || k === "struct" || k === "interface") return this.reader.getUint64(8);
+		return null;
+	}
+};
+const TYPE_KIND_MAP = {
+	0: "void",
+	1: "bool",
+	2: "int8",
+	3: "int16",
+	4: "int32",
+	5: "int64",
+	6: "uint8",
+	7: "uint16",
+	8: "uint32",
+	9: "uint64",
+	10: "float32",
+	11: "float64",
+	12: "text",
+	13: "data",
+	14: "list",
+	15: "enum",
+	16: "struct",
+	17: "interface",
+	18: "anyPointer"
+};
+var ValueReader = class {
+	constructor(reader) {
+		this.reader = reader;
+	}
+	/** union tag 在 bits [0, 16) = bytes [0, 2) */
+	get unionTag() {
+		return this.reader.getUint16(0);
+	}
+	get isVoid() {
+		return this.unionTag === 0;
+	}
+	get isBool() {
+		return this.unionTag === 1;
+	}
+	get isInt8() {
+		return this.unionTag === 2;
+	}
+	get isInt16() {
+		return this.unionTag === 3;
+	}
+	get isInt32() {
+		return this.unionTag === 4;
+	}
+	get isInt64() {
+		return this.unionTag === 5;
+	}
+	get isUint8() {
+		return this.unionTag === 6;
+	}
+	get isUint16() {
+		return this.unionTag === 7;
+	}
+	get isUint32() {
+		return this.unionTag === 8;
+	}
+	get isUint64() {
+		return this.unionTag === 9;
+	}
+	get isFloat32() {
+		return this.unionTag === 10;
+	}
+	get isFloat64() {
+		return this.unionTag === 11;
+	}
+	get isText() {
+		return this.unionTag === 12;
+	}
+	get isData() {
+		return this.unionTag === 13;
+	}
+	get isList() {
+		return this.unionTag === 14;
+	}
+	get isEnum() {
+		return this.unionTag === 15;
+	}
+	get isStruct() {
+		return this.unionTag === 16;
+	}
+	get isInterface() {
+		return this.unionTag === 17;
+	}
+	get isAnyPointer() {
+		return this.unionTag === 18;
+	}
+	get boolValue() {
+		return this.reader.getBool(16);
+	}
+	get int8Value() {
+		return this.reader.getInt8(2);
+	}
+	get int16Value() {
+		return this.reader.getInt16(2);
+	}
+	get int32Value() {
+		return this.reader.getInt32(4);
+	}
+	get int64Value() {
+		return this.reader.getInt64(8);
+	}
+	get uint8Value() {
+		return this.reader.getUint8(2);
+	}
+	get uint16Value() {
+		return this.reader.getUint16(2);
+	}
+	get uint32Value() {
+		return this.reader.getUint32(4);
+	}
+	get uint64Value() {
+		return this.reader.getUint64(8);
+	}
+	get float32Value() {
+		return this.reader.getFloat32(4);
+	}
+	get float64Value() {
+		return this.reader.getFloat64(8);
+	}
+	get enumValue() {
+		return this.reader.getUint16(2);
+	}
+	getAsNumber() {
+		if (this.isInt8) return this.int8Value;
+		if (this.isInt16) return this.int16Value;
+		if (this.isInt32) return this.int32Value;
+		if (this.isUint8) return this.uint8Value;
+		if (this.isUint16) return this.uint16Value;
+		if (this.isUint32) return this.uint32Value;
+		if (this.isFloat32) return this.float32Value;
+		if (this.isFloat64) return this.float64Value;
+		if (this.isEnum) return this.enumValue;
+	}
+	getAsBigint() {
+		if (this.isInt64) return this.int64Value;
+		if (this.isUint64) return this.uint64Value;
+	}
+	getAsBoolean() {
+		if (this.isBool) return this.boolValue;
+	}
+};
+var MethodReader = class {
+	constructor(reader) {
+		this.reader = reader;
+	}
+	get name() {
+		return this.reader.getText(0);
+	}
+	get codeOrder() {
+		return this.reader.getUint16(0);
+	}
+	get paramStructType() {
+		return this.reader.getUint64(8);
+	}
+	get resultStructType() {
+		return this.reader.getUint64(16);
+	}
+};
+var EnumerantReader = class {
+	constructor(reader) {
+		this.reader = reader;
+	}
+	get name() {
+		return this.reader.getText(0);
+	}
+	get codeOrder() {
+		return this.reader.getUint16(0);
+	}
+};
+var NestedNodeReader = class {
+	constructor(reader) {
+		this.reader = reader;
+	}
+	get name() {
+		return this.reader.getText(0);
+	}
+	get id() {
+		return this.reader.getUint64(0);
+	}
+};
+var CodeGeneratorRequestReader = class CodeGeneratorRequestReader {
+	constructor(message) {
+		this.message = message;
+	}
+	static fromBuffer(buffer) {
+		return new CodeGeneratorRequestReader(new MessageReader(buffer));
+	}
+	get nodes() {
+		const listReader = this.message.getRoot(0, 4).getList(0, ElementSize.INLINE_COMPOSITE, {
+			dataWords: 6,
+			pointerCount: 6
+		});
+		if (!listReader) return [];
+		const nodes = [];
+		for (let i = 0; i < listReader.length; i++) {
+			const nodeReader = listReader.getStruct(i);
+			nodes.push(new NodeReader(nodeReader));
+		}
+		return nodes;
+	}
+	get requestedFiles() {
+		const listReader = this.message.getRoot(0, 4).getList(1, ElementSize.INLINE_COMPOSITE, {
+			dataWords: 1,
+			pointerCount: 2
+		});
+		if (!listReader) return [];
+		const files = [];
+		for (let i = 0; i < listReader.length; i++) try {
+			const file = new RequestedFileReader(listReader.getStruct(i));
+			if (!file.filename && files.length > 0) break;
+			files.push(file);
+		} catch (_e) {
+			break;
+		}
+		return files;
+	}
+};
+var RequestedFileReader = class {
+	constructor(reader) {
+		this.reader = reader;
+	}
+	get id() {
+		return this.reader.getUint64(0);
+	}
+	get filename() {
+		return this.reader.getText(0);
+	}
+};
 
 //#endregion
 //#region src/cli.ts
@@ -339,55 +1715,514 @@ const { values, positionals } = parseArgs({
 			type: "string",
 			short: "o"
 		},
+		outDir: {
+			type: "string",
+			short: "d"
+		},
+		runtimePath: {
+			type: "string",
+			short: "r"
+		},
+		dynamic: {
+			type: "boolean",
+			short: "D"
+		},
+		interactive: {
+			type: "boolean",
+			short: "i"
+		},
 		help: {
 			type: "boolean",
 			short: "h"
+		},
+		version: {
+			type: "boolean",
+			short: "v"
 		}
 	},
 	allowPositionals: true
 });
+const VERSION = "3.0.0";
+if (values.version) {
+	console.log(VERSION);
+	process.exit(0);
+}
 if (values.help || positionals.length === 0) {
 	console.log(`
-Cap'n Proto TypeScript CLI
+Cap'n Proto TypeScript Code Generator v3
 
-Usage:
-  capnp gen <schema.capnp> [options]    Generate TypeScript from schema
-  capnp --help                          Show this help
+Usage: capnp-ts-codegen <schema.capnp> [options]
 
 Options:
-  -o, --output    Output file (default: stdout)
-  -h, --help      Show this help
+  -o, --output       Output file (default: stdout for single file)
+  -d, --outDir       Output directory for multiple files
+  -r, --runtimePath  Runtime library import path (default: @naeemo/capnp)
+  -D, --dynamic      Generate dynamic schema loading code
+  -i, --interactive  Start interactive schema query tool
+  -h, --help         Show this help
+  -v, --version      Show version
 
 Examples:
-  npx @naeemo/capnp gen schema.capnp -o types.ts
-  capnp gen schema.capnp > types.ts
+  capnp-ts-codegen schema.capnp -o schema.ts
+  capnp-ts-codegen schema.capnp -d ./generated
+  capnp-ts-codegen schema.capnp -o schema.ts -r ../runtime
+  capnp-ts-codegen schema.capnp -D -o schema-dynamic.ts
+  capnp-ts-codegen schema.capnp -i
+
+Features:
+  - Struct with all primitive types
+  - Enum
+  - List<T>
+  - Text, Data
+  - Nested struct references
+  - Union (discriminant handling)
+  - Group
+  - Default values (XOR encoding)
+  - Multi-segment messages
+  - Interface (RPC client/server generation)
+  - Dynamic schema loading (Phase 7)
+
+Not yet supported:
+  - Const
+  - Advanced RPC features (Level 2-4)
 `);
 	process.exit(0);
 }
-const command = positionals[0];
-if (command !== "gen") {
-	console.error(`Unknown command: ${command}`);
-	console.error("Run \"capnp --help\" for usage");
+const inputFile = positionals[0];
+if (!existsSync(inputFile)) {
+	console.error(`Error: File not found: ${inputFile}`);
 	process.exit(1);
 }
-const inputFile = positionals[1];
-if (!inputFile) {
-	console.error("Error: Missing input file");
-	console.error("Usage: capnp gen <schema.capnp>");
-	process.exit(1);
+function checkCapnpTool() {
+	try {
+		execSync("capnp --version", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
 }
-const outputFile = values.output;
 async function main() {
-	const code = generateCode(parseSchemaV2(readFileSync(inputFile, "utf-8")));
-	if (outputFile) {
-		writeFileSync(outputFile, code);
-		console.error(`Generated: ${outputFile}`);
-	} else console.log(code);
-}
-main().catch((err) => {
-	console.error("Error:", err.message);
-	process.exit(1);
-});
+	if (values.interactive) {
+		await runInteractiveMode(inputFile);
+		return;
+	}
+	if (!checkCapnpTool()) {
+		console.error("Error: capnp tool not found. Please install Cap'n Proto.");
+		console.error("  macOS: brew install capnp");
+		console.error("  Ubuntu/Debian: apt-get install capnproto");
+		console.error("  Other: https://capnproto.org/install.html");
+		process.exit(1);
+	}
+	const tmpDir = mkdtempSync(join(tmpdir(), "capnp-ts-"));
+	const binFile = join(tmpDir, "schema.bin");
+	try {
+		console.error(`Compiling ${inputFile}...`);
+		const inputDir = dirname(inputFile);
+		execSync(`capnp compile -o- "${inputFile}" > "${binFile}"`, {
+			cwd: inputDir,
+			stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			]
+		});
+		console.error("Reading binary schema...");
+		const buffer = readFileSync(binFile);
+		const arrayBuffer = new Uint8Array(buffer.byteLength);
+		arrayBuffer.set(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength));
+		if (values.dynamic) {
+			console.error("Generating dynamic schema loading code...");
+			const dynamicCode = generateDynamicLoadingCode(inputFile, arrayBuffer.buffer);
+			if (values.output) {
+				writeFileSync(values.output, dynamicCode);
+				console.error(`Dynamic loading code written to ${values.output}`);
+			} else console.log(dynamicCode);
+			return;
+		}
+		console.error("Generating TypeScript code...");
+		const files = generateFromRequest(CodeGeneratorRequestReader.fromBuffer(arrayBuffer.buffer), { runtimeImportPath: values.runtimePath || "@naeemo/capnp" });
+		if (values.outDir) {
+			mkdirSync(values.outDir, { recursive: true });
+			for (const [filename, code] of files) {
+				const outPath = join(values.outDir, filename);
+				mkdirSync(dirname(outPath), { recursive: true });
+				writeFileSync(outPath, code);
+				console.error(`Generated: ${outPath}`);
+			}
+		} else if (values.output) {
+			const firstFile = files.values().next().value;
+			if (firstFile) {
+				writeFileSync(values.output, firstFile);
+				console.error(`Output written to ${values.output}`);
+			} else {
+				console.error("Error: No files generated");
+				process.exit(1);
+			}
+		} else {
+			const firstFile = files.values().next().value;
+			if (firstFile) console.log(firstFile);
+			else {
+				console.error("Error: No files generated");
+				process.exit(1);
+			}
+		}
+	} catch (err) {
+		console.error("Error:", err.message);
+		if (err.stderr) console.error(err.stderr.toString());
+		process.exit(1);
+	} finally {
+		rmSync(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+main();
+/**
+* Generate dynamic schema loading code for the given schema file
+*/
+function generateDynamicLoadingCode(inputFile, buffer) {
+	const nodes = CodeGeneratorRequestReader.fromBuffer(buffer).nodes;
+	const runtimePath = values.runtimePath || "@naeemo/capnp";
+	const schemaName = basename(inputFile, ".capnp");
+	const structTypes = [];
+	const interfaceTypes = [];
+	for (const node of nodes) {
+		const id = node.id;
+		const displayName = node.displayName;
+		const shortName = displayName.split(".").pop() || displayName;
+		if (node.isStruct) structTypes.push({
+			id: `0x${id.toString(16)}n`,
+			name: shortName,
+			displayName
+		});
+		else if (node.isInterface) interfaceTypes.push({
+			id: `0x${id.toString(16)}n`,
+			name: shortName,
+			displayName
+		});
+	}
+	return `/**
+ * Dynamic Schema Loading for ${schemaName}.capnp
+ * 
+ * This file provides runtime schema loading capabilities for ${schemaName}.capnp
+ * Generated by capnp-ts-codegen --dynamic
+ * 
+ * Usage:
+ *   import { load${toPascalCase(schemaName)}Schema, ${structTypes.map((t) => t.name).join(", ")} } from './${schemaName}-dynamic';
+ *   
+ *   // Load schema from remote connection
+ *   const schema = await load${toPascalCase(schemaName)}Schema(connection);
+ *   
+ *   // Use dynamic reader
+ *   const reader = createDynamicReader(schema.Person, buffer);
+ *   console.log(reader.get('name'));
+ */
+
+import { 
+  RpcConnection,
+  createDynamicReader, 
+  createDynamicWriter,
+  dumpDynamicReader,
+  type SchemaNode,
+  type SchemaRegistry,
+} from '${runtimePath}';
+
+// =============================================================================
+// Type IDs
+// =============================================================================
+
+${structTypes.map((t) => `/** Type ID for ${t.displayName} */\nexport const ${t.name}TypeId = ${t.id};`).join("\n")}
+
+${interfaceTypes.map((t) => `/** Interface ID for ${t.displayName} */\nexport const ${t.name}InterfaceId = ${t.id};`).join("\n")}
+
+// =============================================================================
+// Schema Cache
+// =============================================================================
+
+let cachedSchemaRegistry: SchemaRegistry | null = null;
+
+// =============================================================================
+// Schema Loading Functions
+// =============================================================================
+
+/**
+ * Load all schemas for ${schemaName}.capnp from a remote connection.
+ * This fetches schema information dynamically and caches it for reuse.
+ * 
+ * @param connection - The RPC connection to fetch schemas from
+ * @returns A registry containing all loaded schemas
+ */
+export async function load${toPascalCase(schemaName)}Schema(connection: RpcConnection): Promise<SchemaRegistry> {
+  if (cachedSchemaRegistry) {
+    return cachedSchemaRegistry;
+  }
+
+  // Fetch all schemas
+  const typeIds = [
+    ${structTypes.map((t) => `${t.name}TypeId`).join(",\n    ")}
+  ];
+
+  for (const typeId of typeIds) {
+    try {
+      await connection.getDynamicSchema(typeId);
+    } catch (err) {
+      console.warn(\`Failed to load schema for type \${typeId}:\`, err);
+    }
+  }
+
+  cachedSchemaRegistry = connection.getSchemaRegistry();
+  return cachedSchemaRegistry;
+}
+
+/**
+ * Get a specific schema node by type ID.
+ * Loads from remote if not already cached.
+ * 
+ * @param connection - The RPC connection
+ * @param typeId - The type ID to fetch
+ * @returns The schema node
+ */
+export async function getSchema(connection: RpcConnection, typeId: bigint): Promise<SchemaNode> {
+  return connection.getDynamicSchema(typeId);
+}
+
+/**
+ * Clear the schema cache.
+ * Call this if you need to re-fetch schemas from the remote server.
+ */
+export function clearSchemaCache(): void {
+  cachedSchemaRegistry = null;
+}
+
+// =============================================================================
+// Dynamic Reader Helpers
+// =============================================================================
+
+${structTypes.map((t) => `
+/**
+ * Create a dynamic reader for ${t.name}
+ * 
+ * @param buffer - The Cap'n Proto message buffer
+ * @param registry - Optional schema registry (will use cached if available)
+ * @returns A DynamicReader for the message
+ */
+export function create${toPascalCase(t.name)}Reader(
+  buffer: ArrayBuffer | Uint8Array,
+  registry?: SchemaRegistry
+): DynamicReader {
+  const reg = registry || cachedSchemaRegistry;
+  if (!reg) {
+    throw new Error('Schema registry not loaded. Call load${toPascalCase(schemaName)}Schema first.');
+  }
+  
+  const schema = reg.getNode(${t.name}TypeId);
+  if (!schema) {
+    throw new Error('Schema for ${t.name} not found in registry');
+  }
+  
+  return createDynamicReader(schema, buffer);
+}
+`).join("\n")}
+
+// =============================================================================
+// Utility Functions
+// =============================================================================
+
+/**
+ * Dump all fields from a dynamic reader for debugging
+ */
+export { dumpDynamicReader };
+
+/**
+ * List all available types in this schema
+ */
+export function listTypes(): Array<{ name: string; typeId: string; kind: 'struct' | 'interface' }> {
+  return [
+    ${structTypes.map((t) => `{ name: '${t.name}', typeId: '${t.id}', kind: 'struct' as const }`).join(",\n    ")},
+    ${interfaceTypes.map((t) => `{ name: '${t.name}', typeId: '${t.id}', kind: 'interface' as const }`).join(",\n    ")},
+  ];
+}
+`;
+}
+/**
+* Run interactive schema query tool
+*/
+async function runInteractiveMode(inputFile) {
+	if (!checkCapnpTool()) {
+		console.error("Error: capnp tool not found. Please install Cap'n Proto.");
+		process.exit(1);
+	}
+	const tmpDir = mkdtempSync(join(tmpdir(), "capnp-ts-"));
+	const binFile = join(tmpDir, "schema.bin");
+	try {
+		console.log(`\n🔍 Loading schema: ${inputFile}...\n`);
+		const inputDir = dirname(inputFile);
+		execSync(`capnp compile -o- "${inputFile}" > "${binFile}"`, {
+			cwd: inputDir,
+			stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			]
+		});
+		const buffer = readFileSync(binFile);
+		const arrayBuffer = new Uint8Array(buffer.byteLength);
+		arrayBuffer.set(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength));
+		const nodes = CodeGeneratorRequestReader.fromBuffer(arrayBuffer.buffer).nodes;
+		const typeIndex = /* @__PURE__ */ new Map();
+		for (const node of nodes) {
+			const id = node.id;
+			const displayName = node.displayName;
+			const shortName = displayName.split(".").pop() || displayName;
+			let kind = "unknown";
+			if (node.isStruct) kind = "struct";
+			else if (node.isInterface) kind = "interface";
+			else if (node.isEnum) kind = "enum";
+			else if (node.isConst) kind = "const";
+			typeIndex.set(shortName, {
+				id,
+				displayName,
+				kind,
+				node
+			});
+			typeIndex.set(displayName, {
+				id,
+				displayName,
+				kind,
+				node
+			});
+			typeIndex.set(id.toString(16), {
+				id,
+				displayName,
+				kind,
+				node
+			});
+		}
+		console.log("📋 Available types:");
+		console.log("─".repeat(60));
+		const structs = [];
+		const interfaces = [];
+		const enums = [];
+		for (const [name, info] of typeIndex) {
+			if (name.includes(".")) continue;
+			if (info.kind === "struct") structs.push(name);
+			else if (info.kind === "interface") interfaces.push(name);
+			else if (info.kind === "enum") enums.push(name);
+		}
+		if (structs.length > 0) {
+			console.log("\n🏗️  Structs:");
+			for (const name of structs.sort()) {
+				const info = typeIndex.get(name);
+				console.log(`   ${name.padEnd(30)} (0x${info.id.toString(16)})`);
+			}
+		}
+		if (interfaces.length > 0) {
+			console.log("\n🔌 Interfaces:");
+			for (const name of interfaces.sort()) {
+				const info = typeIndex.get(name);
+				console.log(`   ${name.padEnd(30)} (0x${info.id.toString(16)})`);
+			}
+		}
+		if (enums.length > 0) {
+			console.log("\n📊 Enums:");
+			for (const name of enums.sort()) {
+				const info = typeIndex.get(name);
+				console.log(`   ${name.padEnd(30)} (0x${info.id.toString(16)})`);
+			}
+		}
+		console.log(`\n${"─".repeat(60)}`);
+		console.log("💡 Commands:");
+		console.log("   inspect <type>  - Show detailed information about a type");
+		console.log("   ids             - List all type IDs");
+		console.log("   export          - Export schema info as JSON");
+		console.log("   quit            - Exit interactive mode");
+		console.log("");
+		const stdin = process.stdin;
+		const stdout = process.stdout;
+		stdin.setEncoding("utf8");
+		stdin.resume();
+		stdout.write("> ");
+		stdin.on("data", (data) => {
+			const line = data.trim();
+			const parts = line.split(/\s+/);
+			const command = parts[0];
+			const arg = parts[1];
+			switch (command) {
+				case "quit":
+				case "exit":
+				case "q":
+					console.log("👋 Goodbye!");
+					process.exit(0);
+					break;
+				case "inspect":
+					if (!arg) console.log("❌ Usage: inspect <type-name>");
+					else {
+						const info = typeIndex.get(arg);
+						if (info) {
+							console.log(`\n🔍 ${info.displayName}`);
+							console.log(`   ${"─".repeat(50)}`);
+							console.log(`   Type ID: 0x${info.id.toString(16)}`);
+							console.log(`   Kind: ${info.kind}`);
+							console.log("");
+						} else console.log(`❌ Type "${arg}" not found`);
+					}
+					break;
+				case "ids":
+					console.log("\n📋 All Type IDs:");
+					console.log(`   ${"─".repeat(50)}`);
+					for (const [name, info] of typeIndex) {
+						if (name.includes(".")) continue;
+						console.log(`   0x${info.id.toString(16).padStart(16, "0")}  ${info.displayName}`);
+					}
+					console.log("");
+					break;
+				case "export": {
+					const exportData = {
+						sourceFile: inputFile,
+						types: Array.from(typeIndex.entries()).filter(([name]) => !name.includes(".")).map(([name, info]) => ({
+							name,
+							displayName: info.displayName,
+							typeId: `0x${info.id.toString(16)}`,
+							kind: info.kind
+						}))
+					};
+					console.log(JSON.stringify(exportData, null, 2));
+					break;
+				}
+				case "help":
+				case "h":
+					console.log("\n💡 Commands:");
+					console.log("   inspect <type>  - Show detailed information about a type");
+					console.log("   ids             - List all type IDs");
+					console.log("   export          - Export schema info as JSON");
+					console.log("   quit            - Exit interactive mode");
+					console.log("");
+					break;
+				default: if (line) {
+					console.log(`❌ Unknown command: ${command}`);
+					console.log("   Type \"help\" for available commands");
+				}
+			}
+			stdout.write("> ");
+		});
+		await new Promise(() => {});
+	} catch (err) {
+		console.error("Error:", err.message);
+		process.exit(1);
+	} finally {
+		rmSync(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Convert string to PascalCase
+*/
+function toPascalCase(str) {
+	return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
 
 //#endregion
 export {  };