@dcl/protocol 1.0.0-28172947415.commit-c2f6832 → 1.0.0-28173821783.commit-63eb0db

package/protoc-gen-bitwise/options.js

@@ -1,108 +0,0 @@
-'use strict'
-
-/**
- * Parser for the custom bitwise field options defined in options.proto.
- *
- * The descriptor decoder hands us the raw serialized FieldOptions bytes (it
- * declares `options` as opaque bytes). We walk those bytes looking for the two
- * custom extension field numbers — protobuf preserves unknown/unregistered
- * extension bytes, so they are always present even though no runtime here knows
- * the extension schema. This mirrors the original options_pb2.py.
- *
- * Wire format: tag = (field_number << 3) | wire_type
- *   wire_type 0 = varint, 1 = 64-bit, 2 = length-delimited, 5 = 32-bit
- */
-
-const { readVarint, skipField } = require('./wire')
-
-// Extension field numbers as defined in options.proto.
-const QUANTIZED_FIELD_NUMBER = 50001
-const BIT_PACKED_FIELD_NUMBER = 50002
-
-/** Parse a serialized QuantizedFloatOptions message: { min, max, bits }. */
-function parseQuantized(data) {
-  const opts = { min: 0.0, max: 0.0, bits: 0 }
-  let pos = 0
-  while (pos < data.length) {
-    let tag
-    ;[tag, pos] = readVarint(data, pos)
-    const fieldNum = tag >>> 3
-    const wireType = tag & 0x7
-    if (fieldNum === 1 && wireType === 5) {
-      // min (float)
-      opts.min = data.readFloatLE(pos)
-      pos += 4
-    } else if (fieldNum === 2 && wireType === 5) {
-      // max (float)
-      opts.max = data.readFloatLE(pos)
-      pos += 4
-    } else if (fieldNum === 3 && wireType === 0) {
-      // bits (uint32)
-      ;[opts.bits, pos] = readVarint(data, pos)
-    } else {
-      pos = skipField(data, pos, wireType)
-    }
-  }
-  return opts
-}
-
-/** Parse a serialized BitPackedOptions message: { bits }. */
-function parseBitPacked(data) {
-  const opts = { bits: 0 }
-  let pos = 0
-  while (pos < data.length) {
-    let tag
-    ;[tag, pos] = readVarint(data, pos)
-    const fieldNum = tag >>> 3
-    const wireType = tag & 0x7
-    if (fieldNum === 1 && wireType === 0) {
-      // bits (uint32)
-      ;[opts.bits, pos] = readVarint(data, pos)
-    } else {
-      pos = skipField(data, pos, wireType)
-    }
-  }
-  return opts
-}
-
-/**
- * Extract custom bitwise options from raw FieldOptions bytes.
- *
- * @param {Buffer|null} optionsRaw serialized FieldOptions, or null when unset.
- * @returns {{quantized: object|null, bitPacked: object|null}}
- */
-function getFieldOptions(optionsRaw) {
-  if (!optionsRaw || optionsRaw.length === 0) {
-    return { quantized: null, bitPacked: null }
-  }
-
-  let quantized = null
-  let bitPacked = null
-  let pos = 0
-
-  while (pos < optionsRaw.length) {
-    let tag
-    ;[tag, pos] = readVarint(optionsRaw, pos)
-    const fieldNum = tag >>> 3
-    const wireType = tag & 0x7
-
-    if (wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(optionsRaw, pos)
-      const valueBytes = optionsRaw.subarray(pos, pos + len)
-      pos += len
-      if (fieldNum === QUANTIZED_FIELD_NUMBER) {
-        quantized = parseQuantized(valueBytes)
-      } else if (fieldNum === BIT_PACKED_FIELD_NUMBER) {
-        bitPacked = parseBitPacked(valueBytes)
-      }
-      // else: unknown length-delimited field — already consumed.
-    } else {
-      pos = skipField(optionsRaw, pos, wireType)
-    }
-  }
-
-  return { quantized, bitPacked }
-}
-
-module.exports = { getFieldOptions }

