protobuf-fastdsl 0.1.0

package/README.md

@@ -0,0 +1,146 @@
+# protobuf-dsl
+
+一个 Vite 插件，将 TypeScript protobuf 接口在构建时编译为**完全内联**、零依赖的编解码函数。
+
+无 `.proto` 文件。无运行时库。无函数调用开销。只需 TypeScript 接口 → 确定化的二进制编解码代码。
+
+## 特性
+
+- **零运行时** — 所有 wire-format 逻辑在编译时内联
+- **TypeScript 原生** — 用 `pb<N, Type>` 标记接口字段即可定义 schema
+- **泛型单态化** — `Wrapper<Wrapper<string>>` → 自动生成具体编解码函数
+- **重复字段** — `pb_repeated<N, Type>` 编译为 `Type[]`
+- **编译期预计算 Tag** — 字段标签在编译时折叠为字面量字节
+
+## 安装
+
+```bash
+npm install protobuf-dsl
+```
+
+## 快速开始
+
+**1. 在 `vite.config.ts` 中添加插件：**
+
+```ts
+import protobufVite from 'protobuf-dsl';
+
+export default defineConfig({
+  plugins: [protobufVite()],
+});
+```
+
+**2. 在 `tsconfig.json` 中添加类型声明：**
+
+```json
+{
+  "compilerOptions": {
+    "types": ["protobuf-dsl/types"]
+  }
+}
+```
+
+**3. 用 TypeScript 接口定义 schema：**
+
+```ts
+interface UserProfile {
+  id:       pb<1, uint_32>;
+  username: pb<2, string>;
+  active:   pb<3, bool>;
+  tags:     pb_repeated<4, string>;
+}
+```
+
+**4. 使用 `protobuf_encode` / `protobuf_decode`：**
+
+```ts
+const bytes = protobuf_encode<UserProfile>({
+  id: 42,
+  username: 'alice',
+  active: true,
+  tags: ['admin', 'dev'],
+});
+
+const user = protobuf_decode<UserProfile>(bytes);
+// user.id === 42, user.tags === ['admin', 'dev']
+```
+
+构建时，插件会将上述代码转换为：
+
+```js
+// 预计算的 tag 字面量，内联 varint 循环，零函数调用
+const bytes = protobuf_encode_UserProfile({ id: 42, ... });
+const user = protobuf_decode_UserProfile(bytes);
+```
+
+## 泛型单态化
+
+定义泛型 protobuf 模板，使用具体类型实例化：
+
+```ts
+interface Wrapper<T> {
+  value?: pb<1, T>;
+}
+
+// 插件自动生成以下具体类型的编解码函数：
+//   Wrapper__string  和  Wrapper__Wrapper__string
+const data = protobuf_encode<Wrapper<Wrapper<string>>>({
+  value: { value: 'hello' },
+});
+```
+
+## 支持的类型
+
+| Protobuf 类型 | TypeScript 类型 | Wire 类型 |
+|---------------|-----------------|-----------|
+| `uint_32`, `int_32` | `number` | Varint |
+| `uint_64`, `int_64` | `bigint` | Varint |
+| `sint_32` | `number` | Varint |
+| `sint_64` | `bigint` | Varint |
+| `bool` | `boolean` | Varint |
+| `string` | `string` | LengthDelimited |
+| `bytes` | `Uint8Array` | LengthDelimited |
+| `float`, `fixed_32`, `sfixed_32` | `number` | 32-bit |
+| `double` | `number` | 64-bit |
+| `fixed_64`, `sfixed_64` | `bigint` | 64-bit |
+| 嵌套消息 | interface | LengthDelimited |
+
+字段标记：
+- `pb<fieldNumber, Type>` — 单值字段
+- `pb_repeated<fieldNumber, Type>` — 重复字段（→ `Type[]`）
+
+说明：
+- 所有 64 位整数类型在 TypeScript 中统一映射为 `bigint`
+
+## ⚡ 性能测试
+
+benchmark 的 `.proto` 定义位于 `bench/proto/bench.proto`，生成入口是 `npm run bench:gen`。脚本会先校验所有实现产出的 wire bytes 完全一致，再统计绝对吞吐率。下表统一以 `protobuf-dsl = 1x` 为基线，其他实现显示相对它慢了多少。
+
+参与对比的实现：
+- `protobuf-ts(protoc)` — `@protobuf-ts/plugin + protoc` 生成代码
+- `protobuf-ts` — 手写 `MessageType` 反射运行时
+- `protobufjs(static)` — `pbjs static-module` 从同一份 `.proto` 生成代码
+- `protobufjs` — 反射 API
+- `protobuf` — `google-protobuf + protoc-gen-js` 生成代码
+
+> Node v22.11.0 | Windows x64 | 每项测试 50 万次迭代
+
+### 编码性能（ops/sec — 越高越好）
+
+| 消息类型 | protobuf-dsl | protobuf-ts(protoc) | protobuf-ts | protobufjs(static) | protobufjs | protobuf |
+|---------|:-----------:|:-------------------:|:-----------:|:------------------:|:----------:|:--------:|
+| 简单消息（1 个字段） | **35,782,016 (1x)** | 8,238,128 (4.34x slower) | 5,828,158 (6.14x slower) | 16,466,923 (2.17x slower) | 16,819,500 (2.13x slower) | 5,794,260 (6.18x slower) |
+| 多字段消息（3 个字段） | **11,361,700 (1x)** | 1,767,940 (6.43x slower) | 1,394,561 (8.15x slower) | 4,481,491 (2.54x slower) | 4,240,911 (2.68x slower) | 1,609,704 (7.06x slower) |
+| 嵌套消息 | **21,264,923 (1x)** | 2,815,065 (7.55x slower) | 2,019,035 (10.53x slower) | 10,287,198 (2.07x slower) | 9,902,049 (2.15x slower) | 2,365,296 (8.99x slower) |
+
+### 解码性能（ops/sec — 越高越好）
+
+| 消息类型 | protobuf-dsl | protobuf-ts(protoc) | protobuf-ts | protobufjs(static) | protobufjs | protobuf |
+|---------|:-----------:|:-------------------:|:-----------:|:------------------:|:----------:|:--------:|
+| 简单消息（1 个字段） | **99,577,790 (1x)** | 7,586,436 (13.13x slower) | 9,032,575 (11.02x slower) | 27,215,772 (3.66x slower) | 19,002,736 (5.24x slower) | 11,497,372 (8.66x slower) |
+| 多字段消息（3 个字段） | **10,190,107 (1x)** | 3,891,478 (2.62x slower) | 3,219,789 (3.16x slower) | 5,141,816 (1.98x slower) | 4,893,718 (2.08x slower) | 3,606,205 (2.83x slower) |
+| 嵌套消息 | **51,491,185 (1x)** | 8,376,444 (6.15x slower) | 6,033,801 (8.53x slower) | 11,922,077 (4.32x slower) | 13,326,794 (3.86x slower) | 3,148,311 (16.36x slower) |
+
+## 许可证
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import { Plugin } from 'vite';
+import ts from 'typescript';
+
+declare enum WireType {
+    Varint = 0,
+    Bit64 = 1,
+    LengthDelim = 2,
+    Bit32 = 5
+}
+interface ProtobufField {
+    name: string;
+    fieldNumber: number;
+    typeName: string;
+    wireType: WireType;
+    isMessage: boolean;
+    isOptional: boolean;
+    isRepeated: boolean;
+}
+interface ProtobufMessage {
+    name: string;
+    fields: ProtobufField[];
+}
+type MessageRegistry = Map<string, ProtobufMessage>;
+
+/**
+ * Deterministic mangled name for a type node.
+ *   `Foo`                → `Foo`
+ *   `Foo<string>`        → `Foo__string`
+ *   `Foo<Bar<uint_32>>`  → `Foo__Bar__uint_32`
+ */
+declare function typeNodeToMangledName(typeNode: ts.TypeNode, sf: ts.SourceFile): string;
+
+/** A recorded call-site for later replacement. */
+interface CallSiteRecord {
+    fnName: string;
+    exprStart: number;
+    typeArgsEnd: number;
+    firstTypeArg: ts.TypeNode;
+}
+interface AnalysisResult {
+    registry: MessageRegistry;
+    callSites: CallSiteRecord[];
+    sourceFile: ts.SourceFile;
+}
+/**
+ * Analyze TypeScript source in a **single parse + single walk**.
+ *
+ * One walk handles both:
+ *  - Collecting concrete + generic interfaces
+ *  - Recording protobuf_encode/decode call-sites
+ *
+ * Then post-processes: monomorphize → resolve wire types → topo sort.
+ */
+declare function analyze(code: string, filePath: string): AnalysisResult;
+/**
+ * Backward-compatible wrapper: returns only the MessageRegistry.
+ * Uses the same single-walk analysis internally.
+ */
+declare function analyzeSource(code: string, filePath: string): MessageRegistry;
+
+/**
+ * Generate fully self-contained encode/decode source code.
+ * No runtime imports needed — all wire-format logic is inlined.
+ */
+declare function generateCode(registry: MessageRegistry): string;
+
+/**
+ * Apply replacements using pre-recorded call-sites from analyze().
+ * No parsing or AST walking — just position-based string edits.
+ */
+declare function applyReplacements(code: string, sf: ts.SourceFile, callSites: CallSiteRecord[], registry: MessageRegistry): {
+    transformedCode: string;
+    hasReplacements: boolean;
+};
+/**
+ * Backward-compatible: parses + walks on its own.
+ * Prefer applyReplacements() with pre-recorded call-sites from analyze().
+ */
+declare function replaceCallSites(code: string, registry: MessageRegistry): {
+    transformedCode: string;
+    hasReplacements: boolean;
+};
+
+declare function protobufVitePlugin(): Plugin;
+
+export { analyze, analyzeSource, applyReplacements, protobufVitePlugin as default, generateCode, replaceCallSites, typeNodeToMangledName };

