@dcl/protocol 1.0.0-27358757907.commit-3c70e8a → 1.0.0-27574288540.commit-f0df3e0

package/README.md

@@ -100,13 +100,11 @@ client can read it without knowledge of the plugin.
 
 | Requirement | Version |
 |---|---|
-| Python | 3.10+ |
-| `protobuf` Python package | 4.x or 3.20+ |
+| Node.js | 16+ |
 | `protoc` | 3.19+ |
 
-```bash
-pip install protobuf
-```
+The plugin is a dependency-free Node script — no `npm install` or extra
+packages are required to run it.
 
 ## Step 1 — Annotate your `.proto` file
 
@@ -157,11 +155,16 @@ protoc \
   --proto_path=proto \
   --proto_path=/path/to/google/protobuf/include \
   --csharp_out=generated/cs \
-  --plugin=protoc-gen-bitwise=protoc-gen-bitwise/plugin.py \
+  --plugin=protoc-gen-bitwise=protoc-gen-bitwise/plugin.js \
   --bitwise_out=generated/cs \
   proto/decentraland/kernel/comms/v3/comms.proto
 ```
 
+> `plugin.js` carries a `#!/usr/bin/env node` shebang. On Windows, protoc
+> cannot exec a `.js` directly, so point `--plugin` at a small `.cmd` wrapper
+> that runs `node plugin.js`; on unix an equivalent shell script is used. Both
+> consumer repos (Pulse, unity-explorer) generate this wrapper automatically.
+
 The plugin emits one `*.Bitwise.cs` file (PascalCase, flat in the output
 directory) for each `.proto` file that contains at least one `[(quantized)]`
 field.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-27358757907.commit-3c70e8a",
+  "version": "1.0.0-27574288540.commit-f0df3e0",
   "description": "",
   "repository": {
     "type": "git",
@@ -13,7 +13,8 @@
   "license": "Apache-2.0",
   "main": "index.js",
   "scripts": {
-    "test": "./scripts/check-proto-compabitility.sh"
+    "test": "./scripts/check-proto-compabitility.sh",
+    "gen:test": "node protoc-gen-bitwise/test/generator.test.js"
   },
   "devDependencies": {
     "@protobuf-ts/protoc": "^2.11.0",
@@ -32,7 +33,8 @@
     "out-ts",
     "out-js",
     "public",
-    "protoc-gen-bitwise"
+    "protoc-gen-bitwise/*.js",
+    "protoc-gen-bitwise/runtime"
   ],
-  "commit": "3c70e8a31967c1171f5470426006675976fcad11"
+  "commit": "f0df3e02ab2f989527ee9b45a1dbc85948842aab"
 }

package/protoc-gen-bitwise/generator_csharp.js