package/protoc-gen-bitwise/plugin.js

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-'use strict'
-
-/**
- * protoc-gen-bitwise — protoc plugin that generates C# bitwise serialization code.
- *
- * Protocol:
- *   1. protoc writes a serialised CodeGeneratorRequest to this process's stdin.
- *   2. This plugin reads it, generates C# partial classes with float accessor
- *      properties for every message that carries [(quantized)] field annotations.
- *   3. A serialised CodeGeneratorResponse is written to stdout.
- *
- * Implemented in plain Node with a self-contained protobuf wire codec (see
- * wire.js) so it runs with only `node` on PATH — no npm install required, even
- * when invoked directly from a sibling checkout.
- *
- * Usage (from project root):
- *   protoc \
- *     --proto_path=proto \
- *     --bitwise_out=generated/ \
- *     --plugin=protoc-gen-bitwise=protoc-gen-bitwise/plugin.js \
- *     proto/my_messages.proto
- *
- * On Windows, protoc needs an executable wrapper, e.g. a .cmd that runs:
- *   node "<path>\protoc-gen-bitwise\plugin.js" %*
- */
-
-const { decodeRequest, encodeResponse } = require('./wire')
-const { generateCsharp } = require('./generator_csharp')
-
-// CodeGeneratorResponse.Feature.FEATURE_PROTO3_OPTIONAL — advertised so protoc
-// does not reject the plugin when the schema uses proto3 `optional` fields.
-const FEATURE_PROTO3_OPTIONAL = 1
-
-function readStdin() {
-  return new Promise((resolve, reject) => {
-    const chunks = []
-    process.stdin.on('data', (chunk) => chunks.push(chunk))
-    process.stdin.on('end', () => resolve(Buffer.concat(chunks)))
-    process.stdin.on('error', reject)
-  })
-}
-
-async function main() {
-  const requestBytes = await readStdin()
-  const request = decodeRequest(requestBytes)
-
-  // Lookup map for all file descriptors (parity with the Python plugin).
-  const fileByName = new Map()
-  for (const file of request.protoFile) fileByName.set(file.name, file)
-
-  const files = []
-  let error = null
-
-  for (const fileName of request.fileToGenerate) {
-    // Skip the options definition file itself — it has no messages to generate.
-    if (fileName === 'decentraland/common/options.proto') continue
-
-    const fileProto = fileByName.get(fileName)
-    if (!fileProto) continue
-
-    try {
-      const generated = generateCsharp(fileProto)
-      if (generated) files.push(generated)
-    } catch (exc) {
-      error = `protoc-gen-bitwise: error processing ${fileName}: ${exc && exc.message ? exc.message : exc}`
-    }
-  }
-
-  const response = encodeResponse({
-    error,
-    supportedFeatures: FEATURE_PROTO3_OPTIONAL,
-    files,
-  })
-
-  // Let the write flush before the process exits (do not call process.exit()).
-  process.stdout.write(response)
-}
-
-main().catch((exc) => {
-  const response = encodeResponse({
-    error: `protoc-gen-bitwise: ${exc && exc.stack ? exc.stack : exc}`,
-    supportedFeatures: FEATURE_PROTO3_OPTIONAL,
-    files: [],
-  })
-  process.stdout.write(response)
-})

package/protoc-gen-bitwise/runtime/cs/BitReader.cs

