feat: initial extraction from mrmeeseeks/protobuf

Pure Pony protobuf runtime — wire codec (Varint, ZigZag, Tag, WireType),
framing + scalar codecs (WireReader, WireWriter, Scalar, LE), UTF-8
validator, typed WireError union.

Sourced from straw-hat-team/trogonai.com/mrmeeseeks/protobuf where the
runtime was incubated alongside Phase 3+4 of an in-Pony codegen
exploration. The codegen path was retired in favor of a Go protoc plugin
(TrogonStack/protoc-gen/cmd/protoc-gen-pony, in flight as PR #47); this
repo extracts the runtime so generated code can depend on it directly.

54 tests including property-based roundtrips for every protobuf scalar
type and fuzz tests confirming arbitrary bytes never panic the readers.

Author: enilsen16

.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install ponyc + corral via ponyup
+        run: |
+          sh -c "$(curl --proto '=https' --tlsv1.2 -fsSL https://raw.githubusercontent.com/ponylang/ponyup/latest-release/ponyup-init.sh)"
+          ~/.local/share/ponyup/bin/ponyup default x86_64-unknown-linux-gnu
+          ~/.local/share/ponyup/bin/ponyup update ponyc release
+          ~/.local/share/ponyup/bin/ponyup update corral release
+          echo "$HOME/.local/share/ponyup/bin" >> "$GITHUB_PATH"
+      - name: Build + test
+        run: |
+          mkdir -p build
+          corral run -- ponyc --path . -o build test/
+          ./build/test

.gitignore

@@ -0,0 +1,6 @@
+_corral/
+_repos/
+build/
+lock.json
+*.o
+*.dwarf

CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## Unreleased
+
+### Features
+
+- Initial extraction from `straw-hat-team/trogonai.com/mrmeeseeks/protobuf`.
+  Wire codec (`Varint`, `ZigZag`, `Tag`, `WireType`), framing + scalar
+  codecs (`WireReader`, `WireWriter`, `Scalar`, `LE`), UTF-8 validator,
+  typed `WireError` union. 54 tests including property-based roundtrips
+  for every protobuf scalar and fuzz tests on the readers.

LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, TrogonStack
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,81 @@
+# protobuf-pony
+
+Pure Pony protobuf runtime — wire codec, framing, scalar codecs, UTF-8
+validation. The runtime that generated Pony code (emitted by
+[`protoc-gen-pony`](https://github.com/TrogonStack/protoc-gen)) calls into.
+
+## What's here
+
+- **`Varint`** — varint encode/decode + zigzag encode/decode (i32/i64).
+- **`Tag`** + **`TagCodec`** — protobuf field tag (field number + wire type).
+- **`WireType`** — typed union (`WireVarint | WireFixed64 | WireLenDelim |
+  WireFixed32`); proto2 group wire types are deliberately omitted.
+- **`WireReader`** — cursor-style reader over `Array[U8] val`. Reads
+  varints, tags, fixed-width fields, length-delimited bytes, UTF-8-validated
+  strings; supports per-wire-type skip-unknown for forward-compat.
+- **`WireWriter`** — accumulating writer, returns an `Array[U8] iso^` on
+  `done()`. Includes a `write_string_field(field_num, s)` helper that
+  internalizes proto3's "skip empty strings" rule.
+- **`Scalar`** — paired encode/decode for all 12 protobuf scalar types
+  (`bool`, `int32/64`, `uint32/64`, `sint32/64`, `fixed32/64`,
+  `sfixed32/64`, `float`, `double`). Uses `F32/F64.from_bits/.bits` LLVM
+  intrinsics for lossless float round-trip.
+- **`LE`** — little-endian byte conversion helpers, shift-based (no
+  `Platform.bigendian()` branch needed since bit shifts produce LE bytes
+  on any host).
+- **`WireError`** — typed-error union (`WireTruncated | WireOverflow |
+  WireBadTag | WireInvalidUtf8`).
+
+## Install
+
+```json
+{
+  "deps": [
+    {
+      "locator": "github.com/TrogonStack/protobuf-pony",
+      "version": "0.1.0"
+    }
+  ]
+}
+```
+
+Then in your Pony source:
+
+```pony
+use "protobuf"
+```
+
+## Usage
+
+The typical caller is generated code from `protoc-gen-pony`. Sketch:
+
+```pony
+let writer = WireWriter
+writer.write_tag(Tag(1, WireVarint))
+Scalar.write_int32(writer, 42)
+let bytes: Array[U8] val = recover val writer.done() end
+
+let reader = WireReader(bytes)
+match reader.read_tag()
+| let t: Tag => /* dispatch on t.field_number, t.wire_type */
+| let e: WireError => /* handle */
+end
+```
+
+Hand-writing decoders is supported but the expected workflow is to define
+your schemas in `.proto`, run `protoc-gen-pony`, and let the generated
+`<Msg>Codec` primitives call into this runtime.
+
+## Build + test
+
+Requires [Task](https://taskfile.dev), [corral](https://github.com/ponylang/corral),
+and `ponyc`.
+
+```bash
+corral fetch
+task test
+```
+
+## License
+
+BSD-2-Clause.

Taskfile.yml

@@ -0,0 +1,18 @@
+version: "3"
+
+tasks:
+  default:
+    desc: Build + test
+    deps: [test]
+
+  test:
+    desc: Build and run unit + property tests
+    cmds:
+      - mkdir -p build
+      - corral run -- ponyc --path . -o build test/
+      - ./build/test
+
+  clean:
+    desc: Remove build artifacts
+    cmds:
+      - rm -rf build _corral

corral.json

@@ -0,0 +1,5 @@
+{
+  "locator": "github.com/TrogonStack/protobuf-pony",
+  "version": "0.1.0",
+  "deps": []
+}

protobuf/endian.pony

@@ -0,0 +1,60 @@
+// Bit shifts produce little-endian bytes regardless of host memory layout,
+// so no `Platform.bigendian()` branch is needed.
+
+primitive LE
+  fun push_u32_le(out: Array[U8] iso, v: U32): Array[U8] iso^ =>
+    out.push((v and 0xFF).u8())
+    out.push(((v >> 8) and 0xFF).u8())
+    out.push(((v >> 16) and 0xFF).u8())
+    out.push(((v >> 24) and 0xFF).u8())
+    consume out
+
+  fun push_u64_le(out: Array[U8] iso, v: U64): Array[U8] iso^ =>
+    out.push((v and 0xFF).u8())
+    out.push(((v >> 8) and 0xFF).u8())
+    out.push(((v >> 16) and 0xFF).u8())
+    out.push(((v >> 24) and 0xFF).u8())
+    out.push(((v >> 32) and 0xFF).u8())
+    out.push(((v >> 40) and 0xFF).u8())
+    out.push(((v >> 48) and 0xFF).u8())
+    out.push(((v >> 56) and 0xFF).u8())
+    consume out
+
+  fun u32_to_le_bytes(v: U32): Array[U8] iso^ =>
+    push_u32_le(recover iso Array[U8](4) end, v)
+
+  fun u32_from_le_bytes(buf: Array[U8] box, offset: USize):
+    (U32 | WireError)
+  =>
+    if buf.size() < (offset + 4) then return WireTruncated end
+    try
+      let b0 = buf(offset)?.u32()
+      let b1 = buf(offset + 1)?.u32()
+      let b2 = buf(offset + 2)?.u32()
+      let b3 = buf(offset + 3)?.u32()
+      b0 or (b1 << 8) or (b2 << 16) or (b3 << 24)
+    else
+      WireTruncated
+    end
+
+  fun u64_to_le_bytes(v: U64): Array[U8] iso^ =>
+    push_u64_le(recover iso Array[U8](8) end, v)
+
+  fun u64_from_le_bytes(buf: Array[U8] box, offset: USize):
+    (U64 | WireError)
+  =>
+    if buf.size() < (offset + 8) then return WireTruncated end
+    try
+      let b0 = buf(offset)?.u64()
+      let b1 = buf(offset + 1)?.u64()
+      let b2 = buf(offset + 2)?.u64()
+      let b3 = buf(offset + 3)?.u64()
+      let b4 = buf(offset + 4)?.u64()
+      let b5 = buf(offset + 5)?.u64()
+      let b6 = buf(offset + 6)?.u64()
+      let b7 = buf(offset + 7)?.u64()
+      b0 or (b1 << 8) or (b2 << 16) or (b3 << 24) or
+        (b4 << 32) or (b5 << 40) or (b6 << 48) or (b7 << 56)
+    else
+      WireTruncated
+    end

protobuf/errors.pony

@@ -0,0 +1,22 @@
+primitive WireTruncated
+  fun label(): String val => "truncated"
+  fun message(): String val =>
+    "buffer ended before varint was complete"
+
+primitive WireOverflow
+  fun label(): String val => "overflow"
+  fun message(): String val =>
+    "varint exceeds 10 bytes (max for U64)"
+
+primitive WireBadTag
+  fun label(): String val => "bad_tag"
+  fun message(): String val =>
+    "tag has zero field number or unknown wire type"
+
+primitive WireInvalidUtf8
+  fun label(): String val => "invalid_utf8"
+  fun message(): String val =>
+    "string field bytes are not valid UTF-8"
+
+type WireError is
+  (WireTruncated | WireOverflow | WireBadTag | WireInvalidUtf8)

protobuf/protobuf.pony

@@ -0,0 +1,8 @@
+"""
+Protocol Buffers runtime library for Pony — wire codec, framing, scalar
+codecs, and a UTF-8 validator. Generated message code emitted by
+`protoc-gen-pony` (TrogonStack/protoc-gen) calls into the types here.
+
+Currently incubating inside mrmeeseeks under the package name `protobuf`;
+extracts to its own repo once a downstream consumer needs it.
+"""