@naeemo/capnp 0.8.1 → 0.9.1

package/dist/cli-gen-aCkffW1Z.js

@@ -0,0 +1,1325 @@
+#!/usr/bin/env node
+import { r as ElementSize } from "./segment-yid_PYS5.js";
+import { t as MessageReader } from "./message-reader-_TCBf61G.js";
+import "./core-DstLMMvA.js";
+import { parseArgs } from "node:util";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+import { join } from "node:path";
+
+//#region src/codegen/generator.ts
+const DEFAULT_OPTIONS = { runtimeImportPath: "@naeemo/capnp" };
+/**
+* 从 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/schema/schema-reader.ts
+/**
+* Cap'n Proto 编译后 Schema 的 TypeScript Reader
+* 基于官方 schema.capnp 手动编写
+*
+* 这是自举的基础：我们需要先能读取 schema 才能生成 schema 的代码
+*
+* 结构信息来自: 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-gen.ts
+/**
+* Cap'n Proto Code Generator CLI
+*
+* Usage: capnp gen <schema.capnp> [options]
+*/
+const VERSION = "3.0.0";
+function printUsage() {
+	console.log(`
+Cap'n Proto TypeScript Code Generator v${VERSION}
+
+Usage: capnp gen <schema.capnp> [options]
+
+Options:
+  -o, --output       Output file (default: stdout)
+  -d, --outDir       Output directory
+  -r, --runtimePath  Runtime library import path (default: @naeemo/capnp)
+  -h, --help         Show this help
+  -v, --version      Show version
+
+Examples:
+  capnp gen schema.capnp -o schema.ts
+  capnp gen schema.capnp -d ./generated
+`);
+}
+function checkCapnpTool() {
+	try {
+		execSync("capnp --version", { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function run(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: {
+			output: {
+				type: "string",
+				short: "o"
+			},
+			outDir: {
+				type: "string",
+				short: "d"
+			},
+			runtimePath: {
+				type: "string",
+				short: "r"
+			},
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			version: {
+				type: "boolean",
+				short: "v"
+			}
+		},
+		allowPositionals: true
+	});
+	if (values.version) {
+		console.log(VERSION);
+		process.exit(0);
+	}
+	if (values.help || positionals.length === 0) {
+		printUsage();
+		process.exit(0);
+	}
+	const inputFile = positionals[0];
+	if (!existsSync(inputFile)) {
+		console.error(`Error: File not found: ${inputFile}`);
+		process.exit(1);
+	}
+	if (!checkCapnpTool()) {
+		console.error("Error: capnp tool not found. Please install Cap'n Proto.");
+		process.exit(1);
+	}
+	const tmpDir = mkdtempSync(join(tmpdir(), "capnp-gen-"));
+	const binFile = join(tmpDir, "schema.bin");
+	try {
+		const { exec } = await import("node:child_process");
+		const { promisify } = await import("node:util");
+		await promisify(exec)(`capnp compile -o- "${inputFile}" > "${binFile}"`);
+		const buffer = readFileSync(binFile);
+		const files = generateFromRequest(CodeGeneratorRequestReader.fromBuffer(buffer.buffer), { runtimeImportPath: typeof values.runtimePath === "string" ? values.runtimePath : "@naeemo/capnp" });
+		if (values.outDir) for (const [filename, content] of files) {
+			const outPath = join(values.outDir, filename);
+			writeFileSync(outPath, content);
+			console.log(`Generated: ${outPath}`);
+		}
+		else if (values.output) {
+			const content = Array.from(files.values()).join("\n");
+			writeFileSync(values.output, content);
+			console.log(`Generated: ${values.output}`);
+		} else {
+			const content = Array.from(files.values()).join("\n");
+			console.log(content);
+		}
+	} catch (err) {
+		console.error("Error:", err.message);
+		process.exit(1);
+	} finally {
+		rmSync(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+
+//#endregion
+export { run };
+//# sourceMappingURL=cli-gen-aCkffW1Z.js.map