@@ -0,0 +1,215 @@
+'use strict'
+
+/**
+ * C# code generator for the protoc-gen-bitwise plugin.
+ *
+ * For every proto message that contains at least one uint32 field annotated
+ * with [(quantized)], this module emits a C# partial class that adds a computed
+ * float property named {FieldName}Quantized. The getter decodes the stored
+ * uint32 to a float; the setter encodes a float back to a uint32. Standard
+ * protobuf handles serialization of the uint32 wire field; this class adds a
+ * typed float accessor on top.
+ *
+ * Only uint32 fields are supported. bit_packed and unannotated fields are
+ * passed through without generating any accessor.
+ *
+ * Port of the original generator_csharp.py — output is intended to be
+ * byte-for-byte identical.
+ */
+
+const { getFieldOptions } = require('./options')
+
+// FieldDescriptorProto type/label constants.
+const TYPE_UINT32 = 13
+const LABEL_REPEATED = 3
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Mirrors Python str.capitalize(): upper-first, lowercase the rest. */
+function capitalize(word) {
+  if (word.length === 0) return ''
+  return word[0].toUpperCase() + word.slice(1).toLowerCase()
+}
+
+/** position_x -> PositionX */
+function snakeToPascal(name) {
+  return name.split('_').map(capitalize).join('')
+}
+
+/** decentraland.kernel.comms.v3 -> Decentraland.Kernel.Comms.V3 */
+function packageToNamespace(pkg) {
+  if (!pkg) return 'Generated'
+  return pkg.split('.').map(capitalize).join('.')
+}
+
+/**
+ * Format a number with C printf %g semantics at `precision` significant digits:
+ * shortest of fixed/scientific, with trailing zeros and a trailing dot removed.
+ * Reproduces Python's `f'{value:.{precision}g}'`.
+ */
+function formatG(value, precision) {
+  if (precision <= 0) precision = 1
+  if (value === 0) return '0'
+  if (!Number.isFinite(value)) return value > 0 ? 'inf' : 'nan'
+
+  const negative = value < 0
+  const v = Math.abs(value)
+
+  // Correctly-rounded scientific form yields the decimal exponent X (handling
+  // carry such as 9.999 -> 1.0e+1).
+  const sci = v.toExponential(precision - 1)
+  const eIdx = sci.indexOf('e')
+  const X = parseInt(sci.slice(eIdx + 1), 10)
+
+  let result
+  if (X >= -4 && X < precision) {
+    // Fixed notation with (precision - 1 - X) fraction digits.
+    const fractionDigits = precision - 1 - X
+    result = v.toFixed(fractionDigits >= 0 ? fractionDigits : 0)
+    if (result.indexOf('.') !== -1) {
+      result = result.replace(/0+$/, '').replace(/\.$/, '')
+    }
+  } else {
+    // Scientific notation; printf prints at least two exponent digits.
+    let mantissa = sci.slice(0, eIdx)
+    if (mantissa.indexOf('.') !== -1) {
+      mantissa = mantissa.replace(/0+$/, '').replace(/\.$/, '')
+    }
+    const expSign = X < 0 ? '-' : '+'
+    let expDigits = String(Math.abs(X))
+    if (expDigits.length < 2) expDigits = '0' + expDigits
+    result = mantissa + 'e' + expSign + expDigits
+  }
+
+  return (negative ? '-' : '') + result
+}
+
+/** Format a value as a C# float literal (e.g. -100.0f). */
+function formatFloat(value) {
+  let text = formatG(value, 8)
+  if (text.indexOf('.') === -1 && text.indexOf('e') === -1 && text.indexOf('E') === -1) {
+    text += '.0'
+  }
+  return text + 'f'
+}
+
+/** Format a quantization step size for a doc comment (e.g. "≈ 0.003"). */
+function formatStep(step) {
+  return '≈ ' + formatG(step, 6)
+}
+
+// ---------------------------------------------------------------------------
+// Per-message code generation
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a C# partial class for a proto message, or null if it has no
+ * quantized uint32 fields. Returns an array of lines (no trailing newline).
+ */
+function generateMessage(msgProto, indent) {
+  const i = indent || '    '
+  const props = []
+
+  for (const field of msgProto.field) {
+    // Repeated/map fields are not supported.
+    if (field.label === LABEL_REPEATED) continue
+    // Only uint32 fields are candidates for quantized accessors.
+    if (field.type !== TYPE_UINT32) continue
+
+    const { quantized } = getFieldOptions(field.optionsRaw)
+    if (quantized === null) continue
+
+    const step = (quantized.max - quantized.min) / ((1 << quantized.bits) - 1)
+
+    props.push({
+      propName: snakeToPascal(field.name),
+      mn: formatFloat(quantized.min),
+      mx: formatFloat(quantized.max),
+      bits: quantized.bits,
+      step,
+    })
+  }
+
+  if (props.length === 0) return null
+
+  const backings = []
+  const lines = []
+  lines.push(`public partial class ${msgProto.name}`)
+  lines.push('{')
+
+  for (const { propName, mn, mx, bits, step } of props) {
+    const backing = '_' + propName[0].toLowerCase() + propName.slice(1)
+    backings.push(backing)
+    lines.push(`${i}private float? ${backing};`)
+    lines.push(
+      `${i}/// <summary>Float accessor for <see cref="${propName}"/>. Range [${mn}, ${mx}], ${bits} bits, step ${formatStep(step)}.</summary>`,
+    )
+    lines.push(`${i}public float ${propName}Quantized`)
+    lines.push(`${i}{`)
+    lines.push(`${i}${i}get => ${backing} ??= Quantize.Decode(${propName}, ${mn}, ${mx}, ${bits});`)
+    lines.push(`${i}${i}set { ${backing} = value; ${propName} = Quantize.Encode(value, ${mn}, ${mx}, ${bits}); }`)
+    lines.push(`${i}}`)
+    lines.push('')
+  }
+
+  lines.push(`${i}/// <summary>Clears all cached decoded values. Call after mutating raw uint32 fields directly.</summary>`)
+  lines.push(`${i}public void ResetDecodedCache()`)
+  lines.push(`${i}{`)
+  for (const backing of backings) {
+    lines.push(`${i}${i}${backing} = null;`)
+  }
+  lines.push(`${i}}`)
+
+  lines.push('}')
+  return lines
+}
+
+// ---------------------------------------------------------------------------
+// Per-file code generation (public entry point)
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a C# source file for a FileDescriptorProto, or null if the file
+ * contains no quantized uint32 fields.
+ * @returns {{name: string, content: string} | null}
+ */
+function generateCsharp(fileProto) {
+  const namespace = packageToNamespace(fileProto.package)
+
+  const protoFile = fileProto.name.split('/').pop()
+  const stem = snakeToPascal(protoFile.replace('.proto', ''))
+  const outName = `${stem}.Bitwise.cs`
+
+  const header = [
+    '// <auto-generated>',
+    '//   Generated by protoc-gen-bitwise. DO NOT EDIT.',
+    `//   Source: ${fileProto.name}`,
+    '// </auto-generated>',
+    '',
+    'using Decentraland.Networking.Bitwise;',
+    '',
+    `namespace ${namespace}`,
+    '{',
+  ]
+  const footer = ['', `} // namespace ${namespace}`]
+
+  const body = []
+  for (const msg of fileProto.messageType) {
+    const msgLines = generateMessage(msg)
+    if (msgLines === null) continue
+    // Indent each line by 4 spaces (inside the namespace block).
+    for (const line of msgLines) {
+      body.push(line ? '    ' + line : '')
+    }
+    body.push('')
+  }
+
+  if (body.length === 0) return null
+
+  const content = header.concat(body, footer).join('\n') + '\n'
+  return { name: outName, content }
+}
+
+module.exports = { generateCsharp }