@@ -1,112 +0,0 @@
-// Decentraland.Networking.Bitwise — BitReader
-// Copy this file into your Unity project alongside generated *.Bitwise.cs files.
-
-using System;
-
-namespace Decentraland.Networking.Bitwise
-{
-    /// <summary>
-    /// Reads bits from a byte buffer, MSB first within each byte (big-endian bit
-    /// order).  Symmetric counterpart of <see cref="BitWriter"/>: every
-    /// Write… call has a corresponding Read… call with identical arguments that
-    /// reproduces the original value.
-    /// </summary>
-    public sealed class BitReader
-    {
-        private readonly byte[] _buffer;
-        private int _bitPos;
-
-        /// <param name="buffer">Source buffer filled by a <see cref="BitWriter"/>.</param>
-        public BitReader(byte[] buffer)
-        {
-            _buffer = buffer ?? throw new ArgumentNullException(nameof(buffer));
-            _bitPos = 0;
-        }
-
-        /// <summary>Current read position in bits.</summary>
-        public int BitPosition => _bitPos;
-
-        /// <summary>
-        /// Returns <c>true</c> when all written bits have been consumed
-        /// (i.e. <see cref="BitPosition"/> has reached the end of the buffer).
-        /// </summary>
-        public bool IsAtEnd => _bitPos >= _buffer.Length * 8;
-
-        // -----------------------------------------------------------------
-        // Core primitive
-        // -----------------------------------------------------------------
-
-        /// <summary>
-        /// Reads <paramref name="bits"/> bits and returns them as the
-        /// least-significant bits of a <see cref="uint"/>, MSB first.
-        /// </summary>
-        public uint ReadBits(int bits)
-        {
-            uint value = 0;
-            for (int i = bits - 1; i >= 0; i--)
-            {
-                int byteIdx = _bitPos / 8;
-                int bitIdx  = 7 - (_bitPos % 8);
-
-                if ((_buffer[byteIdx] >> bitIdx & 1) == 1)
-                    value |= 1u << i;
-
-                _bitPos++;
-            }
-            return value;
-        }
-
-        // -----------------------------------------------------------------
-        // Quantized float
-        // -----------------------------------------------------------------
-
-        /// <summary>
-        /// Reads a quantized float encoded with <see cref="BitWriter.WriteQuantizedFloat"/>.
-        /// Arguments must match those used during encoding exactly.
-        /// </summary>
-        public float ReadQuantizedFloat(float min, float max, int bits)
-        {
-            uint  maxQ       = (1u << bits) - 1;
-            uint  quantized  = ReadBits(bits);
-            float normalized = (float)quantized / maxQ;
-            return min + normalized * (max - min);
-        }
-
-        // -----------------------------------------------------------------
-        // Standard IEEE 754 helpers
-        // -----------------------------------------------------------------
-
-        /// <summary>Reads a 32-bit IEEE 754 float written by <see cref="BitWriter.WriteFloat"/>.</summary>
-        public float ReadFloat()
-        {
-            uint bits = ReadBits(32);
-            byte[] bytes =
-            {
-                (byte)(bits        & 0xFF),
-                (byte)((bits >> 8)  & 0xFF),
-                (byte)((bits >> 16) & 0xFF),
-                (byte)((bits >> 24) & 0xFF),
-            };
-            return BitConverter.ToSingle(bytes, 0);
-        }
-
-        /// <summary>Reads a 64-bit IEEE 754 double written by <see cref="BitWriter.WriteDouble"/>.</summary>
-        public double ReadDouble()
-        {
-            uint hi = ReadBits(32);
-            uint lo = ReadBits(32);
-            byte[] bytes =
-            {
-                (byte)(lo         & 0xFF),
-                (byte)((lo >> 8)  & 0xFF),
-                (byte)((lo >> 16) & 0xFF),
-                (byte)((lo >> 24) & 0xFF),
-                (byte)(hi         & 0xFF),
-                (byte)((hi >> 8)  & 0xFF),
-                (byte)((hi >> 16) & 0xFF),
-                (byte)((hi >> 24) & 0xFF),
-            };
-            return BitConverter.ToDouble(bytes, 0);
-        }
-    }
-}

package/protoc-gen-bitwise/runtime/cs/BitWriter.cs

