Add Protobuf with Testing + Codegen (#7)

Reviewed-on: #7
Reviewed-by: Ivan Malison <ivanmalison@gmail.com>
Co-authored-by: Mike Kalange <countablecloud@gmail.com>
Co-committed-by: Mike Kalange <countablecloud@gmail.com>

.gitea/workflows/tests.yaml

@@ -13,5 +13,5 @@ jobs:
       - uses: actions/checkout@v3
         with:
           submodules: recursive
-      - name: graphql-codegen causes no changes
+      - name: codegen causes no changes
         run: ./bin/assert-no-changes-wrapper.sh

README.md

@@ -0,0 +1 @@
+# rbgql

bin/assert-no-changes.sh

@@ -4,6 +4,12 @@ git ls-files | xargs md5sum > before.txt
 yarn install
 yarn graphql-codegen
 prettier ./src --write
+for proto in $(find ./rbproto -iname '*.proto'); do
+		name=$(basename "$proto" .proto)
+		protoc -I=./rbproto --python_out=./rbproto/python --pyi_out=./rbproto/python ./rbproto/shot.proto
+    yarn pbjs ./rbproto/shot.proto --ts ./rbproto/ts/shot.ts
+done
+prettier ./rbproto --write
 
 git ls-files | xargs md5sum > after.txt
 

flake.nix

@@ -21,7 +21,7 @@
     in
       with pkgs; {
         devShell = mkShell {
-          buildInputs = [nodejs yarn watchman alejandra nodePackages.prettier just];
+          buildInputs = [nodejs yarn watchman alejandra nodePackages.prettier just protobuf];
         };
       });
 }

justfile

@@ -1,4 +1,5 @@
 NIX := "LD_LIBRARY_PATH='' nix"
+PROTOBUF_DIR := "$PWD/rbproto"
 
 prettier-gql:
 	#!/usr/bin/env bash
@@ -12,3 +13,27 @@ gql-codegen:
 
 
 gql: gql-codegen prettier-gql
+
+protobuf-compile-a-python name:
+	protoc -I={{ PROTOBUF_DIR }} --python_out={{ PROTOBUF_DIR }}/python --pyi_out={{ PROTOBUF_DIR }}/python {{ PROTOBUF_DIR }}/shot.proto
+
+protobuf-compile-a-js name:
+	#!/usr/bin/env bash
+	set -euxo pipefail
+	{{NIX}} develop --impure --command bash -c 'yarn pbjs {{ PROTOBUF_DIR }}/shot.proto --ts {{ PROTOBUF_DIR }}/ts/shot.ts && yarn prettier ./rbproto --write'
+
+protobuf-compile-all-js:
+	#!/usr/bin/env bash
+	for proto in $(find {{ PROTOBUF_DIR }} -iname '*.proto'); do
+		name=$(basename "$proto" .proto)
+		just protobuf-compile-a-js $name
+	done
+
+protobuf-compile-all-python:
+	#!/usr/bin/env bash
+	for proto in $(find {{ PROTOBUF_DIR }} -iname '*.proto'); do
+		name=$(basename "$proto" .proto)
+		just protobuf-compile-a-python $name
+	done
+
+protobuf-compile-everything: protobuf-compile-all-js protobuf-compile-all-python

package.json

@@ -18,6 +18,7 @@
     "@graphql-codegen/typescript-operations": "^4.0.1",
     "@graphql-codegen/typescript-react-apollo": "^4.2.0",
     "graphql": "^16.8.1",
+    "pbjs": "^0.0.14",
     "prettier": "^3.2.5",
     "prettier-plugin-organize-imports": "^3.2.4"
   },

pyproject.toml

@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "rbgql"
+version = "0.1.0"
+description = ""
+authors = ["Mike Kalange <countablecloud@gmail.com>"]
+readme = "README.md"
+packages = [{include = "rbproto"}]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.12"
+protobuf = "^4.25.3"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

rbproto/__init__.py

@@ -0,0 +1 @@
+from .python.shot_pb2 import *  # noqa: F401

rbproto/python/shot_pb2.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: shot.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nshot.proto\x12\x0fserialized_shot\",\n\x05Point\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\x12\r\n\x05\x63ount\x18\x03 \x01(\x05\"i\n\x04Path\x12\x13\n\x0bstart_frame\x18\x01 \x01(\x05\x12\x11\n\tend_frame\x18\x02 \x01(\x05\x12\x11\n\tis_static\x18\x03 \x01(\x08\x12&\n\x06points\x18\x04 \x03(\x0b\x32\x16.serialized_shot.Point\"J\n\tBallPaths\x12\x17\n\x0f\x62\x61ll_identifier\x18\x01 \x01(\x05\x12$\n\x05paths\x18\x02 \x03(\x0b\x32\x15.serialized_shot.Path\"^\n\x04Shot\x12\x13\n\x0bstart_frame\x18\x01 \x01(\x05\x12\x11\n\tend_frame\x18\x02 \x01(\x05\x12.\n\nball_paths\x18\x03 \x03(\x0b\x32\x1a.serialized_shot.BallPathsb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'shot_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_POINT']._serialized_start=31
+  _globals['_POINT']._serialized_end=75
+  _globals['_PATH']._serialized_start=77
+  _globals['_PATH']._serialized_end=182
+  _globals['_BALLPATHS']._serialized_start=184
+  _globals['_BALLPATHS']._serialized_end=258
+  _globals['_SHOT']._serialized_start=260
+  _globals['_SHOT']._serialized_end=354
+# @@protoc_insertion_point(module_scope)