package/protoc-gen-bitwise/options.js

@@ -0,0 +1,108 @@
+'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

@@ -0,0 +1,87 @@
+#!/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/wire.js

@@ -0,0 +1,239 @@
+'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,
+}

package/protoc-gen-bitwise/generator_csharp.py

@@ -1,176 +0,0 @@
-"""
-C# code generator for the protoc-gen-bitwise plugin.
-
-For every proto message that contains at least one uint32 field annotated with
-[(quantized)], this module emits a C# partial class that adds a computed float
-property named {FieldName}Quantized.  The getter decodes the stored uint32 to
-a float; the setter encodes a float back to a uint32.  Standard protobuf
-handles serialization of the uint32 wire field; this class adds a typed float
-accessor on top.
-
-Protobuf encodes small uint32 values via varint, so a value that fits in
-2^20 costs 3 bytes on the wire — cheaper than a raw IEEE 754 float (4 bytes).
-
-Only uint32 fields are supported.  bit_packed and unannotated fields are
-passed through without generating any accessor.
-"""
-
-from google.protobuf import descriptor_pb2
-
-from options_pb2 import get_field_options
-
-# FieldDescriptorProto type constants (aliased for readability)
-_FT = descriptor_pb2.FieldDescriptorProto
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def _snake_to_pascal(name: str) -> str:
-    """position_x → PositionX"""
-    return ''.join(word.capitalize() for word in name.split('_'))
-
-
-def _package_to_namespace(package: str) -> str:
-    """decentraland.kernel.comms.v3 → Decentraland.Kernel.Comms.V3"""
-    if not package:
-        return 'Generated'
-    return '.'.join(part.capitalize() for part in package.split('.'))
-
-
-def _format_float(value: float) -> str:
-    """Format a Python float as a C# float literal (e.g. -100.0f)."""
-    text = f'{value:.8g}'
-    if '.' not in text and 'e' not in text and 'E' not in text:
-        text += '.0'
-    return text + 'f'
-
-
-def _format_step(step: float) -> str:
-    """Format a quantization step size for display in a doc comment (e.g. ≈ 0.003)."""
-    return f'\u2248 {step:.6g}'
-
-
-# ---------------------------------------------------------------------------
-# Per-message code generation
-# ---------------------------------------------------------------------------
-
-def _gen_message(msg_proto, indent: str = '    ') -> list[str] | None:
-    """
-    Generate a C# partial class for a proto message.
-
-    For each uint32 field with a [(quantized)] annotation, emits a cached float
-    property {FieldName}Quantized backed by the raw uint32 field.
-
-    Returns a list of lines (without trailing newline) or None if the message
-    has no quantized uint32 fields.
-    """
-    props: list[tuple[str, str, str, int, float]] = []  # (prop_name, mn, mx, bits, step)
-
-    for field in msg_proto.field:
-        # Repeated/map fields are not supported
-        if field.label == _FT.LABEL_REPEATED:
-            continue
-
-        # Only uint32 fields are candidates for quantized accessors
-        if field.type != _FT.TYPE_UINT32:
-            continue
-
-        quantized, _ = get_field_options(field.options)
-        if quantized is None:
-            continue
-
-        step = (quantized.max - quantized.min) / ((1 << quantized.bits) - 1)
-
-        props.append((
-            _snake_to_pascal(field.name),
-            _format_float(quantized.min),
-            _format_float(quantized.max),
-            quantized.bits,
-            step,
-        ))
-
-    if not props:
-        return None
-
-    i = indent
-    backings: list[str] = []
-    lines: list[str] = []
-    lines.append(f'public partial class {msg_proto.name}')
-    lines.append('{')
-
-    for prop_name, mn, mx, bits, step in props:
-        backing = '_' + prop_name[0].lower() + prop_name[1:]
-        backings.append(backing)
-        lines.append(f'{i}private float? {backing};')
-        lines.append(f'{i}/// <summary>Float accessor for <see cref="{prop_name}"/>. Range [{mn}, {mx}], {bits} bits, step {_format_step(step)}.</summary>')
-        lines.append(f'{i}public float {prop_name}Quantized')
-        lines.append(f'{i}{{')
-        lines.append(f'{i}{i}get => {backing} ??= Quantize.Decode({prop_name}, {mn}, {mx}, {bits});')
-        lines.append(f'{i}{i}set {{ {backing} = value; {prop_name} = Quantize.Encode(value, {mn}, {mx}, {bits}); }}')
-        lines.append(f'{i}}}')
-        lines.append('')
-
-    lines.append(f'{i}/// <summary>Clears all cached decoded values. Call after mutating raw uint32 fields directly.</summary>')
-    lines.append(f'{i}public void ResetDecodedCache()')
-    lines.append(f'{i}{{')
-    for backing in backings:
-        lines.append(f'{i}{i}{backing} = null;')
-    lines.append(f'{i}}}')
-
-    lines.append('}')
-    return lines
-
-
-# ---------------------------------------------------------------------------
-# Per-file code generation (public entry point)
-# ---------------------------------------------------------------------------
-
-def generate_csharp(file_proto) -> dict | None:
-    """
-    Generate a C# source file for a FileDescriptorProto.
-
-    Returns a dict with keys 'name' (output path) and 'content' (C# source),
-    or None if the file contains no quantized uint32 fields.
-    """
-    namespace = _package_to_namespace(file_proto.package)
-
-    # Output is placed flat in the output root, matching --csharp_out convention.
-    # e.g. "decentraland/kernel/comms/v3/my_message.proto"
-    #    → "MyMessage.Bitwise.cs"
-    proto_file = file_proto.name.rsplit('/', 1)[-1]
-    stem = _snake_to_pascal(proto_file.replace('.proto', ''))
-    out_name = f'{stem}.Bitwise.cs'
-
-    header = [
-        '// <auto-generated>',
-        '//   Generated by protoc-gen-bitwise. DO NOT EDIT.',
-        f'//   Source: {file_proto.name}',
-        '// </auto-generated>',
-        '',
-        'using Decentraland.Networking.Bitwise;',
-        '',
-        f'namespace {namespace}',
-        '{',
-    ]
-    footer = [
-        '',
-        f'}} // namespace {namespace}',
-    ]
-
-    body: list[str] = []
-    for msg in file_proto.message_type:
-        msg_lines = _gen_message(msg)
-        if msg_lines is None:
-            continue
-        # Indent each line by 4 spaces (inside the namespace block)
-        for line in msg_lines:
-            body.append(('    ' + line) if line else '')
-        body.append('')
-
-    if not body:
-        return None  # nothing to emit
-
-    content = '\n'.join(header + body + footer) + '\n'
-    return {'name': out_name, 'content': content}