@@ -1,117 +0,0 @@
-// Decentraland.Networking.Bitwise — BitWriter
-// Copy this file into your Unity project alongside generated *.Bitwise.cs files.
-
-using System;
-
-namespace Decentraland.Networking.Bitwise
-{
-    /// <summary>
-    /// Writes bits into a pre-allocated byte buffer, MSB first within each byte
-    /// (big-endian bit order).  This matches the layout expected by
-    /// <see cref="BitReader"/> so that encode → decode is always a round-trip no-op.
-    /// </summary>
-    public sealed class BitWriter
-    {
-        private readonly byte[] _buffer;
-        private int _bitPos;
-
-        /// <param name="buffer">Destination buffer (must be large enough for all writes).</param>
-        public BitWriter(byte[] buffer)
-        {
-            _buffer = buffer ?? throw new ArgumentNullException(nameof(buffer));
-            _bitPos = 0;
-        }
-
-        /// <summary>Current write position in bits.</summary>
-        public int BitPosition => _bitPos;
-
-        /// <summary>Number of bytes written (rounded up to the nearest byte).</summary>
-        public int ByteLength => (_bitPos + 7) / 8;
-
-        /// <summary>Returns a copy of the written bytes (trimmed to <see cref="ByteLength"/>).</summary>
-        public byte[] ToArray()
-        {
-            var result = new byte[ByteLength];
-            Array.Copy(_buffer, result, ByteLength);
-            return result;
-        }
-
-        // -----------------------------------------------------------------
-        // Core primitive
-        // -----------------------------------------------------------------
-
-        /// <summary>
-        /// Writes the <paramref name="bits"/> least-significant bits of
-        /// <paramref name="value"/>, MSB first.
-        /// </summary>
-        public void WriteBits(uint value, int bits)
-        {
-            for (int i = bits - 1; i >= 0; i--)
-            {
-                int byteIdx = _bitPos / 8;
-                int bitIdx  = 7 - (_bitPos % 8);
-
-                if ((value >> i & 1u) == 1u)
-                    _buffer[byteIdx] |=  (byte)(1 << bitIdx);
-                else
-                    _buffer[byteIdx] &= (byte)~(1 << bitIdx);
-
-                _bitPos++;
-            }
-        }
-
-        // -----------------------------------------------------------------
-        // Quantized float
-        // -----------------------------------------------------------------
-
-        /// <summary>
-        /// Quantizes <paramref name="value"/> into <paramref name="bits"/> bits
-        /// using the range [<paramref name="min"/>, <paramref name="max"/>] and
-        /// writes it to the buffer.
-        ///
-        /// Uses <c>Math.Round</c> (banker's rounding → ties-to-even) to guarantee
-        /// that encode → decode is a round-trip no-op.
-        /// </summary>
-        public void WriteQuantizedFloat(float value, float min, float max, int bits)
-        {
-            uint  maxQ       = (1u << bits) - 1;
-            float clamped    = Math.Clamp(value, min, max);
-            float normalized = (clamped - min) / (max - min);
-            uint  quantized  = (uint)Math.Round(normalized * maxQ);
-            WriteBits(quantized, bits);
-        }
-
-        // -----------------------------------------------------------------
-        // Standard IEEE 754 helpers (used for un-annotated float/double fields)
-        // -----------------------------------------------------------------
-
-        /// <summary>Writes a 32-bit IEEE 754 float (4 bytes).</summary>
-        public void WriteFloat(float value)
-        {
-            byte[] bytes = BitConverter.GetBytes(value);
-            // GetBytes is little-endian on all platforms; write MSB first.
-            uint bits = (uint)bytes[0]
-                      | ((uint)bytes[1] << 8)
-                      | ((uint)bytes[2] << 16)
-                      | ((uint)bytes[3] << 24);
-            WriteBits(bits, 32);
-        }
-
-        /// <summary>Writes a 64-bit IEEE 754 double (8 bytes).</summary>
-        public void WriteDouble(double value)
-        {
-            byte[] bytes = BitConverter.GetBytes(value);
-            uint lo = (uint)bytes[0]
-                    | ((uint)bytes[1] << 8)
-                    | ((uint)bytes[2] << 16)
-                    | ((uint)bytes[3] << 24);
-            uint hi = (uint)bytes[4]
-                    | ((uint)bytes[5] << 8)
-                    | ((uint)bytes[6] << 16)
-                    | ((uint)bytes[7] << 24);
-            // Write high 32 bits first so the bit stream is big-endian at word level too.
-            WriteBits(hi, 32);
-            WriteBits(lo, 32);
-        }
-    }
-}

package/protoc-gen-bitwise/runtime/cs/Quantize.cs

@@ -1,35 +0,0 @@
-// Decentraland.Networking.Bitwise — Quantize
-// Copy this file into your project alongside generated *.Bitwise.cs files.
-// ReSharper disable once RedundantUsingDirective
-
-using System;
-
-namespace Decentraland.Networking.Bitwise
-    // ReSharper disable once ArrangeNamespaceBody
-{
-    /// <summary>
-    ///     Static helpers for quantizing float values to/from unsigned integers.
-    ///     Intended for use with protobuf uint32 fields: the integer is transmitted
-    ///     as a protobuf varint, while the float accessor lives in a generated partial class.
-    /// </summary>
-    public static class Quantize
-    {
-        /// <summary>
-        ///     Encodes <paramref name="value" /> to a quantized <see cref="uint" />.
-        ///     Values outside [<paramref name="min" />, <paramref name="max" />] are clamped.
-        /// </summary>
-        public static uint Encode(float value, float min, float max, int bits)
-        {
-            var steps = (1u << bits) - 1;
-            var t = Math.Clamp((value - min) / (max - min), 0f, 1f);
-            return (uint)MathF.Round(t * steps);
-        }
-
-        /// <summary>Decodes a quantized <see cref="uint" /> back to a float.</summary>
-        public static float Decode(uint encoded, float min, float max, int bits)
-        {
-            var steps = (1u << bits) - 1;
-            return (float)encoded / steps * (max - min) + min;
-        }
-    }
-}