rbproto/python/shot_pb2.pyi

@@ -0,0 +1,46 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Point(_message.Message):
+    __slots__ = ["x", "y", "count"]
+    X_FIELD_NUMBER: _ClassVar[int]
+    Y_FIELD_NUMBER: _ClassVar[int]
+    COUNT_FIELD_NUMBER: _ClassVar[int]
+    x: float
+    y: float
+    count: int
+    def __init__(self, x: _Optional[float] = ..., y: _Optional[float] = ..., count: _Optional[int] = ...) -> None: ...
+
+class Path(_message.Message):
+    __slots__ = ["start_frame", "end_frame", "is_static", "points"]
+    START_FRAME_FIELD_NUMBER: _ClassVar[int]
+    END_FRAME_FIELD_NUMBER: _ClassVar[int]
+    IS_STATIC_FIELD_NUMBER: _ClassVar[int]
+    POINTS_FIELD_NUMBER: _ClassVar[int]
+    start_frame: int
+    end_frame: int
+    is_static: bool
+    points: _containers.RepeatedCompositeFieldContainer[Point]
+    def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., is_static: bool = ..., points: _Optional[_Iterable[_Union[Point, _Mapping]]] = ...) -> None: ...
+
+class BallPaths(_message.Message):
+    __slots__ = ["ball_identifier", "paths"]
+    BALL_IDENTIFIER_FIELD_NUMBER: _ClassVar[int]
+    PATHS_FIELD_NUMBER: _ClassVar[int]
+    ball_identifier: int
+    paths: _containers.RepeatedCompositeFieldContainer[Path]
+    def __init__(self, ball_identifier: _Optional[int] = ..., paths: _Optional[_Iterable[_Union[Path, _Mapping]]] = ...) -> None: ...
+
+class Shot(_message.Message):
+    __slots__ = ["start_frame", "end_frame", "ball_paths"]
+    START_FRAME_FIELD_NUMBER: _ClassVar[int]
+    END_FRAME_FIELD_NUMBER: _ClassVar[int]
+    BALL_PATHS_FIELD_NUMBER: _ClassVar[int]
+    start_frame: int
+    end_frame: int
+    ball_paths: _containers.RepeatedCompositeFieldContainer[BallPaths]
+    def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., ball_paths: _Optional[_Iterable[_Union[BallPaths, _Mapping]]] = ...) -> None: ...

rbproto/shot.proto

@@ -0,0 +1,27 @@
+syntax = "proto3";
+
+package serialized_shot;
+
+message Point {
+  float x = 1;
+  float y = 2;
+  int32 count = 3;
+}
+
+message Path {
+  int32 start_frame = 1;
+  int32 end_frame = 2;
+  bool is_static = 3;
+  repeated Point points = 4;
+}
+
+message BallPaths {
+  int32 ball_identifier = 1;
+  repeated Path paths = 2;
+}
+
+message Shot {
+  int32 start_frame = 1;
+  int32 end_frame = 2;
+  repeated BallPaths ball_paths = 3;
+}

rbproto/ts/shot.ts

