@naeemo/capnp 0.1.0 → 0.2.0

package/dist/codegen/cli-v3.js

@@ -0,0 +1,1676 @@
+#!/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 { dirname, join } from "node:path";
+import { parseArgs } from "node:util";
+
+//#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;
+		const low = BigInt(this.view.getUint32(byteOffset, true));
+		return BigInt(this.view.getUint32(byteOffset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 设置字（64位）
+	*/
+	setWord(wordOffset, value) {
+		const byteOffset = wordOffset * WORD_SIZE;
+		this.view.setUint32(byteOffset, Number(value & BigInt(4294967295)), true);
+		this.view.setUint32(byteOffset + 4, Number(value >> BigInt(32)), true);
+	}
+	/**
+	* 获取原始 buffer（只读到 _size）
+	*/
+	asUint8Array() {
+		return new Uint8Array(this.buffer, 0, this._size);
+	}
+	/**
+	* 获取字数量
+	*/
+	get wordCount() {
+		return this._size / WORD_SIZE;
+	}
+	/**
+	* 获取字节数量
+	*/
+	get byteLength() {
+		return this._size;
+	}
+	/**
+	* 获取 DataView
+	*/
+	get dataView() {
+		return this.view;
+	}
+};
+
+//#endregion
+//#region src/core/list.ts
+/**
+* ListReader - 读取列表
+*/
+var ListReader = class {
+	segment;
+	startOffset;
+	segmentIndex;
+	constructor(message, segmentIndex, elementSize, elementCount, structSize, wordOffset) {
+		this.message = message;
+		this.elementSize = elementSize;
+		this.elementCount = elementCount;
+		this.structSize = structSize;
+		this.segmentIndex = segmentIndex;
+		this.segment = message.getSegment(segmentIndex);
+		this.startOffset = wordOffset;
+	}
+	/**
+	* 列表长度
+	*/
+	get length() {
+		return this.elementCount;
+	}
+	/**
+	* 获取元素（基础类型）
+	*/
+	getPrimitive(index) {
+		if (index < 0 || index >= this.elementCount) throw new RangeError("Index out of bounds");
+		switch (this.elementSize) {
+			case ElementSize.BIT: {
+				const byteOffset = Math.floor(index / 8);
+				const bitInByte = index % 8;
+				return (this.segment.dataView.getUint8(this.startOffset * WORD_SIZE + byteOffset) & 1 << bitInByte) !== 0 ? 1 : 0;
+			}
+			case ElementSize.BYTE: return this.segment.dataView.getUint8(this.startOffset * WORD_SIZE + index);
+			case ElementSize.TWO_BYTES: return this.segment.dataView.getUint16(this.startOffset * WORD_SIZE + index * 2, true);
+			case ElementSize.FOUR_BYTES: return this.segment.dataView.getUint32(this.startOffset * WORD_SIZE + index * 4, true);
+			case ElementSize.EIGHT_BYTES: {
+				const offset = this.startOffset * WORD_SIZE + index * 8;
+				const low = BigInt(this.segment.dataView.getUint32(offset, true));
+				return BigInt(this.segment.dataView.getUint32(offset + 4, true)) << BigInt(32) | low;
+			}
+			default: throw new Error(`Unsupported element size: ${this.elementSize}`);
+		}
+	}
+	/**
+	* 获取结构元素
+	*/
+	getStruct(index) {
+		if (!this.structSize) throw new Error("Not a struct list");
+		const { dataWords, pointerCount } = this.structSize;
+		const size = dataWords + pointerCount;
+		const offset = this.startOffset + index * size;
+		return new StructReader(this.message, this.segmentIndex, offset, dataWords, pointerCount);
+	}
+	/**
+	* 迭代器
+	*/
+	*[Symbol.iterator]() {
+		for (let i = 0; i < this.elementCount; i++) yield this.getPrimitive(i);
+	}
+};
+
+//#endregion
+//#region src/core/message-reader.ts
+/**
+* Cap'n Proto MessageReader
+* 纯 TypeScript 实现
+*/
+var MessageReader = class {
+	segments;
+	constructor(buffer) {
+		const uint8Array = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+		this.segments = [];
+		if (uint8Array.byteLength < 8) return;
+		const view = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
+		const firstWordLow = view.getUint32(0, true);
+		const firstWordHigh = view.getUint32(4, true);
+		const segmentCount = (firstWordLow & 4294967295) + 1;
+		const firstSegmentSize = firstWordHigh;
+		let offset = 8;
+		const segmentSizes = [firstSegmentSize];
+		for (let i = 1; i < segmentCount; i++) {
+			if (offset + 4 > uint8Array.byteLength) {
+				this.segments = [];
+				return;
+			}
+			segmentSizes.push(view.getUint32(offset, true));
+			offset += 4;
+		}
+		offset = offset + 7 & -8;
+		if (offset > uint8Array.byteLength) {
+			this.segments = [];
+			return;
+		}
+		this.segments = [];
+		for (const size of segmentSizes) {
+			if (offset + size * WORD_SIZE > uint8Array.byteLength) break;
+			const segmentBuffer = uint8Array.slice(offset, offset + size * WORD_SIZE);
+			this.segments.push(Segment.fromBuffer(segmentBuffer.buffer));
+			offset += size * WORD_SIZE;
+		}
+	}
+	/**
+	* 获取根结构
+	*/
+	getRoot(_dataWords, _pointerCount) {
+		const segment = this.segments[0];
+		const ptr = decodePointer(segment.getWord(0));
+		if (ptr.tag === PointerTag.STRUCT) {
+			const structPtr = ptr;
+			const dataOffset = 1 + structPtr.offset;
+			return new StructReader(this, 0, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+		}
+		if (ptr.tag === PointerTag.FAR) {
+			const farPtr = ptr;
+			const targetSegment = this.getSegment(farPtr.targetSegment);
+			if (!targetSegment) throw new Error(`Far pointer references non-existent segment ${farPtr.targetSegment}`);
+			if (farPtr.doubleFar) {
+				const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+				if (landingPadPtr.tag !== PointerTag.FAR) throw new Error("Double-far landing pad is not a far pointer");
+				const innerFarPtr = landingPadPtr;
+				const finalSegment = this.getSegment(innerFarPtr.targetSegment);
+				if (!finalSegment) throw new Error(`Double-far references non-existent segment ${innerFarPtr.targetSegment}`);
+				const structPtr = decodePointer(finalSegment.getWord(innerFarPtr.targetOffset));
+				const dataOffset = innerFarPtr.targetOffset + 1 + structPtr.offset;
+				return new StructReader(this, innerFarPtr.targetSegment, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+			}
+			const structPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+			const dataOffset = farPtr.targetOffset + 1 + structPtr.offset;
+			return new StructReader(this, farPtr.targetSegment, dataOffset, structPtr.dataWords, structPtr.pointerCount);
+		}
+		throw new Error(`Root pointer is not a struct or far pointer: ${ptr.tag}`);
+	}
+	/**
+	* 获取段
+	*/
+	getSegment(index) {
+		return this.segments[index];
+	}
+	/**
+	* 解析指针，处理 far pointer 间接寻址
+	* 返回 { segmentIndex, wordOffset, pointer }，其中 pointer 是实际的 struct/list 指针
+	*/
+	resolvePointer(segmentIndex, wordOffset) {
+		const segment = this.getSegment(segmentIndex);
+		if (!segment) return null;
+		const ptrValue = segment.getWord(wordOffset);
+		if (ptrValue === 0n) return null;
+		const ptr = decodePointer(ptrValue);
+		if (ptr.tag === PointerTag.STRUCT || ptr.tag === PointerTag.LIST) return {
+			segmentIndex,
+			wordOffset: wordOffset + 1 + ptr.offset,
+			pointer: ptr
+		};
+		if (ptr.tag === PointerTag.FAR) {
+			const farPtr = ptr;
+			const targetSegment = this.getSegment(farPtr.targetSegment);
+			if (!targetSegment) return null;
+			if (farPtr.doubleFar) {
+				const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+				if (landingPadPtr.tag !== PointerTag.FAR) return null;
+				const innerFarPtr = landingPadPtr;
+				const finalSegment = this.getSegment(innerFarPtr.targetSegment);
+				if (!finalSegment) return null;
+				const finalPtr = decodePointer(finalSegment.getWord(innerFarPtr.targetOffset));
+				if (finalPtr.tag !== PointerTag.STRUCT && finalPtr.tag !== PointerTag.LIST) return null;
+				const targetOffset = innerFarPtr.targetOffset + 1 + finalPtr.offset;
+				return {
+					segmentIndex: innerFarPtr.targetSegment,
+					wordOffset: targetOffset,
+					pointer: finalPtr
+				};
+			}
+			const landingPadPtr = decodePointer(targetSegment.getWord(farPtr.targetOffset));
+			if (landingPadPtr.tag !== PointerTag.STRUCT && landingPadPtr.tag !== PointerTag.LIST) return null;
+			const targetOffset = farPtr.targetOffset + 1 + landingPadPtr.offset;
+			return {
+				segmentIndex: farPtr.targetSegment,
+				wordOffset: targetOffset,
+				pointer: landingPadPtr
+			};
+		}
+		return null;
+	}
+	/**
+	* 段数量
+	*/
+	get segmentCount() {
+		return this.segments.length;
+	}
+};
+/**
+* 结构读取器
+*/
+var StructReader = class StructReader {
+	constructor(message, segmentIndex, wordOffset, dataWords, pointerCount) {
+		this.message = message;
+		this.segmentIndex = segmentIndex;
+		this.wordOffset = wordOffset;
+		this.dataWords = dataWords;
+		this.pointerCount = pointerCount;
+	}
+	/**
+	* 获取 bool 字段
+	*/
+	getBool(bitOffset) {
+		const byteOffset = Math.floor(bitOffset / 8);
+		const bitInByte = bitOffset % 8;
+		return (this.message.getSegment(this.segmentIndex).dataView.getUint8(this.wordOffset * WORD_SIZE + byteOffset) & 1 << bitInByte) !== 0;
+	}
+	/**
+	* 获取 int8 字段
+	*/
+	getInt8(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt8(this.wordOffset * WORD_SIZE + byteOffset);
+	}
+	/**
+	* 获取 int16 字段
+	*/
+	getInt16(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt16(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 int32 字段
+	*/
+	getInt32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getInt32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 int64 字段
+	*/
+	getInt64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		const low = BigInt(segment.dataView.getUint32(offset, true));
+		return BigInt(segment.dataView.getInt32(offset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 获取 uint8 字段
+	*/
+	getUint8(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint8(this.wordOffset * WORD_SIZE + byteOffset);
+	}
+	/**
+	* 获取 uint16 字段
+	*/
+	getUint16(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint16(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 uint32 字段
+	*/
+	getUint32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getUint32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 uint64 字段
+	*/
+	getUint64(byteOffset) {
+		const segment = this.message.getSegment(this.segmentIndex);
+		const offset = this.wordOffset * WORD_SIZE + byteOffset;
+		const low = BigInt(segment.dataView.getUint32(offset, true));
+		return BigInt(segment.dataView.getUint32(offset + 4, true)) << BigInt(32) | low;
+	}
+	/**
+	* 获取 float32 字段
+	*/
+	getFloat32(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getFloat32(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取 float64 字段
+	*/
+	getFloat64(byteOffset) {
+		return this.message.getSegment(this.segmentIndex).dataView.getFloat64(this.wordOffset * WORD_SIZE + byteOffset, true);
+	}
+	/**
+	* 获取文本字段
+	*/
+	getText(pointerIndex) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return "";
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.LIST) return "";
+		const listPtr = pointer;
+		const segment = this.message.getSegment(segmentIndex);
+		const byteLength = listPtr.elementCount > 0 ? listPtr.elementCount - 1 : 0;
+		if (byteLength === 0) return "";
+		const bytes = new Uint8Array(segment.dataView.buffer, wordOffset * WORD_SIZE, byteLength);
+		return new TextDecoder().decode(bytes);
+	}
+	/**
+	* 获取嵌套结构
+	*/
+	getStruct(pointerIndex, _dataWords, _pointerCount) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return void 0;
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.STRUCT) return void 0;
+		const structPtr = pointer;
+		return new StructReader(this.message, segmentIndex, wordOffset, structPtr.dataWords, structPtr.pointerCount);
+	}
+	/**
+	* 获取列表
+	*/
+	getList(pointerIndex, _elementSize, structSize) {
+		const ptrOffset = this.wordOffset + this.dataWords + pointerIndex;
+		const resolved = this.message.resolvePointer(this.segmentIndex, ptrOffset);
+		if (!resolved) return void 0;
+		const { segmentIndex, wordOffset, pointer } = resolved;
+		if (pointer.tag !== PointerTag.LIST) return void 0;
+		const listPtr = pointer;
+		let targetOffset = wordOffset;
+		let elementCount = listPtr.elementCount;
+		let actualStructSize = structSize;
+		const segment = this.message.getSegment(segmentIndex);
+		if (listPtr.elementSize === ElementSize.COMPOSITE) {
+			const tagWord = segment.getWord(targetOffset);
+			elementCount = Number(tagWord & BigInt(4294967295));
+			actualStructSize = {
+				dataWords: Number(tagWord >> BigInt(32) & BigInt(65535)),
+				pointerCount: Number(tagWord >> BigInt(48) & BigInt(65535))
+			};
+			targetOffset += 1;
+		}
+		return new ListReader(this.message, segmentIndex, listPtr.elementSize, elementCount, actualStructSize, targetOffset);
+	}
+};
+
+//#endregion
+//#region src/schema/schema-reader.ts
+/**
+* Cap'n Proto 编译后 Schema 的 TypeScript Reader
+* 基于官方 schema.capnp 手动编写
+*
+* 这是自举的基础：我们需要先能读取 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 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 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/codegen/generator-v3.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("");
+	const fileNodes = allNodes.filter((n) => n.scopeId === fileId);
+	for (const node of fileNodes) {
+		if (node.isStruct) lines.push(generateStruct(node, allNodes));
+		else if (node.isEnum) lines.push(generateEnum(node));
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* 生成 Struct 的 TypeScript 代码
+*/
+function generateStruct(node, allNodes) {
+	const lines = [];
+	const structName = getShortName(node.displayName);
+	const { unionGroups, regularFields, groupFields } = analyzeFields(node, allNodes);
+	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;
+		for (const field of groupNode.structFields) {
+			if (!field.isSlot) continue;
+			const tsType = getTypeScriptType(field.slotType, allNodes);
+			lines.push(`  ${groupName}${capitalize(field.name)}: ${tsType};`);
+		}
+	}
+	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;
+		for (const field of groupNode.structFields) {
+			if (!field.isSlot) continue;
+			const getter = generateGroupFieldGetter(field, groupName);
+			lines.push(`  ${getter}`);
+			lines.push("");
+		}
+	}
+	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;
+		for (const field of groupNode.structFields) {
+			if (!field.isSlot) continue;
+			const setter = generateGroupFieldSetter(field, groupName);
+			lines.push(`  ${setter}`);
+			lines.push("");
+		}
+	}
+	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"
+*/
+function getShortName(displayName) {
+	const colonIndex = displayName.lastIndexOf(":");
+	if (colonIndex >= 0) return displayName.substring(colonIndex + 1);
+	return displayName.replace(/\.capnp$/, "").replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+//#endregion
+//#region src/codegen/cli-v3.ts
+/**
+* Cap'n Proto TypeScript Code Generator CLI v3
+*
+* 使用官方 capnp 编译器生成的 binary schema 来生成 TypeScript 代码
+* 这是推荐的生产环境方案
+*/
+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"
+		},
+		help: {
+			type: "boolean",
+			short: "h"
+		},
+		version: {
+			type: "boolean",
+			short: "v"
+		}
+	},
+	allowPositionals: true
+});
+const VERSION = "3.0.0";
+if (values.version) {
+	console.log(VERSION);
+	process.exit(0);
+}
+if (values.help || positionals.length === 0) {
+	console.log(`
+Cap'n Proto TypeScript Code Generator v3
+
+Usage: capnp-ts-codegen <schema.capnp> [options]
+
+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)
+  -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
+
+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
+
+Not yet supported:
+  - Interface
+  - Const
+  - RPC
+`);
+	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 (!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 = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+		console.error("Generating TypeScript code...");
+		const files = generateFromRequest(CodeGeneratorRequestReader.fromBuffer(arrayBuffer), { 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();
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli-v3.js.map