package/protoc-gen-bitwise/wire.js

@@ -1,239 +0,0 @@
-'use strict'
-
-/**
- * Self-contained protobuf wire-format codec for protoc-gen-bitwise.
- *
- * The plugin only needs a tiny slice of the descriptor/plugin schemas, so
- * rather than pull in a protobuf runtime (which would force every consumer —
- * including the sibling Pulse checkout that runs this file directly off disk —
- * to `npm install` the protocol repo) we decode the handful of fields we care
- * about by walking the wire format directly. This mirrors the original Python
- * plugin, which already hand-parsed FieldOptions for the same reason.
- *
- * Decoded subset:
- *   CodeGeneratorRequest { file_to_generate = 1; proto_file = 15; }
- *   FileDescriptorProto  { name = 1; package = 2; message_type = 4; }
- *   DescriptorProto      { name = 1; field = 2; }
- *   FieldDescriptorProto { name = 1; label = 4; type = 5; options = 8 (raw bytes); }
- *
- * Encoded subset:
- *   CodeGeneratorResponse { error = 1; supported_features = 2; file = 15; }
- *   CodeGeneratorResponse.File { name = 1; content = 15; }
- *
- * Wire types: 0 = varint, 1 = 64-bit, 2 = length-delimited, 5 = 32-bit.
- */
-
-// ---------------------------------------------------------------------------
-// Low-level readers
-// ---------------------------------------------------------------------------
-
-/** Decode a protobuf varint at `pos`. Returns [value, newPos]. */
-function readVarint(buf, pos) {
-  let result = 0
-  let shift = 0
-  let byte
-  do {
-    byte = buf[pos++]
-    // Multiplication (not <<) keeps values correct past 32 bits.
-    result += (byte & 0x7f) * Math.pow(2, shift)
-    shift += 7
-  } while (byte & 0x80)
-  return [result, pos]
-}
-
-/** Advance `pos` past a field of the given wire type. Returns newPos. */
-function skipField(buf, pos, wireType) {
-  switch (wireType) {
-    case 0: // varint
-      return readVarint(buf, pos)[1]
-    case 1: // 64-bit
-      return pos + 8
-    case 2: {
-      // length-delimited
-      const [length, next] = readVarint(buf, pos)
-      return next + length
-    }
-    case 5: // 32-bit
-      return pos + 4
-    default:
-      // Groups (3/4) are deprecated and never appear in descriptors.
-      return pos
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Request decoding
-// ---------------------------------------------------------------------------
-
-function decodeFieldDescriptor(buf) {
-  const field = { name: '', label: 0, type: 0, optionsRaw: null }
-  let pos = 0
-  while (pos < buf.length) {
-    let tag
-    ;[tag, pos] = readVarint(buf, pos)
-    const fieldNum = tag >>> 3
-    const wireType = tag & 0x7
-    if (fieldNum === 1 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      field.name = buf.toString('utf8', pos, pos + len)
-      pos += len
-    } else if (fieldNum === 4 && wireType === 0) {
-      ;[field.label, pos] = readVarint(buf, pos)
-    } else if (fieldNum === 5 && wireType === 0) {
-      ;[field.type, pos] = readVarint(buf, pos)
-    } else if (fieldNum === 8 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      // Keep the raw FieldOptions bytes so custom extensions survive (the
-      // descriptor schema doesn't know about ext 50001/50002).
-      field.optionsRaw = buf.subarray(pos, pos + len)
-      pos += len
-    } else {
-      pos = skipField(buf, pos, wireType)
-    }
-  }
-  return field
-}
-
-function decodeDescriptor(buf) {
-  const message = { name: '', field: [] }
-  let pos = 0
-  while (pos < buf.length) {
-    let tag
-    ;[tag, pos] = readVarint(buf, pos)
-    const fieldNum = tag >>> 3
-    const wireType = tag & 0x7
-    if (fieldNum === 1 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      message.name = buf.toString('utf8', pos, pos + len)
-      pos += len
-    } else if (fieldNum === 2 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      message.field.push(decodeFieldDescriptor(buf.subarray(pos, pos + len)))
-      pos += len
-    } else {
-      // nested_type / enum_type / etc. are intentionally ignored — the
-      // generator only walks top-level messages, matching the Python plugin.
-      pos = skipField(buf, pos, wireType)
-    }
-  }
-  return message
-}
-
-function decodeFileDescriptor(buf) {
-  const file = { name: '', package: '', messageType: [] }
-  let pos = 0
-  while (pos < buf.length) {
-    let tag
-    ;[tag, pos] = readVarint(buf, pos)
-    const fieldNum = tag >>> 3
-    const wireType = tag & 0x7
-    if (fieldNum === 1 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      file.name = buf.toString('utf8', pos, pos + len)
-      pos += len
-    } else if (fieldNum === 2 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      file.package = buf.toString('utf8', pos, pos + len)
-      pos += len
-    } else if (fieldNum === 4 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      file.messageType.push(decodeDescriptor(buf.subarray(pos, pos + len)))
-      pos += len
-    } else {
-      pos = skipField(buf, pos, wireType)
-    }
-  }
-  return file
-}
-
-/** Decode a serialized CodeGeneratorRequest. */
-function decodeRequest(buf) {
-  const request = { fileToGenerate: [], protoFile: [] }
-  let pos = 0
-  while (pos < buf.length) {
-    let tag
-    ;[tag, pos] = readVarint(buf, pos)
-    const fieldNum = tag >>> 3
-    const wireType = tag & 0x7
-    if (fieldNum === 1 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      request.fileToGenerate.push(buf.toString('utf8', pos, pos + len))
-      pos += len
-    } else if (fieldNum === 15 && wireType === 2) {
-      let len
-      ;[len, pos] = readVarint(buf, pos)
-      request.protoFile.push(decodeFileDescriptor(buf.subarray(pos, pos + len)))
-      pos += len
-    } else {
-      pos = skipField(buf, pos, wireType)
-    }
-  }
-  return request
-}
-
-// ---------------------------------------------------------------------------
-// Response encoding
-// ---------------------------------------------------------------------------
-
-/** Encode an unsigned integer as a protobuf varint Buffer. */
-function encodeVarint(value) {
-  const bytes = []
-  let v = value
-  while (v > 0x7f) {
-    bytes.push((v & 0x7f) | 0x80)
-    v = Math.floor(v / 128)
-  }
-  bytes.push(v & 0x7f)
-  return Buffer.from(bytes)
-}
-
-function encodeTag(fieldNum, wireType) {
-  return encodeVarint((fieldNum << 3) | wireType)
-}
-
-/** Encode a length-delimited (string/bytes) field: tag + length + payload. */
-function encodeLengthDelimited(fieldNum, payload) {
-  const buf = Buffer.isBuffer(payload) ? payload : Buffer.from(payload, 'utf8')
-  return Buffer.concat([encodeTag(fieldNum, 2), encodeVarint(buf.length), buf])
-}
-
-function encodeFile(file) {
-  return Buffer.concat([
-    encodeLengthDelimited(1, file.name), // name = 1
-    encodeLengthDelimited(15, file.content), // content = 15
-  ])
-}
-
-/**
- * Encode a CodeGeneratorResponse.
- * @param {{error?: string|null, supportedFeatures?: number, files?: Array<{name:string,content:string}>}} response
- */
-function encodeResponse(response) {
-  const parts = []
-  if (response.error != null) {
-    parts.push(encodeLengthDelimited(1, response.error)) // error = 1
-  }
-  if (response.supportedFeatures != null) {
-    parts.push(encodeTag(2, 0)) // supported_features = 2 (varint)
-    parts.push(encodeVarint(response.supportedFeatures))
-  }
-  for (const file of response.files || []) {
-    parts.push(encodeLengthDelimited(15, encodeFile(file))) // file = 15
-  }
-  return Buffer.concat(parts)
-}
-
-module.exports = {
-  readVarint,
-  skipField,
-  decodeRequest,
-  encodeResponse,
-}