package/protoc-gen-bitwise/options_pb2.py

@@ -1,171 +0,0 @@
-"""
-Manual parser for the custom bitwise field options defined in options.proto.
-
-Rather than relying on protobuf extension registration (which requires a properly
-compiled _pb2 module), this module parses the raw serialized FieldOptions bytes
-directly using the protobuf binary wire format.  All protobuf runtimes preserve
-unknown/unregistered extension bytes when round-tripping, so
-field.options.SerializeToString() always contains the extension data even when
-the extension is not registered in the Python runtime.
-
-Wire format reference:
-  tag  = (field_number << 3) | wire_type
-  wire_type 0 = varint, 1 = 64-bit, 2 = length-delimited, 5 = 32-bit
-"""
-
-import struct
-
-# Extension field numbers as defined in options.proto
-QUANTIZED_FIELD_NUMBER = 50001
-BIT_PACKED_FIELD_NUMBER = 50002
-
-
-# ---------------------------------------------------------------------------
-# Low-level wire-format helpers
-# ---------------------------------------------------------------------------
-
-def _read_varint(data: bytes, pos: int):
-    """Decode a protobuf varint starting at *pos*. Returns (value, new_pos)."""
-    result = 0
-    shift = 0
-    while pos < len(data):
-        byte = data[pos]
-        pos += 1
-        result |= (byte & 0x7F) << shift
-        if not (byte & 0x80):
-            break
-        shift += 7
-    return result, pos
-
-
-def _read_float32(data: bytes, pos: int):
-    """Decode a little-endian 32-bit float. Returns (value, new_pos)."""
-    value, = struct.unpack_from('<f', data, pos)
-    return value, pos + 4
-
-
-def _skip_field(data: bytes, pos: int, wire_type: int) -> int:
-    """Advance *pos* past a field with the given wire_type."""
-    if wire_type == 0:
-        _, pos = _read_varint(data, pos)
-    elif wire_type == 1:
-        pos += 8
-    elif wire_type == 2:
-        length, pos = _read_varint(data, pos)
-        pos += length
-    elif wire_type == 5:
-        pos += 4
-    # wire types 3 and 4 (start/end group) are deprecated; skip gracefully
-    return pos
-
-
-# ---------------------------------------------------------------------------
-# Option message classes
-# ---------------------------------------------------------------------------
-
-class QuantizedFloatOptions:
-    """Mirrors the QuantizedFloatOptions proto message."""
-
-    __slots__ = ('min', 'max', 'bits')
-
-    def __init__(self, min_val: float = 0.0, max_val: float = 0.0, bits: int = 0):
-        self.min = min_val
-        self.max = max_val
-        self.bits = bits
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> 'QuantizedFloatOptions':
-        obj = cls()
-        pos = 0
-        while pos < len(data):
-            tag, pos = _read_varint(data, pos)
-            field_num = tag >> 3
-            wire_type = tag & 0x7
-            if field_num == 1 and wire_type == 5:    # min  (float)
-                obj.min, pos = _read_float32(data, pos)
-            elif field_num == 2 and wire_type == 5:  # max  (float)
-                obj.max, pos = _read_float32(data, pos)
-            elif field_num == 3 and wire_type == 0:  # bits (uint32)
-                obj.bits, pos = _read_varint(data, pos)
-            else:
-                pos = _skip_field(data, pos, wire_type)
-        return obj
-
-    def __repr__(self):
-        return f'QuantizedFloatOptions(min={self.min}, max={self.max}, bits={self.bits})'
-
-
-class BitPackedOptions:
-    """Mirrors the BitPackedOptions proto message."""
-
-    __slots__ = ('bits',)
-
-    def __init__(self, bits: int = 0):
-        self.bits = bits
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> 'BitPackedOptions':
-        obj = cls()
-        pos = 0
-        while pos < len(data):
-            tag, pos = _read_varint(data, pos)
-            field_num = tag >> 3
-            wire_type = tag & 0x7
-            if field_num == 1 and wire_type == 0:    # bits (uint32)
-                obj.bits, pos = _read_varint(data, pos)
-            else:
-                pos = _skip_field(data, pos, wire_type)
-        return obj
-
-    def __repr__(self):
-        return f'BitPackedOptions(bits={self.bits})'
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-def get_field_options(field_options_proto):
-    """
-    Extract custom bitwise options from a FieldDescriptorProto.options object.
-
-    Serialises the options message to bytes and walks the wire-format stream
-    looking for extension fields 50001 (quantized) and 50002 (bit_packed).
-
-    Args:
-        field_options_proto: google.protobuf.descriptor_pb2.FieldOptions instance
-            (may be a default/empty instance when no options are set).
-
-    Returns:
-        tuple[QuantizedFloatOptions | None, BitPackedOptions | None]
-    """
-    try:
-        raw = field_options_proto.SerializeToString()
-    except Exception:
-        return None, None
-
-    if not raw:
-        return None, None
-
-    quantized = None
-    bit_packed = None
-    pos = 0
-
-    while pos < len(raw):
-        tag, pos = _read_varint(raw, pos)
-        field_num = tag >> 3
-        wire_type = tag & 0x7
-
-        if wire_type == 2:                              # length-delimited
-            length, pos = _read_varint(raw, pos)
-            value_bytes = raw[pos:pos + length]
-            pos += length
-            if field_num == QUANTIZED_FIELD_NUMBER:
-                quantized = QuantizedFloatOptions.from_bytes(value_bytes)
-            elif field_num == BIT_PACKED_FIELD_NUMBER:
-                bit_packed = BitPackedOptions.from_bytes(value_bytes)
-            # else: unknown length-delimited field — already consumed
-        else:
-            pos = _skip_field(raw, pos, wire_type)
-
-    return quantized, bit_packed

