@naeemo/capnp 0.8.1 → 0.9.1

package/dist/cli.js

@@ -1,1802 +1,23 @@
 #!/usr/bin/env node
 #!/usr/bin/env node
-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/generator.ts
-const DEFAULT_OPTIONS = { runtimeImportPath: "@naeemo/capnp" };
+//#region src/cli-unified.ts
 /**
-* 从 CodeGeneratorRequest 生成 TypeScript 代码
-*/
-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");
-}
-/**
-* 生成 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 */ }`;
-	}
-}
-/**
-* 获取 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);
-}
-/**
-* 生成 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("}");
-	return lines.join("\n");
-}
-/**
-* 获取 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)}[]`;
-		}
-		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("");
-	lines.push(`// ${interfaceName} Server Stub`);
-	lines.push(`export class ${interfaceName}Stub {`);
-	lines.push(`  private server: ${interfaceName}Server;`);
-	lines.push("");
-	lines.push(`  constructor(server: ${interfaceName}Server) {`);
-	lines.push("    this.server = server;");
-	lines.push("  }");
-	lines.push("");
-	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("");
-	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("}");
-	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/core/pointer.ts
-/**
-* Cap'n Proto 指针编解码
-* 纯 TypeScript 实现
-*/
-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/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;
-		if (byteOffset + 8 > this._size) throw new Error(`Offset ${wordOffset} is outside the bounds of the segment (${this.wordCount} words)`);
-		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;
-		if (byteOffset + 8 > this.buffer.byteLength) throw new Error(`Offset ${wordOffset} is outside the bounds of the segment`);
-		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;
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return false;
-		return (segment.dataView.getUint8(dataOffset) & 1 << bitInByte) !== 0;
-	}
-	/**
-	* 获取 int8 字段
-	*/
-	getInt8(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return 0;
-		return segment.dataView.getInt8(dataOffset);
-	}
-	/**
-	* 获取 int16 字段
-	*/
-	getInt16(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset + 2 > dataSectionEnd) return 0;
-		return segment.dataView.getInt16(dataOffset, true);
-	}
-	/**
-	* 获取 int32 字段
-	*/
-	getInt32(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
-		return segment.dataView.getInt32(dataOffset, true);
-	}
-	/**
-	* 获取 int64 字段
-	*/
-	getInt64(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return BigInt(0);
-		const low = BigInt(segment.dataView.getUint32(dataOffset, true));
-		return BigInt(segment.dataView.getInt32(dataOffset + 4, true)) << BigInt(32) | low;
-	}
-	/**
-	* 获取 uint8 字段
-	*/
-	getUint8(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset >= dataSectionEnd) return 0;
-		return segment.dataView.getUint8(dataOffset);
-	}
-	/**
-	* 获取 uint16 字段
-	*/
-	getUint16(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset + 2 > dataSectionEnd) return 0;
-		return segment.dataView.getUint16(dataOffset, true);
-	}
-	/**
-	* 获取 uint32 字段
-	*/
-	getUint32(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
-		return segment.dataView.getUint32(dataOffset, true);
-	}
-	/**
-	* 获取 uint64 字段
-	*/
-	getUint64(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return BigInt(0);
-		const low = BigInt(segment.dataView.getUint32(dataOffset, true));
-		return BigInt(segment.dataView.getUint32(dataOffset + 4, true)) << BigInt(32) | low;
-	}
-	/**
-	* 获取 float32 字段
-	*/
-	getFloat32(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset + 4 > dataSectionEnd) return 0;
-		return segment.dataView.getFloat32(dataOffset, true);
-	}
-	/**
-	* 获取 float64 字段
-	*/
-	getFloat64(byteOffset) {
-		const segment = this.message.getSegment(this.segmentIndex);
-		const dataOffset = this.wordOffset * WORD_SIZE + byteOffset;
-		const dataSectionEnd = this.wordOffset * WORD_SIZE + this.dataWords * WORD_SIZE;
-		if (dataOffset < 0 || dataOffset + 8 > dataSectionEnd) return 0;
-		return segment.dataView.getFloat64(dataOffset, 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);
-	}
-	/**
-	* 获取数据字段
-	* Data is stored as List(UInt8) without NUL terminator
-	* @param pointerIndex - The index of the pointer in the pointer section
-	* @returns Uint8Array of the data content, or undefined if null pointer
-	*/
-	getData(pointerIndex) {
-		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;
-		const segment = this.message.getSegment(segmentIndex);
-		const byteLength = listPtr.elementCount;
-		if (byteLength === 0) return new Uint8Array(0);
-		const bytes = new Uint8Array(segment.dataView.buffer, wordOffset * WORD_SIZE, byteLength);
-		return new Uint8Array(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) {
-			if (targetOffset < 0 || targetOffset >= segment.wordCount) return;
-			try {
-				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;
-			} catch {
-				return;
-			}
-		}
-		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 手动编写
+* Cap'n Proto Unified CLI
 *
-* 这是自举的基础：我们需要先能读取 schema 才能生成 schema 的代码
+* Usage: capnp <command> [options]
 *
-* 结构信息来自: 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;
-	}
-	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;
-	}
-	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;
-	}
-	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;
-	}
-};
-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
-/**
-* Cap'n Proto CLI
-*
-* Usage:
-*   capnp gen schema.capnp -o types.ts
+* Commands:
+*   gen       Generate TypeScript code from schema
+*   json      Convert between Cap'n Proto and JSON
+*   compat    Check schema compatibility
+*   audit     Security audit message files
+*   help      Show help for a command
 */
 const { values, positionals } = parseArgs({
 	args: process.argv.slice(2),
 	options: {
-		output: {
-			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"
@@ -1806,489 +27,99 @@ const { values, positionals } = parseArgs({
 			short: "v"
 		}
 	},
-	allowPositionals: true
+	allowPositionals: true,
+	strict: false
 });
-const VERSION = "3.0.0";
-if (values.version) {
-	console.log(VERSION);
-	process.exit(0);
-}
-if (values.help || positionals.length === 0) {
+const VERSION = "0.9.1";
+function printMainUsage() {
 	console.log(`
-Cap'n Proto TypeScript Code Generator v3
+Cap'n Proto TypeScript CLI v${VERSION}
+
+Usage: capnp <command> [options]
 
-Usage: capnp-ts-codegen <schema.capnp> [options]
+Commands:
+  gen       Generate TypeScript code from .capnp schema
+  json      Convert between Cap'n Proto binary and JSON
+  compat    Check schema compatibility between versions
+  audit     Security audit message files
+  bench     Run performance benchmarks
 
 Options:
-  -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
+  -h, --help     Show this help
+  -v, --version  Show version
 
 Examples:
-  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)
+  capnp gen schema.capnp -o types.ts
+  capnp json to-json -i data.bin -s schema.json
+  capnp compat old.json new.json
+  capnp audit message.bin
+  capnp bench --sizes 1KB,10KB,100KB --vs-json
 
-Not yet supported:
-  - Const
-  - Advanced RPC features (Level 2-4)
+Run 'capnp <command> --help' for more information on a command.
 `);
-	process.exit(0);
-}
-const inputFile = positionals[0];
-if (!existsSync(inputFile)) {
-	console.error(`Error: File not found: ${inputFile}`);
-	process.exit(1);
-}
-function checkCapnpTool() {
-	try {
-		execSync("capnp --version", { stdio: "ignore" });
-		return true;
-	} catch {
-		return false;
-	}
 }
 async function main() {
-	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");
+	if (values.version) {
+		console.log(VERSION);
+		process.exit(0);
+	}
+	if (values.help || positionals.length === 0) {
+		printMainUsage();
+		process.exit(0);
+	}
+	const command = positionals[0];
+	const args = process.argv.slice(3);
+	switch (command) {
+		case "gen":
+			await import("./cli-gen-aCkffW1Z.js").then((m) => m.run(args));
+			break;
+		case "json":
+			await import("./cli-DGBgLdGK.js").then((m) => m.run(args));
+			break;
+		case "compat":
+			await import("./cli-DlZBZozW.js").then((m) => m.run(args));
+			break;
+		case "audit":
+			await import("./cli-audit-j58Eyd5d.js").then((m) => m.run(args));
+			break;
+		case "bench":
+			await import("./cli-bench-bkR1vGK8.js").then((m) => m.run(args));
+			break;
+		case "help":
+			if (positionals[1]) {
+				args.push("--help");
+				switch (positionals[1]) {
+					case "gen":
+						await import("./cli-gen-aCkffW1Z.js").then((m) => m.run(args));
+						break;
+					case "json":
+						await import("./cli-DGBgLdGK.js").then((m) => m.run(args));
+						break;
+					case "compat":
+						await import("./cli-DlZBZozW.js").then((m) => m.run(args));
+						break;
+					case "audit":
+						await import("./cli-audit-j58Eyd5d.js").then((m) => m.run(args));
+						break;
+					case "bench":
+						await import("./cli-bench-bkR1vGK8.js").then((m) => m.run(args));
+						break;
+					default:
+						console.error(`Unknown command: ${positionals[1]}`);
+						process.exit(1);
 				}
-			}
-			stdout.write("> ");
-		});
-		await new Promise(() => {});
-	} catch (err) {
-		console.error("Error:", err.message);
-		process.exit(1);
-	} finally {
-		rmSync(tmpDir, {
-			recursive: true,
-			force: true
-		});
+			} else printMainUsage();
+			break;
+		default:
+			console.error(`Unknown command: ${command}`);
+			printMainUsage();
+			process.exit(1);
 	}
 }
-/**
-* Convert string to PascalCase
-*/
-function toPascalCase(str) {
-	return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
-}
+main().catch((err) => {
+	console.error("Error:", err.message);
+	process.exit(1);
+});
 
 //#endregion
 export {  };