package/dist/index.js

@@ -0,0 +1,1111 @@
+// src/ast/analyzer.ts
+import ts4 from "typescript";
+
+// src/ast/types.ts
+var PRIMITIVE_TYPE_MAP = {
+  uint_32: { wireType: 0 /* Varint */, defaultValue: "0" },
+  int_32: { wireType: 0 /* Varint */, defaultValue: "0" },
+  uint_64: { wireType: 0 /* Varint */, defaultValue: "0" },
+  int_64: { wireType: 0 /* Varint */, defaultValue: "0" },
+  sint_32: { wireType: 0 /* Varint */, defaultValue: "0" },
+  sint_64: { wireType: 0 /* Varint */, defaultValue: "0" },
+  bool: { wireType: 0 /* Varint */, defaultValue: "false" },
+  string: { wireType: 2 /* LengthDelim */, defaultValue: '""' },
+  bytes: { wireType: 2 /* LengthDelim */, defaultValue: "new Uint8Array(0)" },
+  float: { wireType: 5 /* Bit32 */, defaultValue: "0" },
+  double: { wireType: 1 /* Bit64 */, defaultValue: "0" },
+  fixed_32: { wireType: 5 /* Bit32 */, defaultValue: "0" },
+  fixed_64: { wireType: 1 /* Bit64 */, defaultValue: "0" },
+  sfixed_32: { wireType: 5 /* Bit32 */, defaultValue: "0" },
+  sfixed_64: { wireType: 1 /* Bit64 */, defaultValue: "0" }
+};
+var PB_MARKER = "pb";
+var PB_REPEATED_MARKER = "pb_repeated";
+
+// src/ast/collector.ts
+import ts2 from "typescript";
+
+// src/ast/utils.ts
+import ts from "typescript";
+var KEYWORD_TYPE_KINDS = /* @__PURE__ */ new Set([
+  ts.SyntaxKind.StringKeyword,
+  ts.SyntaxKind.NumberKeyword,
+  ts.SyntaxKind.BooleanKeyword,
+  ts.SyntaxKind.AnyKeyword,
+  ts.SyntaxKind.VoidKeyword,
+  ts.SyntaxKind.UndefinedKeyword,
+  ts.SyntaxKind.NullKeyword,
+  ts.SyntaxKind.NeverKeyword,
+  ts.SyntaxKind.UnknownKeyword,
+  ts.SyntaxKind.BigIntKeyword,
+  ts.SyntaxKind.SymbolKeyword,
+  ts.SyntaxKind.ObjectKeyword
+]);
+function isKeywordTypeNode(node) {
+  return KEYWORD_TYPE_KINDS.has(node.kind);
+}
+function typeNodeToMangledName(typeNode, sf) {
+  if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+    const base = typeNode.typeName.text;
+    if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+      const args = typeNode.typeArguments.map((a) => typeNodeToMangledName(a, sf));
+      return base + "__" + args.join("__");
+    }
+    return base;
+  }
+  if (isKeywordTypeNode(typeNode)) return typeNode.getText(sf);
+  return typeNode.getText(sf);
+}
+
+// src/ast/collector.ts
+function collectInterface(node, sf) {
+  const fields = [];
+  for (const m of node.members) {
+    if (!ts2.isPropertySignature(m) || !m.type) continue;
+    const f = extractField(m, sf);
+    if (f) fields.push(f);
+  }
+  return fields.length ? { name: node.name.text, fields } : null;
+}
+function collectGenericInterface(node, sf) {
+  const typeParams = node.typeParameters.map((p) => p.name.text);
+  const tpSet = new Set(typeParams);
+  const fields = [];
+  for (const m of node.members) {
+    if (!ts2.isPropertySignature(m) || !m.type) continue;
+    const f = extractGenericField(m, sf, tpSet);
+    if (f) fields.push(f);
+  }
+  return fields.length ? { name: node.name.text, typeParams, fields } : null;
+}
+function parsePbTypeRef(member) {
+  const t = member.type;
+  if (!ts2.isTypeReferenceNode(t) || !ts2.isIdentifier(t.typeName)) return null;
+  const marker = t.typeName.text;
+  if (marker !== PB_MARKER && marker !== PB_REPEATED_MARKER) return null;
+  const ta = t.typeArguments;
+  if (!ta || ta.length !== 2) return null;
+  const fnNode = ta[0];
+  if (!ts2.isLiteralTypeNode(fnNode) || !ts2.isNumericLiteral(fnNode.literal)) return null;
+  return { marker, fieldNumber: Number(fnNode.literal.text), typeArgNode: ta[1] };
+}
+function resolveTypeName(node, sf) {
+  if (ts2.isTypeReferenceNode(node) && ts2.isIdentifier(node.typeName)) return node.typeName.text;
+  if (isKeywordTypeNode(node)) return node.getText(sf);
+  return null;
+}
+function extractField(member, sf) {
+  const parsed = parsePbTypeRef(member);
+  if (!parsed) return null;
+  const typeName = resolveTypeName(parsed.typeArgNode, sf);
+  if (!typeName || !ts2.isIdentifier(member.name)) return null;
+  return {
+    name: member.name.text,
+    fieldNumber: parsed.fieldNumber,
+    typeName,
+    wireType: 0 /* Varint */,
+    // placeholder
+    isMessage: false,
+    // placeholder
+    isOptional: member.questionToken != null,
+    isRepeated: parsed.marker === PB_REPEATED_MARKER
+  };
+}
+function extractGenericField(member, sf, tpSet) {
+  const parsed = parsePbTypeRef(member);
+  if (!parsed) return null;
+  const raw = resolveTypeName(parsed.typeArgNode, sf);
+  if (!raw || !ts2.isIdentifier(member.name)) return null;
+  return {
+    name: member.name.text,
+    fieldNumber: parsed.fieldNumber,
+    rawTypeName: raw,
+    isTypeParam: tpSet.has(raw),
+    isOptional: member.questionToken != null,
+    isRepeated: parsed.marker === PB_REPEATED_MARKER
+  };
+}
+
+// src/ast/monomorphizer.ts
+import ts3 from "typescript";
+function monomorphizeTypeNode(typeNode, sf, templates, out) {
+  if (!ts3.isTypeReferenceNode(typeNode) || !ts3.isIdentifier(typeNode.typeName)) return null;
+  const baseName = typeNode.typeName.text;
+  const typeArgs = typeNode.typeArguments;
+  if (!typeArgs || typeArgs.length === 0) return baseName;
+  const tpl = templates.get(baseName);
+  if (!tpl || typeArgs.length !== tpl.typeParams.length) return null;
+  const mangledName = typeNodeToMangledName(typeNode, sf);
+  if (out.has(mangledName)) return mangledName;
+  const paramMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tpl.typeParams.length; i++) {
+    const resolved = resolveTypeArg(typeArgs[i], sf, templates, out);
+    if (!resolved) return null;
+    paramMap.set(tpl.typeParams[i], resolved);
+  }
+  const fields = tpl.fields.map((f) => ({
+    name: f.name,
+    fieldNumber: f.fieldNumber,
+    typeName: f.isTypeParam ? paramMap.get(f.rawTypeName) ?? f.rawTypeName : f.rawTypeName,
+    wireType: 0 /* Varint */,
+    isMessage: false,
+    isOptional: f.isOptional,
+    isRepeated: f.isRepeated
+  }));
+  out.set(mangledName, { name: mangledName, fields });
+  return mangledName;
+}
+function resolveTypeArg(node, sf, templates, out) {
+  const mono = monomorphizeTypeNode(node, sf, templates, out);
+  if (mono) return mono;
+  if (isKeywordTypeNode(node)) return node.getText(sf);
+  if (ts3.isTypeReferenceNode(node) && ts3.isIdentifier(node.typeName) && !node.typeArguments) {
+    return node.typeName.text;
+  }
+  return null;
+}
+
+// src/ast/analyzer.ts
+function analyze(code, filePath) {
+  const sf = ts4.createSourceFile(filePath, code, ts4.ScriptTarget.Latest, true);
+  const concrete = [];
+  const templates = /* @__PURE__ */ new Map();
+  const mono = /* @__PURE__ */ new Map();
+  const callSites = [];
+  const deferredTypeArgs = [];
+  ts4.forEachChild(sf, function visit(node) {
+    if (ts4.isInterfaceDeclaration(node)) {
+      if (node.typeParameters?.length) {
+        const tpl = collectGenericInterface(node, sf);
+        if (tpl) templates.set(tpl.name, tpl);
+      } else {
+        const msg = collectInterface(node, sf);
+        if (msg) concrete.push(msg);
+      }
+    }
+    if (ts4.isCallExpression(node)) {
+      const e = node.expression;
+      if (ts4.isIdentifier(e) && (e.text === "protobuf_encode" || e.text === "protobuf_decode")) {
+        const ta = node.typeArguments;
+        if (ta?.length) {
+          deferredTypeArgs.push(ta[0]);
+          callSites.push({
+            fnName: e.text,
+            exprStart: e.getStart(sf),
+            typeArgsEnd: ta.end + 1,
+            firstTypeArg: ta[0]
+          });
+        }
+      }
+    }
+    ts4.forEachChild(node, visit);
+  });
+  for (const typeArg of deferredTypeArgs) {
+    monomorphizeTypeNode(typeArg, sf, templates, mono);
+  }
+  for (const m of mono.values()) concrete.push(m);
+  const names = new Set(concrete.map((m) => m.name));
+  for (const msg of concrete) {
+    for (const f of msg.fields) {
+      const prim = PRIMITIVE_TYPE_MAP[f.typeName];
+      if (prim) {
+        f.wireType = prim.wireType;
+        f.isMessage = false;
+      } else if (names.has(f.typeName)) {
+        f.wireType = 2 /* LengthDelim */;
+        f.isMessage = true;
+      }
+    }
+  }
+  return { registry: topoSort(concrete), callSites, sourceFile: sf };
+}
+function analyzeSource(code, filePath) {
+  return analyze(code, filePath).registry;
+}
+function topoSort(messages) {
+  const map = new Map(messages.map((m) => [m.name, m]));
+  const deps = new Map(messages.map((m) => [
+    m.name,
+    new Set(m.fields.filter((f) => map.has(f.typeName)).map((f) => f.typeName))
+  ]));
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function dfs(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) throw new Error(`Circular dependency: ${name}`);
+    visiting.add(name);
+    for (const d of deps.get(name) || []) dfs(d);
+    visiting.delete(name);
+    visited.add(name);
+    sorted.push(map.get(name));
+  }
+  for (const m of messages) dfs(m.name);
+  return new Map(sorted.map((m) => [m.name, m]));
+}
+
+// src/codegen/encoder.ts
+function computeTagBytes(fieldNumber, wireType) {
+  let value = (fieldNumber << 3 | wireType) >>> 0;
+  const bytes = [];
+  while (value > 127) {
+    bytes.push(value & 127 | 128);
+    value >>>= 7;
+  }
+  bytes.push(value & 127);
+  return bytes;
+}
+function writeTag(fieldNumber, wireType, ind) {
+  return computeTagBytes(fieldNumber, wireType).map((byte) => `${ind}buf[offset++] = ${byte};`).join("\n");
+}
+function varintSize(varName, ind) {
+  return `${ind}size += ${varName} < 0x80 ? 1 : ${varName} < 0x4000 ? 2 : ${varName} < 0x200000 ? 3 : ${varName} < 0x10000000 ? 4 : 5;`;
+}
+function writeVarint(expr, ind) {
+  return [
+    `${ind}let _v = ${expr};`,
+    `${ind}if (_v < 0x80) {`,
+    `${ind}  buf[offset++] = _v;`,
+    `${ind}} else if (_v < 0x4000) {`,
+    `${ind}  buf[offset++] = (_v & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = _v >>> 7;`,
+    `${ind}} else if (_v < 0x200000) {`,
+    `${ind}  buf[offset++] = (_v & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = ((_v >>> 7) & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = _v >>> 14;`,
+    `${ind}} else if (_v < 0x10000000) {`,
+    `${ind}  buf[offset++] = (_v & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = ((_v >>> 7) & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = ((_v >>> 14) & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = _v >>> 21;`,
+    `${ind}} else {`,
+    `${ind}  buf[offset++] = (_v & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = ((_v >>> 7) & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = ((_v >>> 14) & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = ((_v >>> 21) & 0x7f) | 0x80;`,
+    `${ind}  buf[offset++] = _v >>> 28;`,
+    `${ind}}`
+  ].join("\n");
+}
+function isVarint64(typeName) {
+  return typeName === "uint_64" || typeName === "int_64" || typeName === "sint_64";
+}
+function isFixed64BigInt(typeName) {
+  return typeName === "fixed_64" || typeName === "sfixed_64";
+}
+function bigintVarintExpr(typeName, expr) {
+  if (typeName === "uint_64") return `BigInt.asUintN(64, ${expr})`;
+  if (typeName === "int_64") return `BigInt.asUintN(64, ${expr})`;
+  return `__zigZagEncode64(${expr})`;
+}
+function generateEncoder(msg, _registry) {
+  const blocks = msg.fields.map((field, index) => field.isRepeated ? buildRepeatedBlock(field, index) : buildSingularBlock(field, index));
+  const L = [
+    `function protobuf_encode_${msg.name}(obj) {`,
+    `  let size = 0;`,
+    ...blocks.flatMap((block) => block.declare),
+    ...blocks.flatMap((block) => block.size),
+    `  const buf = new Uint8Array(size);`,
+    `  let offset = 0;`,
+    ...blocks.flatMap((block) => block.write),
+    `  return buf;`,
+    `}`
+  ];
+  return L.join("\n");
+}
+function buildSingularBlock(field, index) {
+  const { name, fieldNumber, typeName, wireType, isMessage } = field;
+  const valueVar = `_f${index}`;
+  const cacheVar = `_c${index}`;
+  const tagLength = computeTagBytes(fieldNumber, isMessage || typeName === "string" || typeName === "bytes" ? 2 : wireType).length;
+  if (isMessage) {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`, `  let ${cacheVar};`],
+      size: [
+        `  if (${valueVar} != null) {`,
+        `    ${cacheVar} = protobuf_encode_${typeName}(${valueVar});`,
+        `    const _len = ${cacheVar}.length;`,
+        `    size += ${tagLength};`,
+        varintSize("_len", "    "),
+        `    size += _len;`,
+        `  }`
+      ],
+      write: [
+        `  if (${valueVar} != null) {`,
+        `    const _data = ${cacheVar};`,
+        writeTag(fieldNumber, 2, "    "),
+        `    const _len = _data.length;`,
+        writeVarint("_len", "    "),
+        `    buf.set(_data, offset);`,
+        `    offset += _len;`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "string") {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`, `  let ${cacheVar};`],
+      size: [
+        `  if (${valueVar} != null && ${valueVar} !== "") {`,
+        `    ${cacheVar} = __utf8Len(${valueVar});`,
+        `    const _len = ${cacheVar};`,
+        `    size += ${tagLength};`,
+        varintSize("_len", "    "),
+        `    size += _len;`,
+        `  }`
+      ],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== "") {`,
+        writeTag(fieldNumber, 2, "    "),
+        `    const _len = ${cacheVar};`,
+        writeVarint("_len", "    "),
+        `    offset = __utf8Write(buf, offset, ${valueVar});`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "bytes") {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [
+        `  if (${valueVar} != null && ${valueVar}.length > 0) {`,
+        `    const _len = ${valueVar}.length;`,
+        `    size += ${tagLength};`,
+        varintSize("_len", "    "),
+        `    size += _len;`,
+        `  }`
+      ],
+      write: [
+        `  if (${valueVar} != null && ${valueVar}.length > 0) {`,
+        writeTag(fieldNumber, 2, "    "),
+        `    const _len = ${valueVar}.length;`,
+        writeVarint("_len", "    "),
+        `    buf.set(${valueVar}, offset);`,
+        `    offset += _len;`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "bool") {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [`  if (${valueVar} === true) size += ${tagLength + 1};`],
+      write: [
+        `  if (${valueVar} === true) {`,
+        writeTag(fieldNumber, 0, "    "),
+        `    buf[offset++] = 1;`,
+        `  }`
+      ]
+    };
+  }
+  if (isVarint64(typeName)) {
+    const bigintExpr = bigintVarintExpr(typeName, valueVar);
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [
+        `  if (${valueVar} != null && ${valueVar} !== 0n) {`,
+        `    const _val = ${bigintExpr};`,
+        `    size += ${tagLength};`,
+        `    size += __varint64Size(_val);`,
+        `  }`
+      ],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== 0n) {`,
+        `    const _val = ${bigintExpr};`,
+        writeTag(fieldNumber, 0, "    "),
+        `    offset = __writeVarint64(buf, offset, _val);`,
+        `  }`
+      ]
+    };
+  }
+  if (wireType === 0 /* Varint */) {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [
+        `  if (${valueVar} != null && ${valueVar} !== 0) {`,
+        `    const _val = ${valueVar} >>> 0;`,
+        `    size += ${tagLength};`,
+        varintSize("_val", "    "),
+        `  }`
+      ],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== 0) {`,
+        writeTag(fieldNumber, 0, "    "),
+        writeVarint(`${valueVar} >>> 0`, "    "),
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "float") {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [`  if (${valueVar} != null && ${valueVar} !== 0) size += ${tagLength + 4};`],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== 0) {`,
+        writeTag(fieldNumber, 5, "    "),
+        `    offset = __writeFloat32(buf, offset, ${valueVar});`,
+        `  }`
+      ]
+    };
+  }
+  if (wireType === 5 /* Bit32 */) {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [`  if (${valueVar} != null && ${valueVar} !== 0) size += ${tagLength + 4};`],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== 0) {`,
+        writeTag(fieldNumber, 5, "    "),
+        `    const _val = ${valueVar};`,
+        `    buf[offset++] = _val & 0xff;`,
+        `    buf[offset++] = (_val >> 8) & 0xff;`,
+        `    buf[offset++] = (_val >> 16) & 0xff;`,
+        `    buf[offset++] = (_val >> 24) & 0xff;`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "double") {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [`  if (${valueVar} != null && ${valueVar} !== 0) size += ${tagLength + 8};`],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== 0) {`,
+        writeTag(fieldNumber, 1, "    "),
+        `    offset = __writeFloat64(buf, offset, ${valueVar});`,
+        `  }`
+      ]
+    };
+  }
+  if (isFixed64BigInt(typeName)) {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [`  if (${valueVar} != null && ${valueVar} !== 0n) size += ${tagLength + 8};`],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== 0n) {`,
+        writeTag(fieldNumber, 1, "    "),
+        `    offset = __writeFixed64(buf, offset, ${valueVar});`,
+        `  }`
+      ]
+    };
+  }
+  if (wireType === 1 /* Bit64 */) {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [`  if (${valueVar} != null && ${valueVar} !== 0) size += ${tagLength + 8};`],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== 0) {`,
+        writeTag(fieldNumber, 1, "    "),
+        `    const _val = ${valueVar};`,
+        `    buf[offset++] = _val & 0xff;`,
+        `    buf[offset++] = (_val >> 8) & 0xff;`,
+        `    buf[offset++] = (_val >> 16) & 0xff;`,
+        `    buf[offset++] = (_val >> 24) & 0xff;`,
+        `    buf[offset++] = 0;`,
+        `    buf[offset++] = 0;`,
+        `    buf[offset++] = 0;`,
+        `    buf[offset++] = 0;`,
+        `  }`
+      ]
+    };
+  }
+  return { declare: [], size: [], write: [] };
+}
+function buildRepeatedBlock(field, index) {
+  const { name, fieldNumber, typeName, wireType, isMessage } = field;
+  const arrayVar = `_f${index}`;
+  const cacheVar = `_c${index}`;
+  const tagWireType = isMessage || typeName === "string" || typeName === "bytes" ? 2 : wireType;
+  const tagLength = computeTagBytes(fieldNumber, tagWireType).length;
+  if (isMessage) {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`, `  let ${cacheVar};`],
+      size: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    ${cacheVar} = new Array(${arrayVar}.length);`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _data = protobuf_encode_${typeName}(${arrayVar}[_i]);`,
+        `      ${cacheVar}[_i] = _data;`,
+        `      const _len = _data.length;`,
+        `      size += ${tagLength};`,
+        varintSize("_len", "      "),
+        `      size += _len;`,
+        `    }`,
+        `  }`
+      ],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _data = ${cacheVar}[_i];`,
+        writeTag(fieldNumber, 2, "      "),
+        `      const _len = _data.length;`,
+        writeVarint("_len", "      "),
+        `      buf.set(_data, offset);`,
+        `      offset += _len;`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "string") {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`, `  let ${cacheVar};`],
+      size: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    ${cacheVar} = new Array(${arrayVar}.length);`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _len = __utf8Len(${arrayVar}[_i]);`,
+        `      ${cacheVar}[_i] = _len;`,
+        `      size += ${tagLength};`,
+        varintSize("_len", "      "),
+        `      size += _len;`,
+        `    }`,
+        `  }`
+      ],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _len = ${cacheVar}[_i];`,
+        writeTag(fieldNumber, 2, "      "),
+        writeVarint("_len", "      "),
+        `      offset = __utf8Write(buf, offset, ${arrayVar}[_i]);`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "bytes") {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _data = ${arrayVar}[_i];`,
+        `      const _len = _data.length;`,
+        `      size += ${tagLength};`,
+        varintSize("_len", "      "),
+        `      size += _len;`,
+        `    }`,
+        `  }`
+      ],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _data = ${arrayVar}[_i];`,
+        writeTag(fieldNumber, 2, "      "),
+        `      const _len = _data.length;`,
+        writeVarint("_len", "      "),
+        `      buf.set(_data, offset);`,
+        `      offset += _len;`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "bool") {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [`  if (${arrayVar} != null && ${arrayVar}.length > 0) size += ${arrayVar}.length * ${tagLength + 1};`],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        writeTag(fieldNumber, 0, "      "),
+        `      buf[offset++] = ${arrayVar}[_i] ? 1 : 0;`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (isVarint64(typeName)) {
+    const bigintExpr = bigintVarintExpr(typeName, `${arrayVar}[_i]`);
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _val = ${bigintExpr};`,
+        `      size += ${tagLength};`,
+        `      size += __varint64Size(_val);`,
+        `    }`,
+        `  }`
+      ],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _val = ${bigintExpr};`,
+        writeTag(fieldNumber, 0, "      "),
+        `      offset = __writeVarint64(buf, offset, _val);`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (wireType === 0 /* Varint */) {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        `      const _val = ${arrayVar}[_i] >>> 0;`,
+        `      size += ${tagLength};`,
+        varintSize("_val", "      "),
+        `    }`,
+        `  }`
+      ],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        writeTag(fieldNumber, 0, "      "),
+        writeVarint(`${arrayVar}[_i] >>> 0`, "      "),
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "float") {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [`  if (${arrayVar} != null && ${arrayVar}.length > 0) size += ${arrayVar}.length * ${tagLength + 4};`],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        writeTag(fieldNumber, 5, "      "),
+        `      offset = __writeFloat32(buf, offset, ${arrayVar}[_i]);`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (wireType === 5 /* Bit32 */) {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [`  if (${arrayVar} != null && ${arrayVar}.length > 0) size += ${arrayVar}.length * ${tagLength + 4};`],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        writeTag(fieldNumber, 5, "      "),
+        `      const _val = ${arrayVar}[_i];`,
+        `      buf[offset++] = _val & 0xff;`,
+        `      buf[offset++] = (_val >> 8) & 0xff;`,
+        `      buf[offset++] = (_val >> 16) & 0xff;`,
+        `      buf[offset++] = (_val >> 24) & 0xff;`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (typeName === "double") {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [`  if (${arrayVar} != null && ${arrayVar}.length > 0) size += ${arrayVar}.length * ${tagLength + 8};`],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        writeTag(fieldNumber, 1, "      "),
+        `      offset = __writeFloat64(buf, offset, ${arrayVar}[_i]);`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (isFixed64BigInt(typeName)) {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [`  if (${arrayVar} != null && ${arrayVar}.length > 0) size += ${arrayVar}.length * ${tagLength + 8};`],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        writeTag(fieldNumber, 1, "      "),
+        `      offset = __writeFixed64(buf, offset, ${arrayVar}[_i]);`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  if (wireType === 1 /* Bit64 */) {
+    return {
+      declare: [`  const ${arrayVar} = obj.${name};`],
+      size: [`  if (${arrayVar} != null && ${arrayVar}.length > 0) size += ${arrayVar}.length * ${tagLength + 8};`],
+      write: [
+        `  if (${arrayVar} != null && ${arrayVar}.length > 0) {`,
+        `    for (let _i = 0; _i < ${arrayVar}.length; _i++) {`,
+        writeTag(fieldNumber, 1, "      "),
+        `      const _val = ${arrayVar}[_i];`,
+        `      buf[offset++] = _val & 0xff;`,
+        `      buf[offset++] = (_val >> 8) & 0xff;`,
+        `      buf[offset++] = (_val >> 16) & 0xff;`,
+        `      buf[offset++] = (_val >> 24) & 0xff;`,
+        `      buf[offset++] = 0;`,
+        `      buf[offset++] = 0;`,
+        `      buf[offset++] = 0;`,
+        `      buf[offset++] = 0;`,
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  return { declare: [], size: [], write: [] };
+}
+
+// src/codegen/decoder.ts
+function tagValue(field) {
+  const wireType = field.isMessage || field.typeName === "string" || field.typeName === "bytes" ? 2 /* LengthDelim */ : field.wireType;
+  return (field.fieldNumber << 3 | wireType) >>> 0;
+}
+function varintDec(varName, ind) {
+  return [
+    `${ind}let ${varName} = data[offset++];`,
+    `${ind}if (${varName} & 0x80) {`,
+    `${ind}  let _s = 7, _b;`,
+    `${ind}  ${varName} &= 0x7f;`,
+    `${ind}  do { _b = data[offset++]; ${varName} |= (_b & 0x7f) << _s; _s += 7; } while (_b & 0x80);`,
+    `${ind}}`
+  ].join("\n");
+}
+function varintDec64(varName, ind) {
+  return [
+    `${ind}let ${varName} = 0n, _s = 0n, _b;`,
+    `${ind}do { _b = data[offset++]; ${varName} |= BigInt(_b & 0x7f) << _s; _s += 7n; } while (_b & 0x80);`
+  ].join("\n");
+}
+function isVarint642(typeName) {
+  return typeName === "uint_64" || typeName === "int_64" || typeName === "sint_64";
+}
+function isFixed64BigInt2(typeName) {
+  return typeName === "fixed_64" || typeName === "sfixed_64";
+}
+var INLINE_SKIP = [
+  `        const wireType = _tag & 0x7;`,
+  `        if (wireType === 0) { while (data[offset] & 0x80) offset++; offset++; }`,
+  `        else if (wireType === 1) offset += 8;`,
+  `        else if (wireType === 2) { let _l = data[offset++]; if (_l & 0x80) { let _s = 7, _b; _l &= 0x7f; do { _b = data[offset++]; _l |= (_b & 0x7f) << _s; _s += 7; } while (_b & 0x80); } offset += _l; }`,
+  `        else if (wireType === 5) offset += 4;`
+].join("\n");
+function generateDecoder(msg, _registry) {
+  const locals = msg.fields.map((field, index) => {
+    const keyword = field.isRepeated ? "const" : "let";
+    return `  ${keyword} _f${index} = ${getDefault(field)};`;
+  });
+  const result = msg.fields.map((field, index) => `${field.name}: _f${index}`).join(", ");
+  const L = [
+    `function protobuf_decode_${msg.name}(data, offset = 0, end = data.length) {`,
+    ...locals,
+    `  while (offset < end) {`,
+    `    let _tag = data[offset++];`,
+    `    if (_tag & 0x80) {`,
+    `      let _ts = 7, _tb;`,
+    `      _tag &= 0x7f;`,
+    `      do { _tb = data[offset++]; _tag |= (_tb & 0x7f) << _ts; _ts += 7; } while (_tb & 0x80);`,
+    `    }`,
+    `    switch (_tag) {`
+  ];
+  msg.fields.forEach((field, index) => {
+    L.push(decodeField(field, index));
+  });
+  L.push(
+    `      default: {`,
+    INLINE_SKIP,
+    `        break;`,
+    `      }`,
+    `    }`,
+    `  }`,
+    `  return { ${result} };`,
+    `}`
+  );
+  return L.join("\n");
+}
+function decodeField(field, index) {
+  const { typeName, wireType, isMessage, isRepeated } = field;
+  const I = "        ";
+  const local = `_f${index}`;
+  const assign = (expr) => isRepeated ? `${I}${local}.push(${expr});` : `${I}${local} = ${expr};`;
+  const L = [`      case ${tagValue(field)}: {`];
+  if (isMessage) {
+    L.push(varintDec("_len", I));
+    L.push(assign(`protobuf_decode_${typeName}(data, offset, offset + _len)`));
+    L.push(`${I}offset += _len;`);
+  } else if (typeName === "string") {
+    L.push(varintDec("_len", I));
+    L.push(`${I}const _end = offset + _len;`);
+    L.push(assign(`__td.decode(data.subarray(offset, _end))`));
+    L.push(`${I}offset = _end;`);
+  } else if (typeName === "bytes") {
+    L.push(varintDec("_len", I));
+    L.push(`${I}const _end = offset + _len;`);
+    L.push(assign(`data.slice(offset, _end)`));
+    L.push(`${I}offset = _end;`);
+  } else if (typeName === "bool") {
+    L.push(varintDec("_val", I));
+    L.push(assign(`_val !== 0`));
+  } else if (isVarint642(typeName)) {
+    L.push(varintDec64("_val", I));
+    if (typeName === "uint_64") {
+      L.push(assign(`_val`));
+    } else if (typeName === "int_64") {
+      L.push(assign(`BigInt.asIntN(64, _val)`));
+    } else {
+      L.push(assign(`__zigZagDecode64(_val)`));
+    }
+  } else if (wireType === 0 /* Varint */) {
+    L.push(varintDec("_val", I));
+    L.push(assign(`_val >>> 0`));
+  } else if (typeName === "float") {
+    L.push(assign(`__readFloat32(data, offset)`));
+    L.push(`${I}offset += 4;`);
+  } else if (wireType === 5 /* Bit32 */) {
+    L.push(assign(`data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24)`));
+    L.push(`${I}offset += 4;`);
+  } else if (typeName === "double") {
+    L.push(assign(`__readFloat64(data, offset)`));
+    L.push(`${I}offset += 8;`);
+  } else if (isFixed64BigInt2(typeName)) {
+    if (typeName === "fixed_64") {
+      L.push(assign(`__readFixed64(data, offset)`));
+    } else {
+      L.push(assign(`BigInt.asIntN(64, __readFixed64(data, offset))`));
+    }
+    L.push(`${I}offset += 8;`);
+  } else if (wireType === 1 /* Bit64 */) {
+    L.push(assign(`data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24)`));
+    L.push(`${I}offset += 8;`);
+  }
+  L.push(`${I}break;`, `      }`);
+  return L.join("\n");
+}
+function getDefault(field) {
+  if (field.isRepeated) return "[]";
+  if (field.isOptional || field.isMessage) return "null";
+  const primitive = PRIMITIVE_TYPE_MAP[field.typeName];
+  return primitive ? primitive.defaultValue : "null";
+}
+
+// src/codegen/generator.ts
+var CODEGEN_PREAMBLE = `const __td = new TextDecoder();
+const __scratch = new DataView(new ArrayBuffer(8));
+function __utf8Len(value) {
+  let length = 0;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 0x80) {
+      length++;
+      continue;
+    }
+    if (code < 0x800) {
+      length += 2;
+      continue;
+    }
+    if ((code & 0xfc00) === 0xd800) {
+      if (i + 1 < value.length) {
+        const next = value.charCodeAt(i + 1);
+        if ((next & 0xfc00) === 0xdc00) {
+          length += 4;
+          i++;
+          continue;
+        }
+      }
+      length += 3;
+      continue;
+    }
+    if ((code & 0xfc00) === 0xdc00) {
+      length += 3;
+      continue;
+    }
+    length += 3;
+  }
+  return length;
+}
+function __utf8Write(buf, offset, value) {
+  for (let i = 0; i < value.length; i++) {
+    let code = value.charCodeAt(i);
+    if (code < 0x80) {
+      buf[offset++] = code;
+      continue;
+    }
+    if (code < 0x800) {
+      buf[offset++] = 0xc0 | (code >> 6);
+      buf[offset++] = 0x80 | (code & 0x3f);
+      continue;
+    }
+    if ((code & 0xfc00) === 0xd800) {
+      if (i + 1 < value.length) {
+        const next = value.charCodeAt(i + 1);
+        if ((next & 0xfc00) === 0xdc00) {
+          const point = ((code - 0xd800) << 10) + (next - 0xdc00) + 0x10000;
+          buf[offset++] = 0xf0 | (point >> 18);
+          buf[offset++] = 0x80 | ((point >> 12) & 0x3f);
+          buf[offset++] = 0x80 | ((point >> 6) & 0x3f);
+          buf[offset++] = 0x80 | (point & 0x3f);
+          i++;
+          continue;
+        }
+      }
+      code = 0xfffd;
+    } else if ((code & 0xfc00) === 0xdc00) {
+      code = 0xfffd;
+    }
+    buf[offset++] = 0xe0 | (code >> 12);
+    buf[offset++] = 0x80 | ((code >> 6) & 0x3f);
+    buf[offset++] = 0x80 | (code & 0x3f);
+  }
+  return offset;
+}
+function __varint64Size(value) {
+  let size = 1;
+  while (value > 0x7fn) {
+    value >>= 7n;
+    size++;
+  }
+  return size;
+}
+function __writeVarint64(buf, offset, value) {
+  while (value > 0x7fn) {
+    buf[offset++] = Number((value & 0x7fn) | 0x80n);
+    value >>= 7n;
+  }
+  buf[offset++] = Number(value);
+  return offset;
+}
+function __zigZagEncode64(value) {
+  value = BigInt.asIntN(64, value);
+  return BigInt.asUintN(64, (value << 1n) ^ (value >> 63n));
+}
+function __zigZagDecode64(value) {
+  return BigInt.asIntN(64, (value >> 1n) ^ -(value & 1n));
+}
+function __writeFloat32(buf, offset, value) {
+  __scratch.setFloat32(0, value, true);
+  buf[offset++] = __scratch.getUint8(0);
+  buf[offset++] = __scratch.getUint8(1);
+  buf[offset++] = __scratch.getUint8(2);
+  buf[offset++] = __scratch.getUint8(3);
+  return offset;
+}
+function __readFloat32(data, offset) {
+  __scratch.setUint8(0, data[offset]);
+  __scratch.setUint8(1, data[offset + 1]);
+  __scratch.setUint8(2, data[offset + 2]);
+  __scratch.setUint8(3, data[offset + 3]);
+  return __scratch.getFloat32(0, true);
+}
+function __writeFloat64(buf, offset, value) {
+  __scratch.setFloat64(0, value, true);
+  buf[offset++] = __scratch.getUint8(0);
+  buf[offset++] = __scratch.getUint8(1);
+  buf[offset++] = __scratch.getUint8(2);
+  buf[offset++] = __scratch.getUint8(3);
+  buf[offset++] = __scratch.getUint8(4);
+  buf[offset++] = __scratch.getUint8(5);
+  buf[offset++] = __scratch.getUint8(6);
+  buf[offset++] = __scratch.getUint8(7);
+  return offset;
+}
+function __readFloat64(data, offset) {
+  __scratch.setUint8(0, data[offset]);
+  __scratch.setUint8(1, data[offset + 1]);
+  __scratch.setUint8(2, data[offset + 2]);
+  __scratch.setUint8(3, data[offset + 3]);
+  __scratch.setUint8(4, data[offset + 4]);
+  __scratch.setUint8(5, data[offset + 5]);
+  __scratch.setUint8(6, data[offset + 6]);
+  __scratch.setUint8(7, data[offset + 7]);
+  return __scratch.getFloat64(0, true);
+}
+function __writeFixed64(buf, offset, value) {
+  value = BigInt.asUintN(64, value);
+  buf[offset++] = Number(value & 0xffn);
+  buf[offset++] = Number((value >> 8n) & 0xffn);
+  buf[offset++] = Number((value >> 16n) & 0xffn);
+  buf[offset++] = Number((value >> 24n) & 0xffn);
+  buf[offset++] = Number((value >> 32n) & 0xffn);
+  buf[offset++] = Number((value >> 40n) & 0xffn);
+  buf[offset++] = Number((value >> 48n) & 0xffn);
+  buf[offset++] = Number((value >> 56n) & 0xffn);
+  return offset;
+}
+function __readFixed64(data, offset) {
+  return BigInt(data[offset])
+    | (BigInt(data[offset + 1]) << 8n)
+    | (BigInt(data[offset + 2]) << 16n)
+    | (BigInt(data[offset + 3]) << 24n)
+    | (BigInt(data[offset + 4]) << 32n)
+    | (BigInt(data[offset + 5]) << 40n)
+    | (BigInt(data[offset + 6]) << 48n)
+    | (BigInt(data[offset + 7]) << 56n);
+}`;
+function generateCode(registry) {
+  if (registry.size === 0) return "";
+  const parts = [CODEGEN_PREAMBLE];
+  for (const msg of registry.values()) {
+    parts.push(generateEncoder(msg, registry));
+    parts.push(generateDecoder(msg, registry));
+  }
+  return parts.join("\n");
+}
+
+// src/transform/replacer.ts
+import ts5 from "typescript";
+function applyReplacements(code, sf, callSites, registry) {
+  const edits = [];
+  for (const cs of callSites) {
+    const mangled = typeNodeToMangledName(cs.firstTypeArg, sf);
+    if (registry.has(mangled)) {
+      edits.push({
+        start: cs.exprStart,
+        end: cs.typeArgsEnd,
+        replacement: `${cs.fnName}_${mangled}`
+      });
+    }
+  }
+  if (!edits.length) return { transformedCode: code, hasReplacements: false };
+  edits.sort((a, b) => b.start - a.start);
+  let result = code;
+  for (const ed of edits) result = result.slice(0, ed.start) + ed.replacement + result.slice(ed.end);
+  return { transformedCode: result, hasReplacements: true };
+}
+function replaceCallSites(code, registry) {
+  const sf = ts5.createSourceFile("input.ts", code, ts5.ScriptTarget.Latest, true);
+  const callSites = [];
+  ts5.forEachChild(sf, function visit(node) {
+    if (ts5.isCallExpression(node)) {
+      const e = node.expression;
+      if (ts5.isIdentifier(e) && (e.text === "protobuf_encode" || e.text === "protobuf_decode")) {
+        const ta = node.typeArguments;
+        if (ta?.length) {
+          callSites.push({
+            fnName: e.text,
+            exprStart: e.getStart(sf),
+            typeArgsEnd: ta.end + 1,
+            firstTypeArg: ta[0]
+          });
+        }
+      }
+    }
+    ts5.forEachChild(node, visit);
+  });
+  return applyReplacements(code, sf, callSites, registry);
+}
+
+// src/index.ts
+function protobufVitePlugin() {
+  return {
+    name: "vite-plugin-protobuf",
+    enforce: "pre",
+    transform(code, id) {
+      if (!id.endsWith(".ts") || id.endsWith(".d.ts")) return null;
+      const { registry, callSites, sourceFile } = analyze(code, id);
+      if (registry.size === 0) return null;
+      const generatedCode = generateCode(registry);
+      const { transformedCode, hasReplacements } = applyReplacements(code, sourceFile, callSites, registry);
+      if (!hasReplacements && generatedCode === "") return null;
+      return { code: generatedCode + "\n" + transformedCode, map: null };
+    }
+  };
+}
+export {
+  analyze,
+  analyzeSource,
+  applyReplacements,
+  protobufVitePlugin as default,
+  generateCode,
+  replaceCallSites,
+  typeNodeToMangledName
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "protobuf-fastdsl",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "protobuf.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./protobuf.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "bench": "npx tsx bench/index.ts"
+  },
+  "dependencies": {
+    "typescript": "^5.5.0"
+  },
+  "peerDependencies": {
+    "vite": "^5.0.0 || ^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "tsup": "^8.0.0",
+    "vite": "^6.0.0",
+    "vitest": "^3.0.0"
+  }
+}

package/protobuf.d.ts

@@ -0,0 +1,25 @@
+// ── Protobuf field markers ────────────────────────────────────────────
+/** Marks a singular protobuf field: `name: pb<fieldNumber, Type>` */
+type pb<_ProtoNumber extends number, Type> = Type;
+/** Marks a repeated protobuf field: `ids: pb_repeated<fieldNumber, Type>` → Type[] */
+type pb_repeated<_ProtoNumber extends number, Type> = Type[];
+
+// ── Protobuf primitive types ──────────────────────────────────────────
+type uint_32 = number;
+type int_32 = number;
+type uint_64 = bigint;
+type int_64 = bigint;
+type sint_32 = number;
+type sint_64 = bigint;
+type bool = boolean;
+type float = number;
+type double = number;
+type fixed_32 = number;
+type fixed_64 = bigint;
+type sfixed_32 = number;
+type sfixed_64 = bigint;
+type bytes = Uint8Array;
+
+// ── Encode / decode stubs (replaced at compile-time by the vite plugin) ──
+declare function protobuf_encode<T>(params: T): Uint8Array;
+declare function protobuf_decode<T>(data: Uint8Array): T;