@@ -0,0 +1,879 @@
+export interface Point {
+  x?: number;
+  y?: number;
+  count?: number;
+}
+
+export function encodePoint(message: Point): Uint8Array {
+  let bb = popByteBuffer();
+  _encodePoint(message, bb);
+  return toUint8Array(bb);
+}
+
+function _encodePoint(message: Point, bb: ByteBuffer): void {
+  // optional float x = 1;
+  let $x = message.x;
+  if ($x !== undefined) {
+    writeVarint32(bb, 13);
+    writeFloat(bb, $x);
+  }
+
+  // optional float y = 2;
+  let $y = message.y;
+  if ($y !== undefined) {
+    writeVarint32(bb, 21);
+    writeFloat(bb, $y);
+  }
+
+  // optional int32 count = 3;
+  let $count = message.count;
+  if ($count !== undefined) {
+    writeVarint32(bb, 24);
+    writeVarint64(bb, intToLong($count));
+  }
+}
+
+export function decodePoint(binary: Uint8Array): Point {
+  return _decodePoint(wrapByteBuffer(binary));
+}
+
+function _decodePoint(bb: ByteBuffer): Point {
+  let message: Point = {} as any;
+
+  end_of_message: while (!isAtEnd(bb)) {
+    let tag = readVarint32(bb);
+
+    switch (tag >>> 3) {
+      case 0:
+        break end_of_message;
+
+      // optional float x = 1;
+      case 1: {
+        message.x = readFloat(bb);
+        break;
+      }
+
+      // optional float y = 2;
+      case 2: {
+        message.y = readFloat(bb);
+        break;
+      }
+
+      // optional int32 count = 3;
+      case 3: {
+        message.count = readVarint32(bb);
+        break;
+      }
+
+      default:
+        skipUnknownField(bb, tag & 7);
+    }
+  }
+
+  return message;
+}
+
+export interface Path {
+  start_frame?: number;
+  end_frame?: number;
+  is_static?: boolean;
+  points?: Point[];
+}
+
+export function encodePath(message: Path): Uint8Array {
+  let bb = popByteBuffer();
+  _encodePath(message, bb);
+  return toUint8Array(bb);
+}
+
+function _encodePath(message: Path, bb: ByteBuffer): void {
+  // optional int32 start_frame = 1;
+  let $start_frame = message.start_frame;
+  if ($start_frame !== undefined) {
+    writeVarint32(bb, 8);
+    writeVarint64(bb, intToLong($start_frame));
+  }
+
+  // optional int32 end_frame = 2;
+  let $end_frame = message.end_frame;
+  if ($end_frame !== undefined) {
+    writeVarint32(bb, 16);
+    writeVarint64(bb, intToLong($end_frame));
+  }
+
+  // optional bool is_static = 3;
+  let $is_static = message.is_static;
+  if ($is_static !== undefined) {
+    writeVarint32(bb, 24);
+    writeByte(bb, $is_static ? 1 : 0);
+  }
+
+  // repeated Point points = 4;
+  let array$points = message.points;
+  if (array$points !== undefined) {
+    for (let value of array$points) {
+      writeVarint32(bb, 34);
+      let nested = popByteBuffer();
+      _encodePoint(value, nested);
+      writeVarint32(bb, nested.limit);
+      writeByteBuffer(bb, nested);
+      pushByteBuffer(nested);
+    }
+  }
+}
+
+export function decodePath(binary: Uint8Array): Path {
+  return _decodePath(wrapByteBuffer(binary));
+}
+
+function _decodePath(bb: ByteBuffer): Path {
+  let message: Path = {} as any;
+
+  end_of_message: while (!isAtEnd(bb)) {
+    let tag = readVarint32(bb);
+
+    switch (tag >>> 3) {
+      case 0:
+        break end_of_message;
+
+      // optional int32 start_frame = 1;
+      case 1: {
+        message.start_frame = readVarint32(bb);
+        break;
+      }
+
+      // optional int32 end_frame = 2;
+      case 2: {
+        message.end_frame = readVarint32(bb);
+        break;
+      }
+
+      // optional bool is_static = 3;
+      case 3: {
+        message.is_static = !!readByte(bb);
+        break;
+      }
+
+      // repeated Point points = 4;
+      case 4: {
+        let limit = pushTemporaryLength(bb);
+        let values = message.points || (message.points = []);
+        values.push(_decodePoint(bb));
+        bb.limit = limit;
+        break;
+      }
+
+      default:
+        skipUnknownField(bb, tag & 7);
+    }
+  }
+
+  return message;
+}
+
+export interface BallPaths {
+  ball_identifier?: number;
+  paths?: Path[];
+}
+
+export function encodeBallPaths(message: BallPaths): Uint8Array {
+  let bb = popByteBuffer();
+  _encodeBallPaths(message, bb);
+  return toUint8Array(bb);
+}
+
+function _encodeBallPaths(message: BallPaths, bb: ByteBuffer): void {
+  // optional int32 ball_identifier = 1;
+  let $ball_identifier = message.ball_identifier;
+  if ($ball_identifier !== undefined) {
+    writeVarint32(bb, 8);
+    writeVarint64(bb, intToLong($ball_identifier));
+  }
+
+  // repeated Path paths = 2;
+  let array$paths = message.paths;
+  if (array$paths !== undefined) {
+    for (let value of array$paths) {
+      writeVarint32(bb, 18);
+      let nested = popByteBuffer();
+      _encodePath(value, nested);
+      writeVarint32(bb, nested.limit);
+      writeByteBuffer(bb, nested);
+      pushByteBuffer(nested);
+    }
+  }
+}
+
+export function decodeBallPaths(binary: Uint8Array): BallPaths {
+  return _decodeBallPaths(wrapByteBuffer(binary));
+}
+
+function _decodeBallPaths(bb: ByteBuffer): BallPaths {
+  let message: BallPaths = {} as any;
+
+  end_of_message: while (!isAtEnd(bb)) {
+    let tag = readVarint32(bb);
+
+    switch (tag >>> 3) {
+      case 0:
+        break end_of_message;
+
+      // optional int32 ball_identifier = 1;
+      case 1: {
+        message.ball_identifier = readVarint32(bb);
+        break;
+      }
+
+      // repeated Path paths = 2;
+      case 2: {
+        let limit = pushTemporaryLength(bb);
+        let values = message.paths || (message.paths = []);
+        values.push(_decodePath(bb));
+        bb.limit = limit;
+        break;
+      }
+
+      default:
+        skipUnknownField(bb, tag & 7);
+    }
+  }
+
+  return message;
+}
+
+export interface Shot {
+  start_frame?: number;
+  end_frame?: number;
+  ball_paths?: BallPaths[];
+}
+
+export function encodeShot(message: Shot): Uint8Array {
+  let bb = popByteBuffer();
+  _encodeShot(message, bb);
+  return toUint8Array(bb);
+}
+
+function _encodeShot(message: Shot, bb: ByteBuffer): void {
+  // optional int32 start_frame = 1;
+  let $start_frame = message.start_frame;
+  if ($start_frame !== undefined) {
+    writeVarint32(bb, 8);
+    writeVarint64(bb, intToLong($start_frame));
+  }
+
+  // optional int32 end_frame = 2;
+  let $end_frame = message.end_frame;
+  if ($end_frame !== undefined) {
+    writeVarint32(bb, 16);
+    writeVarint64(bb, intToLong($end_frame));
+  }
+
+  // repeated BallPaths ball_paths = 3;
+  let array$ball_paths = message.ball_paths;
+  if (array$ball_paths !== undefined) {
+    for (let value of array$ball_paths) {
+      writeVarint32(bb, 26);
+      let nested = popByteBuffer();
+      _encodeBallPaths(value, nested);
+      writeVarint32(bb, nested.limit);
+      writeByteBuffer(bb, nested);
+      pushByteBuffer(nested);
+    }
+  }
+}
+
+export function decodeShot(binary: Uint8Array): Shot {
+  return _decodeShot(wrapByteBuffer(binary));
+}
+
+function _decodeShot(bb: ByteBuffer): Shot {
+  let message: Shot = {} as any;
+
+  end_of_message: while (!isAtEnd(bb)) {
+    let tag = readVarint32(bb);
+
+    switch (tag >>> 3) {
+      case 0:
+        break end_of_message;
+
+      // optional int32 start_frame = 1;
+      case 1: {
+        message.start_frame = readVarint32(bb);
+        break;
+      }
+
+      // optional int32 end_frame = 2;
+      case 2: {
+        message.end_frame = readVarint32(bb);
+        break;
+      }
+
+      // repeated BallPaths ball_paths = 3;
+      case 3: {
+        let limit = pushTemporaryLength(bb);
+        let values = message.ball_paths || (message.ball_paths = []);
+        values.push(_decodeBallPaths(bb));
+        bb.limit = limit;
+        break;
+      }
+
+      default:
+        skipUnknownField(bb, tag & 7);
+    }
+  }
+
+  return message;
+}
+
+export interface Long {
+  low: number;
+  high: number;
+  unsigned: boolean;
+}
+
+interface ByteBuffer {
+  bytes: Uint8Array;
+  offset: number;
+  limit: number;
+}
+
+function pushTemporaryLength(bb: ByteBuffer): number {
+  let length = readVarint32(bb);
+  let limit = bb.limit;
+  bb.limit = bb.offset + length;
+  return limit;
+}
+
+function skipUnknownField(bb: ByteBuffer, type: number): void {
+  switch (type) {
+    case 0:
+      while (readByte(bb) & 0x80) {}
+      break;
+    case 2:
+      skip(bb, readVarint32(bb));
+      break;
+    case 5:
+      skip(bb, 4);
+      break;
+    case 1:
+      skip(bb, 8);
+      break;
+    default:
+      throw new Error("Unimplemented type: " + type);
+  }
+}
+
+function stringToLong(value: string): Long {
+  return {
+    low: value.charCodeAt(0) | (value.charCodeAt(1) << 16),
+    high: value.charCodeAt(2) | (value.charCodeAt(3) << 16),
+    unsigned: false,
+  };
+}
+
+function longToString(value: Long): string {
+  let low = value.low;
+  let high = value.high;
+  return String.fromCharCode(
+    low & 0xffff,
+    low >>> 16,
+    high & 0xffff,
+    high >>> 16,
+  );
+}
+
+// The code below was modified from https://github.com/protobufjs/bytebuffer.js
+// which is under the Apache License 2.0.
+
+let f32 = new Float32Array(1);
+let f32_u8 = new Uint8Array(f32.buffer);
+
+let f64 = new Float64Array(1);
+let f64_u8 = new Uint8Array(f64.buffer);
+
+function intToLong(value: number): Long {
+  value |= 0;
+  return {
+    low: value,
+    high: value >> 31,
+    unsigned: value >= 0,
+  };
+}
+
+let bbStack: ByteBuffer[] = [];
+
+function popByteBuffer(): ByteBuffer {
+  const bb = bbStack.pop();
+  if (!bb) return { bytes: new Uint8Array(64), offset: 0, limit: 0 };
+  bb.offset = bb.limit = 0;
+  return bb;
+}
+
+function pushByteBuffer(bb: ByteBuffer): void {
+  bbStack.push(bb);
+}
+
+function wrapByteBuffer(bytes: Uint8Array): ByteBuffer {
+  return { bytes, offset: 0, limit: bytes.length };
+}
+
+function toUint8Array(bb: ByteBuffer): Uint8Array {
+  let bytes = bb.bytes;
+  let limit = bb.limit;
+  return bytes.length === limit ? bytes : bytes.subarray(0, limit);
+}
+
+function skip(bb: ByteBuffer, offset: number): void {
+  if (bb.offset + offset > bb.limit) {
+    throw new Error("Skip past limit");
+  }
+  bb.offset += offset;
+}
+
+function isAtEnd(bb: ByteBuffer): boolean {
+  return bb.offset >= bb.limit;
+}
+
+function grow(bb: ByteBuffer, count: number): number {
+  let bytes = bb.bytes;
+  let offset = bb.offset;
+  let limit = bb.limit;
+  let finalOffset = offset + count;
+  if (finalOffset > bytes.length) {
+    let newBytes = new Uint8Array(finalOffset * 2);
+    newBytes.set(bytes);
+    bb.bytes = newBytes;
+  }
+  bb.offset = finalOffset;
+  if (finalOffset > limit) {
+    bb.limit = finalOffset;
+  }
+  return offset;
+}
+
+function advance(bb: ByteBuffer, count: number): number {
+  let offset = bb.offset;
+  if (offset + count > bb.limit) {
+    throw new Error("Read past limit");
+  }
+  bb.offset += count;
+  return offset;
+}
+
+function readBytes(bb: ByteBuffer, count: number): Uint8Array {
+  let offset = advance(bb, count);
+  return bb.bytes.subarray(offset, offset + count);
+}
+
+function writeBytes(bb: ByteBuffer, buffer: Uint8Array): void {
+  let offset = grow(bb, buffer.length);
+  bb.bytes.set(buffer, offset);
+}
+
+function readString(bb: ByteBuffer, count: number): string {
+  // Sadly a hand-coded UTF8 decoder is much faster than subarray+TextDecoder in V8
+  let offset = advance(bb, count);
+  let fromCharCode = String.fromCharCode;
+  let bytes = bb.bytes;
+  let invalid = "\uFFFD";
+  let text = "";
+
+  for (let i = 0; i < count; i++) {
+    let c1 = bytes[i + offset],
+      c2: number,
+      c3: number,
+      c4: number,
+      c: number;
+
+    // 1 byte
+    if ((c1 & 0x80) === 0) {
+      text += fromCharCode(c1);
+    }
+
+    // 2 bytes
+    else if ((c1 & 0xe0) === 0xc0) {
+      if (i + 1 >= count) text += invalid;
+      else {
+        c2 = bytes[i + offset + 1];
+        if ((c2 & 0xc0) !== 0x80) text += invalid;
+        else {
+          c = ((c1 & 0x1f) << 6) | (c2 & 0x3f);
+          if (c < 0x80) text += invalid;
+          else {
+            text += fromCharCode(c);
+            i++;
+          }
+        }
+      }
+    }
+
+    // 3 bytes
+    else if ((c1 & 0xf0) == 0xe0) {
+      if (i + 2 >= count) text += invalid;
+      else {
+        c2 = bytes[i + offset + 1];
+        c3 = bytes[i + offset + 2];
+        if (((c2 | (c3 << 8)) & 0xc0c0) !== 0x8080) text += invalid;
+        else {
+          c = ((c1 & 0x0f) << 12) | ((c2 & 0x3f) << 6) | (c3 & 0x3f);
+          if (c < 0x0800 || (c >= 0xd800 && c <= 0xdfff)) text += invalid;
+          else {
+            text += fromCharCode(c);
+            i += 2;
+          }
+        }
+      }
+    }
+
+    // 4 bytes
+    else if ((c1 & 0xf8) == 0xf0) {
+      if (i + 3 >= count) text += invalid;
+      else {
+        c2 = bytes[i + offset + 1];
+        c3 = bytes[i + offset + 2];
+        c4 = bytes[i + offset + 3];
+        if (((c2 | (c3 << 8) | (c4 << 16)) & 0xc0c0c0) !== 0x808080)
+          text += invalid;
+        else {
+          c =
+            ((c1 & 0x07) << 0x12) |
+            ((c2 & 0x3f) << 0x0c) |
+            ((c3 & 0x3f) << 0x06) |
+            (c4 & 0x3f);
+          if (c < 0x10000 || c > 0x10ffff) text += invalid;
+          else {
+            c -= 0x10000;
+            text += fromCharCode((c >> 10) + 0xd800, (c & 0x3ff) + 0xdc00);
+            i += 3;
+          }
+        }
+      }
+    } else text += invalid;
+  }
+
+  return text;
+}
+
+function writeString(bb: ByteBuffer, text: string): void {
+  // Sadly a hand-coded UTF8 encoder is much faster than TextEncoder+set in V8
+  let n = text.length;
+  let byteCount = 0;
+
+  // Write the byte count first
+  for (let i = 0; i < n; i++) {
+    let c = text.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) {
+      c = (c << 10) + text.charCodeAt(++i) - 0x35fdc00;
+    }
+    byteCount += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
+  }
+  writeVarint32(bb, byteCount);
+
+  let offset = grow(bb, byteCount);
+  let bytes = bb.bytes;
+
+  // Then write the bytes
+  for (let i = 0; i < n; i++) {
+    let c = text.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) {
+      c = (c << 10) + text.charCodeAt(++i) - 0x35fdc00;
+    }
+    if (c < 0x80) {
+      bytes[offset++] = c;
+    } else {
+      if (c < 0x800) {
+        bytes[offset++] = ((c >> 6) & 0x1f) | 0xc0;
+      } else {
+        if (c < 0x10000) {
+          bytes[offset++] = ((c >> 12) & 0x0f) | 0xe0;
+        } else {
+          bytes[offset++] = ((c >> 18) & 0x07) | 0xf0;
+          bytes[offset++] = ((c >> 12) & 0x3f) | 0x80;
+        }
+        bytes[offset++] = ((c >> 6) & 0x3f) | 0x80;
+      }
+      bytes[offset++] = (c & 0x3f) | 0x80;
+    }
+  }
+}
+
+function writeByteBuffer(bb: ByteBuffer, buffer: ByteBuffer): void {
+  let offset = grow(bb, buffer.limit);
+  let from = bb.bytes;
+  let to = buffer.bytes;
+
+  // This for loop is much faster than subarray+set on V8
+  for (let i = 0, n = buffer.limit; i < n; i++) {
+    from[i + offset] = to[i];
+  }
+}
+
+function readByte(bb: ByteBuffer): number {
+  return bb.bytes[advance(bb, 1)];
+}
+
+function writeByte(bb: ByteBuffer, value: number): void {
+  let offset = grow(bb, 1);
+  bb.bytes[offset] = value;
+}
+
+function readFloat(bb: ByteBuffer): number {
+  let offset = advance(bb, 4);
+  let bytes = bb.bytes;
+
+  // Manual copying is much faster than subarray+set in V8
+  f32_u8[0] = bytes[offset++];
+  f32_u8[1] = bytes[offset++];
+  f32_u8[2] = bytes[offset++];
+  f32_u8[3] = bytes[offset++];
+  return f32[0];
+}
+
+function writeFloat(bb: ByteBuffer, value: number): void {
+  let offset = grow(bb, 4);
+  let bytes = bb.bytes;
+  f32[0] = value;
+
+  // Manual copying is much faster than subarray+set in V8
+  bytes[offset++] = f32_u8[0];
+  bytes[offset++] = f32_u8[1];
+  bytes[offset++] = f32_u8[2];
+  bytes[offset++] = f32_u8[3];
+}
+
+function readDouble(bb: ByteBuffer): number {
+  let offset = advance(bb, 8);
+  let bytes = bb.bytes;
+
+  // Manual copying is much faster than subarray+set in V8
+  f64_u8[0] = bytes[offset++];
+  f64_u8[1] = bytes[offset++];
+  f64_u8[2] = bytes[offset++];
+  f64_u8[3] = bytes[offset++];
+  f64_u8[4] = bytes[offset++];
+  f64_u8[5] = bytes[offset++];
+  f64_u8[6] = bytes[offset++];
+  f64_u8[7] = bytes[offset++];
+  return f64[0];
+}
+
+function writeDouble(bb: ByteBuffer, value: number): void {
+  let offset = grow(bb, 8);
+  let bytes = bb.bytes;
+  f64[0] = value;
+
+  // Manual copying is much faster than subarray+set in V8
+  bytes[offset++] = f64_u8[0];
+  bytes[offset++] = f64_u8[1];
+  bytes[offset++] = f64_u8[2];
+  bytes[offset++] = f64_u8[3];
+  bytes[offset++] = f64_u8[4];
+  bytes[offset++] = f64_u8[5];
+  bytes[offset++] = f64_u8[6];
+  bytes[offset++] = f64_u8[7];
+}
+
+function readInt32(bb: ByteBuffer): number {
+  let offset = advance(bb, 4);
+  let bytes = bb.bytes;
+  return (
+    bytes[offset] |
+    (bytes[offset + 1] << 8) |
+    (bytes[offset + 2] << 16) |
+    (bytes[offset + 3] << 24)
+  );
+}
+
+function writeInt32(bb: ByteBuffer, value: number): void {
+  let offset = grow(bb, 4);
+  let bytes = bb.bytes;
+  bytes[offset] = value;
+  bytes[offset + 1] = value >> 8;
+  bytes[offset + 2] = value >> 16;
+  bytes[offset + 3] = value >> 24;
+}
+
+function readInt64(bb: ByteBuffer, unsigned: boolean): Long {
+  return {
+    low: readInt32(bb),
+    high: readInt32(bb),
+    unsigned,
+  };
+}
+
+function writeInt64(bb: ByteBuffer, value: Long): void {
+  writeInt32(bb, value.low);
+  writeInt32(bb, value.high);
+}
+
+function readVarint32(bb: ByteBuffer): number {
+  let c = 0;
+  let value = 0;
+  let b: number;
+  do {
+    b = readByte(bb);
+    if (c < 32) value |= (b & 0x7f) << c;
+    c += 7;
+  } while (b & 0x80);
+  return value;
+}
+
+function writeVarint32(bb: ByteBuffer, value: number): void {
+  value >>>= 0;
+  while (value >= 0x80) {
+    writeByte(bb, (value & 0x7f) | 0x80);
+    value >>>= 7;
+  }
+  writeByte(bb, value);
+}
+
+function readVarint64(bb: ByteBuffer, unsigned: boolean): Long {
+  let part0 = 0;
+  let part1 = 0;
+  let part2 = 0;
+  let b: number;
+
+  b = readByte(bb);
+  part0 = b & 0x7f;
+  if (b & 0x80) {
+    b = readByte(bb);
+    part0 |= (b & 0x7f) << 7;
+    if (b & 0x80) {
+      b = readByte(bb);
+      part0 |= (b & 0x7f) << 14;
+      if (b & 0x80) {
+        b = readByte(bb);
+        part0 |= (b & 0x7f) << 21;
+        if (b & 0x80) {
+          b = readByte(bb);
+          part1 = b & 0x7f;
+          if (b & 0x80) {
+            b = readByte(bb);
+            part1 |= (b & 0x7f) << 7;
+            if (b & 0x80) {
+              b = readByte(bb);
+              part1 |= (b & 0x7f) << 14;
+              if (b & 0x80) {
+                b = readByte(bb);
+                part1 |= (b & 0x7f) << 21;
+                if (b & 0x80) {
+                  b = readByte(bb);
+                  part2 = b & 0x7f;
+                  if (b & 0x80) {
+                    b = readByte(bb);
+                    part2 |= (b & 0x7f) << 7;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    low: part0 | (part1 << 28),
+    high: (part1 >>> 4) | (part2 << 24),
+    unsigned,
+  };
+}
+
+function writeVarint64(bb: ByteBuffer, value: Long): void {
+  let part0 = value.low >>> 0;
+  let part1 = ((value.low >>> 28) | (value.high << 4)) >>> 0;
+  let part2 = value.high >>> 24;
+
+  // ref: src/google/protobuf/io/coded_stream.cc
+  let size =
+    part2 === 0
+      ? part1 === 0
+        ? part0 < 1 << 14
+          ? part0 < 1 << 7
+            ? 1
+            : 2
+          : part0 < 1 << 21
+            ? 3
+            : 4
+        : part1 < 1 << 14
+          ? part1 < 1 << 7
+            ? 5
+            : 6
+          : part1 < 1 << 21
+            ? 7
+            : 8
+      : part2 < 1 << 7
+        ? 9
+        : 10;
+
+  let offset = grow(bb, size);
+  let bytes = bb.bytes;
+
+  switch (size) {
+    case 10:
+      bytes[offset + 9] = (part2 >>> 7) & 0x01;
+    case 9:
+      bytes[offset + 8] = size !== 9 ? part2 | 0x80 : part2 & 0x7f;
+    case 8:
+      bytes[offset + 7] =
+        size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7f;
+    case 7:
+      bytes[offset + 6] =
+        size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7f;
+    case 6:
+      bytes[offset + 5] =
+        size !== 6 ? (part1 >>> 7) | 0x80 : (part1 >>> 7) & 0x7f;
+    case 5:
+      bytes[offset + 4] = size !== 5 ? part1 | 0x80 : part1 & 0x7f;
+    case 4:
+      bytes[offset + 3] =
+        size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7f;
+    case 3:
+      bytes[offset + 2] =
+        size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7f;
+    case 2:
+      bytes[offset + 1] =
+        size !== 2 ? (part0 >>> 7) | 0x80 : (part0 >>> 7) & 0x7f;
+    case 1:
+      bytes[offset] = size !== 1 ? part0 | 0x80 : part0 & 0x7f;
+  }
+}
+
+function readVarint32ZigZag(bb: ByteBuffer): number {
+  let value = readVarint32(bb);
+
+  // ref: src/google/protobuf/wire_format_lite.h
+  return (value >>> 1) ^ -(value & 1);
+}
+
+function writeVarint32ZigZag(bb: ByteBuffer, value: number): void {
+  // ref: src/google/protobuf/wire_format_lite.h
+  writeVarint32(bb, (value << 1) ^ (value >> 31));
+}
+
+function readVarint64ZigZag(bb: ByteBuffer): Long {
+  let value = readVarint64(bb, /* unsigned */ false);
+  let low = value.low;
+  let high = value.high;
+  let flip = -(low & 1);
+
+  // ref: src/google/protobuf/wire_format_lite.h
+  return {
+    low: ((low >>> 1) | (high << 31)) ^ flip,
+    high: (high >>> 1) ^ flip,
+    unsigned: false,
+  };
+}
+
+function writeVarint64ZigZag(bb: ByteBuffer, value: Long): void {
+  let low = value.low;
+  let high = value.high;
+  let flip = high >> 31;
+
+  // ref: src/google/protobuf/wire_format_lite.h
+  writeVarint64(bb, {
+    low: (low << 1) ^ flip,
+    high: ((high << 1) | (low >>> 31)) ^ flip,
+    unsigned: false,
+  });
+}

src/index.tsx

@@ -329,6 +329,11 @@ export type RangeFilter = {
   lessThan?: InputMaybe<Scalars["Float"]["input"]>;
 };
 
+export type SerializedShotPathsGql = {
+  __typename?: "SerializedShotPathsGQL";
+  b64EncodedBuffer?: Maybe<Scalars["String"]["output"]>;
+};
+
 export enum ShotDirectionEnum {
   Left = "LEFT",
   Right = "RIGHT",
@@ -343,6 +348,7 @@ export type ShotGql = {
   endFrame: Scalars["Int"]["output"];
   id: Scalars["Int"]["output"];
   pocketingIntentionFeatures?: Maybe<PocketingIntentionFeaturesGql>;
+  serializedShotPaths?: Maybe<SerializedShotPathsGql>;
   startFrame: Scalars["Int"]["output"];
   updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
   user?: Maybe<UserGql>;

src/schema.gql

@@ -144,6 +144,7 @@ type ShotGQL {
   cueObjectFeatures: CueObjectFeaturesGQL
   pocketingIntentionFeatures: PocketingIntentionFeaturesGQL
   bankFeatures: BankFeaturesGQL
+  serializedShotPaths: SerializedShotPathsGQL
   user: UserGQL
 }
 
@@ -177,6 +178,10 @@ enum WallTypeEnum {
   SHORT
 }
 
+type SerializedShotPathsGQL {
+  b64EncodedBuffer: String
+}
+
 type UserGQL {
   id: Int!
   firebaseUid: String!

yarn.lock

@@ -1553,6 +1553,11 @@ colorette@^2.0.16:
   resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.20.tgz#9eb793e6833067f7235902fcd3b09917a000a95a"
   integrity sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==
 
+commander@4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-4.0.1.tgz#b67622721785993182e807f4883633e6401ba53c"
+  integrity sha512-IPF4ouhCP+qdlcmCedhxX4xiGBPyigb8v5NeUp+0LyhwLgxMqyp3S0vl7TAPfS/hiP7FC3caI/PB9lTmP8r1NA==
+
 common-tags@1.8.2:
   version "1.8.2"
   resolved "https://registry.yarnpkg.com/common-tags/-/common-tags-1.8.2.tgz#94ebb3c076d26032745fd54face7f688ef5ac9c6"
@@ -2538,6 +2543,14 @@ path-type@^4.0.0:
   resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
   integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
 
+pbjs@^0.0.14:
+  version "0.0.14"
+  resolved "https://registry.yarnpkg.com/pbjs/-/pbjs-0.0.14.tgz#5ab3d4a5f06a9ab78dd320c63f72877120d4c48d"
+  integrity sha512-F4aA0ojrQ37kxFPOg4yRLP/vxb76rYQwMQigmVEljYlA7hZKmjaWjP6IkRn4nA0NdIj4Xxe4iqWrrIhJy+MwWQ==
+  dependencies:
+    commander "4.0.1"
+    protocol-buffers-schema "3.1.0"
+
 picocolors@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c"
@@ -2574,6 +2587,11 @@ prop-types@^15.7.2:
     object-assign "^4.1.1"
     react-is "^16.13.1"
 
+protocol-buffers-schema@3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/protocol-buffers-schema/-/protocol-buffers-schema-3.1.0.tgz#d8a819549ead3e6bd189ebe9e50e96636bbc5cc7"
+  integrity sha512-1g9zFjLFhGN1Dc5UVO8D2loVslp6sVxk5sJqgD66CuWUITh2gOaTLRN/pIakGFfB6e0nNF6hImrYFDurEsA1UQ==
+
 punycode@^1.3.2:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"