protobuf-fastdsl 0.1.3 → 0.1.6

package/dist/chunk-ZIB6RCYI.js

@@ -0,0 +1,947 @@
+// src/ast/dependency-graph.ts
+function collectDependencyClosure(registry, roots) {
+  const selected = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (selected.has(name)) return;
+    const msg = registry.get(name);
+    if (!msg) return;
+    selected.add(name);
+    for (const field of msg.fields) {
+      if (registry.has(field.typeName)) visit(field.typeName);
+    }
+  }
+  for (const root of roots) visit(root);
+  return selected;
+}
+function pickRegistrySubset(registry, selectedNames) {
+  const subset = /* @__PURE__ */ new Map();
+  for (const [name, msg] of registry) {
+    if (selectedNames.has(name)) subset.set(name, msg);
+  }
+  return subset;
+}
+function buildDependencyRegistry(registry, roots) {
+  const selected = collectDependencyClosure(registry, roots);
+  return pickRegistrySubset(registry, selected);
+}
+
+// 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/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 (typeName === "sint_32") {
+    return {
+      declare: [`  const ${valueVar} = obj.${name};`],
+      size: [
+        `  if (${valueVar} != null && ${valueVar} !== 0) {`,
+        `    const _val = ((${valueVar} << 1) ^ (${valueVar} >> 31)) >>> 0;`,
+        `    size += ${tagLength};`,
+        varintSize("_val", "    "),
+        `  }`
+      ],
+      write: [
+        `  if (${valueVar} != null && ${valueVar} !== 0) {`,
+        writeTag(fieldNumber, 0, "    "),
+        writeVarint(`((${valueVar} << 1) ^ (${valueVar} >> 31)) >>> 0`, "    "),
+        `  }`
+      ]
+    };
+  }
+  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 (typeName === "sint_32") {
+    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] << 1) ^ (${arrayVar}[_i] >> 31)) >>> 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] << 1) ^ (${arrayVar}[_i] >> 31)) >>> 0`, "      "),
+        `    }`,
+        `  }`
+      ]
+    };
+  }
+  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 (typeName === "sint_32") {
+    L.push(varintDec("_val", I));
+    L.push(assign(`(_val >>> 1) ^ -(_val & 1)`));
+  } 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/runtime-map.ts
+function cloneField(field) {
+  return {
+    name: field.name,
+    fieldNumber: field.fieldNumber,
+    typeName: field.typeName,
+    wireType: field.wireType,
+    isMessage: field.isMessage,
+    isOptional: field.isOptional,
+    isRepeated: field.isRepeated
+  };
+}
+function cloneMessage(msg) {
+  return {
+    name: msg.name,
+    fields: msg.fields.map(cloneField)
+  };
+}
+function registryToRuntimeMapMessages(registry) {
+  return [...registry.values()].map(cloneMessage);
+}
+function runtimeMapToRegistry(map) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const msg of map.messages) {
+    registry.set(msg.name, cloneMessage(msg));
+  }
+  return registry;
+}
+function normalizeRuntimeMapPath(filePath) {
+  const noQuery = filePath.replace(/[?#].*$/, "");
+  return noQuery.replace(/\\/g, "/").replace(/^file:\/\//, "");
+}
+function createRuntimeMap(map) {
+  const dedupedCallSites = /* @__PURE__ */ new Map();
+  for (const cs of map.callSites) {
+    const normalized = {
+      ...cs,
+      file: normalizeRuntimeMapPath(cs.file)
+    };
+    const key = `${normalized.file}:${normalized.line}:${normalized.column}:${normalized.fnName}:${normalized.typeName}`;
+    dedupedCallSites.set(key, normalized);
+  }
+  return {
+    version: 1,
+    messages: registryToRuntimeMapMessages(map.messages),
+    callSites: [...dedupedCallSites.values()]
+  };
+}
+
+export {
+  PRIMITIVE_TYPE_MAP,
+  PB_MARKER,
+  PB_REPEATED_MARKER,
+  buildDependencyRegistry,
+  generateCode,
+  runtimeMapToRegistry,
+  normalizeRuntimeMapPath,
+  createRuntimeMap
+};