package/protoc-gen-bitwise/plugin.py

@@ -1,92 +0,0 @@
-#!/usr/bin/env python3
-"""
-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 Encode / Decode
-     methods for every message that carries [(quantized)] or [(bit_packed)]
-     field annotations.
-  3. A serialised CodeGeneratorResponse is written to stdout.
-
-Usage (from project root):
-    protoc \\
-      --proto_path=proto \\
-      --bitwise_out=generated/ \\
-      --plugin=protoc-gen-bitwise \\
-      proto/my_messages.proto
-
-Windows invocation (plugin not on PATH as executable):
-    protoc \\
-      --proto_path=proto \\
-      --bitwise_out=generated/ \\
-      --plugin=protoc-gen-bitwise=python protoc-gen-bitwise/plugin.py \\
-      proto/my_messages.proto
-
-Dependencies:
-    pip install grpcio-tools   # or: pip install protobuf
-"""
-
-import os
-import sys
-
-# Ensure sibling modules (generator_csharp, options_pb2) are importable
-# regardless of where protoc invokes this script from.
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-# On Windows, stdin/stdout are opened in text mode by default which corrupts
-# the binary protobuf payload.
-if sys.platform == 'win32':
-    import msvcrt
-    msvcrt.setmode(sys.stdin.fileno(),  os.O_BINARY)
-    msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
-
-from google.protobuf.compiler import plugin_pb2
-
-from generator_csharp import generate_csharp
-
-
-def main() -> None:
-    request_bytes = sys.stdin.buffer.read()
-
-    request = plugin_pb2.CodeGeneratorRequest()
-    request.ParseFromString(request_bytes)
-
-    response = plugin_pb2.CodeGeneratorResponse()
-    # Advertise proto3-optional support so protoc does not reject the plugin.
-    response.supported_features = (
-        plugin_pb2.CodeGeneratorResponse.FEATURE_PROTO3_OPTIONAL
-    )
-
-    # Build a lookup map for all file descriptors (needed for imports, though
-    # the current generator only uses the directly requested files).
-    file_by_name = {f.name: f for f in request.proto_file}
-
-    for file_name in request.file_to_generate:
-        # Skip the options definition file itself — it has no messages to generate.
-        if file_name == 'decentraland/common/options.proto':
-            continue
-
-        file_proto = file_by_name.get(file_name)
-        if file_proto is None:
-            continue
-
-        try:
-            generated = generate_csharp(file_proto)
-        except Exception as exc:  # noqa: BLE001
-            error = response.file.add()
-            error.name = ''  # empty name signals an error to protoc
-            # Append error text; protoc will print it and fail.
-            response.error = f'protoc-gen-bitwise: error processing {file_name}: {exc}'
-            continue
-
-        if generated is not None:
-            out = response.file.add()
-            out.name    = generated['name']
-            out.content = generated['content']
-
-    sys.stdout.buffer.write(response.SerializeToString())
-
-
-if __name__ == '__main__':
-    main()