Merge branch 'check-conformance'

Update the README with a new benchmark group and performance results.
Include new data files and update the Rust benchmark implementation.
Regenerate UPB bindings and fix a data path in the C benchmark runner.

AGENTS.md

@@ -14,6 +14,6 @@ If you are writing code, write tests first. The tests must pass for your work to
 If the users asks you to fork off and work on something, this means that you should:
 
 1. Create a temporary directory using `mktemp -d`
-2. Create a new branch to work on
+2. Create a new branch to work on `git branch xyz`
 3. Use git worktree to extract that branch to the temporary directory (i.e., `git worktree add $TMP_DIR -- $BRANCH)
 4. Work from that directory (i.e., `cd $TMP_DIR`)

README.md

@@ -148,11 +148,12 @@ Two benchmark suites share the same binary data files and the same four
 measurement groups:
 
 | Group               | What is timed                                           |
-| --------------- | ------------------------------------------------------- |
+| ------------------- | ------------------------------------------------------- |
 | `shallow_parse`     | Become ready to read any field (one scan / full decode) |
 | `deep_parse`        | Walk the full tree: Campaign → Operations → Hackers     |
 | `field_access`      | Read individual fields on an already-parsed message     |
 | `iterate`           | Count top-level and nested repeated fields              |
+| `read_update_write` | Parse, update a field, and serialize back to a buffer   |
 
 ### 1 — Generate the shared data files (do this once)
 
@@ -267,6 +268,18 @@ criterion medians; C/upb times are the custom runner's mean over ≥ 0.5 s.
 > `shallow_parse`. `count_all_crew` also parses each `Operation` sub-message;
 > roto's per-level scans remain cheaper than upb's full decode.
 
+#### `read_update_write` — parse, update a field, and serialize back to a buffer
+
+| Size   |     Bytes | roto (ns) |    upb (ns) | roto speedup |
+| ------ | --------: | --------: | ----------: | -----------: |
+| tiny   |       588 |     153.8 |     1,120.3 |     **7.3×** |
+| small  |    20,265 |   1,301.8 |    42,089.6 |    **32.3×** |
+| medium | 2,071,053 | 302,090.0 | 9,233,397.9 |    **30.5×** |
+
+> roto's `with()` method allows copying fields directly from the original binary
+> without decoding them, making the update process extremely efficient. upb must
+> fully parse the message into structs and then re-serialize the entire tree.
+
 ### Interpreting the comparison
 
 The two libraries have fundamentally different models:
@@ -283,6 +296,31 @@ after parsing is faster. For workloads that read every field the costs
 invert; for workloads that read a handful of fields from large messages roto
 wins.
 
-## Literature
+## Protobuf Spec Validation
 
-https://protobuf.dev/programming-guides/encoding/
+The goal is to validate roto's implementation against the Proto3 specification.
+
+### Supported Features
+
+- **Scalar Types**: `double`, `float`, `int32`, `int64`, `uint32`, `uint64`, `sint32`, `sint64`, `fixed32`, `fixed64`, `sfixed32`, `sfixed64`, `bool`, `string`, `bytes`.
+- **Messages**: Top-level and nested message definitions.
+- **Enums**: Enum definitions with `from_i32` conversion.
+- **Field Labels**: Singular and `repeated` fields.
+
+### Unsupported Features
+
+- **Default Values**: Missing fields return `RotoError::FieldNotFound` instead of the Proto3 default value (e.g., `0` or `""`).
+- **Field Presence**: No `has_field()` methods are generated to distinguish between a field being absent and a field being set to its default value.
+- **`oneof` Fields**: Not currently supported in code generation.
+- **`map` Fields**: Not currently supported.
+- **Packed Repeated Fields**: `roto` expects individual tags for all repeated elements; it does not support the packed encoding used for scalar numeric types in Proto3.
+- **Reserved Fields**: `reserved` statements are ignored.
+- **Services**: `service` and `rpc` definitions are ignored.
+- **Options**: Field and message options are ignored.
+
+### Tasks
+
+- [x] Analyze `roto/codegen` to determine which protobuf constructs are supported during code generation.
+- [x] Analyze `roto/runtime` to determine which wire types and protobuf types are supported during reading and writing.
+- [x] Compare findings with the Proto3 spec (https://protobuf.dev/reference/protobuf/proto3-spec/).
+- [x] Document supported and unsupported features in the README.

benches/benches/hackers_bench.rs

@@ -27,7 +27,7 @@
 //! - `iterate`        — counting repeated fields at different nesting depths
 
 use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
-use roto_benches::hackers::{Campaign, Hacker, Operation, Worm};
+use roto_benches::hackers::{Campaign, CampaignBuilder, Hacker, Operation, Worm};
 use std::hint::black_box;
 
 // =============================================================================
@@ -205,11 +205,41 @@ fn bench_iterate(c: &mut Criterion) {
     group.finish();
 }
 
+/// Parse, update a field, and serialize back to a buffer.
+fn bench_read_update_write(c: &mut Criterion) {
+    let cases = [
+        ("tiny", load("tiny")),
+        ("small", load("small")),
+        ("medium", load("medium")),
+    ];
+
+    let mut group = c.benchmark_group("read_update_write");
+    for (label, maybe_data) in &cases {
+        let Some(data) = maybe_data else { continue };
+        group.throughput(Throughput::Bytes(data.len() as u64));
+        group.bench_with_input(BenchmarkId::new("Campaign", label), data, |b, data| {
+            b.iter(|| {
+                let campaign = Campaign::new(data).unwrap();
+                let mut buf = vec![0u8; data.len() * 2];
+                let res = CampaignBuilder::builder(&mut buf)
+                    .name("updated")
+                    .unwrap()
+                    .with(&campaign)
+                    .unwrap()
+                    .finish();
+                black_box(res.unwrap().len())
+            })
+        });
+    }
+    group.finish();
+}
+
 criterion_group!(
     benches,
     bench_shallow_parse,
     bench_deep_parse,
     bench_field_access,
-    bench_iterate
+    bench_iterate,
+    bench_read_update_write
 );
 criterion_main!(benches);

upb_test/hackers.upb.h

@@ -10,58 +10,75 @@
 #define HACKERS_PROTO_UPB_H__UPB_H_
 
 #include "upb/generated_code_support.h"
-
 #include "hackers.upb_minitable.h"
 
-
 // Must be last.
 #include "upb/port/def.inc"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
+typedef struct Tool {
+  upb_Message UPB_PRIVATE(base);
+} Tool;
+
+typedef struct Connection {
+  upb_Message UPB_PRIVATE(base);
+} Connection;
+
+typedef struct Hacker {
+  upb_Message UPB_PRIVATE(base);
+} Hacker;
+
+typedef struct Worm {
+  upb_Message UPB_PRIVATE(base);
+} Worm;
+
+typedef struct Operation {
+  upb_Message UPB_PRIVATE(base);
+} Operation;
+
+typedef struct Campaign {
+  upb_Message UPB_PRIVATE(base);
+} Campaign;
 
-typedef struct Tool { upb_Message UPB_PRIVATE(base); } Tool;
-typedef struct Connection { upb_Message UPB_PRIVATE(base); } Connection;
-typedef struct Hacker { upb_Message UPB_PRIVATE(base); } Hacker;
-typedef struct Worm { upb_Message UPB_PRIVATE(base); } Worm;
-typedef struct Operation { upb_Message UPB_PRIVATE(base); } Operation;
-typedef struct Campaign { upb_Message UPB_PRIVATE(base); } Campaign;
 
 
 
 /* Tool */
-
 UPB_INLINE Tool* Tool_new(upb_Arena* arena) {
   return (Tool*)_upb_Message_New(&Tool_msg_init, arena);
 }
-UPB_INLINE Tool* Tool_parse(const char* buf, size_t size, upb_Arena* arena) {
+UPB_INLINE Tool* Tool_parse(const char* buf, size_t size,
+                                        upb_Arena* arena) {
   Tool* ret = Tool_new(arena);
   if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Tool_msg_init, NULL, 0, arena) !=
-      kUpb_DecodeStatus_Ok) {
-    return NULL;
-  }
-  return ret;
-}
-UPB_INLINE Tool* Tool_parse_ex(const char* buf, size_t size,
-                           const upb_ExtensionRegistry* extreg,
-                           int options, upb_Arena* arena) {
-  Tool* ret = Tool_new(arena);
-  if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Tool_msg_init, extreg, options,
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Tool_msg_init, NULL, 0,
                  arena) != kUpb_DecodeStatus_Ok) {
     return NULL;
   }
   return ret;
 }
-UPB_INLINE char* Tool_serialize(const Tool* msg, upb_Arena* arena, size_t* len) {
+UPB_INLINE Tool* Tool_parse_ex(
+    const char* buf, size_t size, const upb_ExtensionRegistry* extreg,
+    int options, upb_Arena* arena) {
+  Tool* ret = Tool_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Tool_msg_init, extreg,
+                 options, arena) != kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char* Tool_serialize(const Tool* msg,
+                                      upb_Arena* arena, size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Tool_msg_init, 0, arena, &ptr, len);
   return ptr;
 }
-UPB_INLINE char* Tool_serialize_ex(const Tool* msg, int options,
-                                 upb_Arena* arena, size_t* len) {
+UPB_INLINE char* Tool_serialize_ex(const Tool* msg,
+                                         int options, upb_Arena* arena,
+                                         size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Tool_msg_init, options, arena, &ptr, len);
   return ptr;
@@ -149,37 +166,39 @@ UPB_INLINE void Tool_set_exploit_count(Tool *msg, int32_t value) {
 }
 
 /* Connection */
-
 UPB_INLINE Connection* Connection_new(upb_Arena* arena) {
   return (Connection*)_upb_Message_New(&Connection_msg_init, arena);
 }
-UPB_INLINE Connection* Connection_parse(const char* buf, size_t size, upb_Arena* arena) {
+UPB_INLINE Connection* Connection_parse(const char* buf, size_t size,
+                                        upb_Arena* arena) {
   Connection* ret = Connection_new(arena);
   if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Connection_msg_init, NULL, 0, arena) !=
-      kUpb_DecodeStatus_Ok) {
-    return NULL;
-  }
-  return ret;
-}
-UPB_INLINE Connection* Connection_parse_ex(const char* buf, size_t size,
-                           const upb_ExtensionRegistry* extreg,
-                           int options, upb_Arena* arena) {
-  Connection* ret = Connection_new(arena);
-  if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Connection_msg_init, extreg, options,
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Connection_msg_init, NULL, 0,
                  arena) != kUpb_DecodeStatus_Ok) {
     return NULL;
   }
   return ret;
 }
-UPB_INLINE char* Connection_serialize(const Connection* msg, upb_Arena* arena, size_t* len) {
+UPB_INLINE Connection* Connection_parse_ex(
+    const char* buf, size_t size, const upb_ExtensionRegistry* extreg,
+    int options, upb_Arena* arena) {
+  Connection* ret = Connection_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Connection_msg_init, extreg,
+                 options, arena) != kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char* Connection_serialize(const Connection* msg,
+                                      upb_Arena* arena, size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Connection_msg_init, 0, arena, &ptr, len);
   return ptr;
 }
-UPB_INLINE char* Connection_serialize_ex(const Connection* msg, int options,
-                                 upb_Arena* arena, size_t* len) {
+UPB_INLINE char* Connection_serialize_ex(const Connection* msg,
+                                         int options, upb_Arena* arena,
+                                         size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Connection_msg_init, options, arena, &ptr, len);
   return ptr;
@@ -267,37 +286,39 @@ UPB_INLINE void Connection_set_session_key(Connection *msg, upb_StringView value
 }
 
 /* Hacker */
-
 UPB_INLINE Hacker* Hacker_new(upb_Arena* arena) {
   return (Hacker*)_upb_Message_New(&Hacker_msg_init, arena);
 }
-UPB_INLINE Hacker* Hacker_parse(const char* buf, size_t size, upb_Arena* arena) {
+UPB_INLINE Hacker* Hacker_parse(const char* buf, size_t size,
+                                        upb_Arena* arena) {
   Hacker* ret = Hacker_new(arena);
   if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Hacker_msg_init, NULL, 0, arena) !=
-      kUpb_DecodeStatus_Ok) {
-    return NULL;
-  }
-  return ret;
-}
-UPB_INLINE Hacker* Hacker_parse_ex(const char* buf, size_t size,
-                           const upb_ExtensionRegistry* extreg,
-                           int options, upb_Arena* arena) {
-  Hacker* ret = Hacker_new(arena);
-  if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Hacker_msg_init, extreg, options,
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Hacker_msg_init, NULL, 0,
                  arena) != kUpb_DecodeStatus_Ok) {
     return NULL;
   }
   return ret;
 }
-UPB_INLINE char* Hacker_serialize(const Hacker* msg, upb_Arena* arena, size_t* len) {
+UPB_INLINE Hacker* Hacker_parse_ex(
+    const char* buf, size_t size, const upb_ExtensionRegistry* extreg,
+    int options, upb_Arena* arena) {
+  Hacker* ret = Hacker_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Hacker_msg_init, extreg,
+                 options, arena) != kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char* Hacker_serialize(const Hacker* msg,
+                                      upb_Arena* arena, size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Hacker_msg_init, 0, arena, &ptr, len);
   return ptr;
 }
-UPB_INLINE char* Hacker_serialize_ex(const Hacker* msg, int options,
-                                 upb_Arena* arena, size_t* len) {
+UPB_INLINE char* Hacker_serialize_ex(const Hacker* msg,
+                                         int options, upb_Arena* arena,
+                                         size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Hacker_msg_init, options, arena, &ptr, len);
   return ptr;
@@ -378,7 +399,8 @@ UPB_INLINE void Hacker_clear_exploits(Hacker* msg) {
   const upb_MiniTableField field = {7, UPB_SIZE(20, 64), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
 }
-UPB_INLINE upb_StringView const* Hacker_exploits(const Hacker* msg, size_t* size) {
+UPB_INLINE upb_StringView const* Hacker_exploits(const Hacker* msg,
+                                                  size_t* size) {
   const upb_MiniTableField field = {7, UPB_SIZE(20, 64), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -389,7 +411,10 @@ UPB_INLINE upb_StringView const* Hacker_exploits(const Hacker* msg, size_t* size
     return NULL;
   }
 }
-UPB_INLINE const upb_Array* _Hacker_exploits_upb_array(const Hacker* msg, size_t* size) {
+
+//
+UPB_INLINE const upb_Array* _Hacker_exploits_upb_array(
+    const Hacker* msg, size_t* size) {
   const upb_MiniTableField field = {7, UPB_SIZE(20, 64), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (size) {
@@ -397,7 +422,9 @@ UPB_INLINE const upb_Array* _Hacker_exploits_upb_array(const Hacker* msg, size_t
   }
   return arr;
 }
-UPB_INLINE upb_Array* _Hacker_exploits_mutable_upb_array(Hacker* msg, size_t* size, upb_Arena* arena) {
+
+UPB_INLINE upb_Array* _Hacker_exploits_mutable_upb_array(
+    Hacker* msg, size_t* size, upb_Arena* arena) {
   const upb_MiniTableField field = {7, UPB_SIZE(20, 64), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
                                                        &field, arena);
@@ -407,11 +434,12 @@ UPB_INLINE upb_Array* _Hacker_exploits_mutable_upb_array(Hacker* msg, size_t* si
   return arr;
 }
 UPB_INLINE void Hacker_clear_tools(Hacker* msg) {
-  const upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
 }
-UPB_INLINE const Tool* const* Hacker_tools(const Hacker* msg, size_t* size) {
-  const upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE const Tool* const* Hacker_tools(const Hacker* msg,
+                                                  size_t* size) {
+  const upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Tool_msg_init);
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -422,8 +450,11 @@ UPB_INLINE const Tool* const* Hacker_tools(const Hacker* msg, size_t* size) {
     return NULL;
   }
 }
-UPB_INLINE const upb_Array* _Hacker_tools_upb_array(const Hacker* msg, size_t* size) {
-  const upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+
+//
+UPB_INLINE const upb_Array* _Hacker_tools_upb_array(
+    const Hacker* msg, size_t* size) {
+  const upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Tool_msg_init);
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (size) {
@@ -431,8 +462,10 @@ UPB_INLINE const upb_Array* _Hacker_tools_upb_array(const Hacker* msg, size_t* s
   }
   return arr;
 }
-UPB_INLINE upb_Array* _Hacker_tools_mutable_upb_array(Hacker* msg, size_t* size, upb_Arena* arena) {
-  const upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+
+UPB_INLINE upb_Array* _Hacker_tools_mutable_upb_array(
+    Hacker* msg, size_t* size, upb_Arena* arena) {
+  const upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Tool_msg_init);
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
                                                        &field, arena);
@@ -442,20 +475,20 @@ UPB_INLINE upb_Array* _Hacker_tools_mutable_upb_array(Hacker* msg, size_t* size,
   return arr;
 }
 UPB_INLINE void Hacker_clear_active_connection(Hacker* msg) {
-  const upb_MiniTableField field = {9, UPB_SIZE(28, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {9, UPB_SIZE(28, 80), 64, UPB_SIZE(4, 6), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
 }
 UPB_INLINE const Connection* Hacker_active_connection(const Hacker* msg) {
   const Connection* default_val = NULL;
   const Connection* ret;
-  const upb_MiniTableField field = {9, UPB_SIZE(28, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {9, UPB_SIZE(28, 80), 64, UPB_SIZE(4, 6), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Connection_msg_init);
   _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
                                     &default_val, &ret);
   return ret;
 }
 UPB_INLINE bool Hacker_has_active_connection(const Hacker* msg) {
-  const upb_MiniTableField field = {9, UPB_SIZE(28, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {9, UPB_SIZE(28, 80), 64, UPB_SIZE(4, 6), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
 }
 
@@ -483,7 +516,8 @@ UPB_INLINE void Hacker_set_crew_id(Hacker *msg, int64_t value) {
   const upb_MiniTableField field = {6, UPB_SIZE(48, 56), 0, kUpb_NoSub, 3, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)};
   upb_Message_SetBaseField((upb_Message*)msg, &field, &value);
 }
-UPB_INLINE upb_StringView* Hacker_mutable_exploits(Hacker* msg, size_t* size) {
+UPB_INLINE upb_StringView* Hacker_mutable_exploits(Hacker* msg,
+                                              size_t* size) {
   upb_MiniTableField field = {7, UPB_SIZE(20, 64), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -494,12 +528,16 @@ UPB_INLINE upb_StringView* Hacker_mutable_exploits(Hacker* msg, size_t* size) {
     return NULL;
   }
 }
-UPB_INLINE upb_StringView* Hacker_resize_exploits(Hacker* msg, size_t size, upb_Arena* arena) {
+
+UPB_INLINE upb_StringView* Hacker_resize_exploits(Hacker* msg,
+                                             size_t size,
+                                             upb_Arena* arena) {
   upb_MiniTableField field = {7, UPB_SIZE(20, 64), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
-  return (upb_StringView*)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
-                                                   &field, size, arena);
+  return (upb_StringView*)upb_Message_ResizeArrayUninitialized(
+      UPB_UPCAST(msg), &field, size, arena);
 }
-UPB_INLINE bool Hacker_add_exploits(Hacker* msg, upb_StringView val, upb_Arena* arena) {
+UPB_INLINE bool Hacker_add_exploits(Hacker* msg, upb_StringView val,
+                                      upb_Arena* arena) {
   upb_MiniTableField field = {7, UPB_SIZE(20, 64), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(
       UPB_UPCAST(msg), &field, arena);
@@ -511,8 +549,9 @@ UPB_INLINE bool Hacker_add_exploits(Hacker* msg, upb_StringView val, upb_Arena*
   (arr, arr->UPB_PRIVATE(size) - 1, &val, sizeof(val));
   return true;
 }
-UPB_INLINE Tool** Hacker_mutable_tools(Hacker* msg, size_t* size) {
-  upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE Tool** Hacker_mutable_tools(Hacker* msg,
+                                              size_t* size) {
+  upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Tool_msg_init);
   upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -523,13 +562,18 @@ UPB_INLINE Tool** Hacker_mutable_tools(Hacker* msg, size_t* size) {
     return NULL;
   }
 }
-UPB_INLINE Tool** Hacker_resize_tools(Hacker* msg, size_t size, upb_Arena* arena) {
-  upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
-  return (Tool**)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
-                                                   &field, size, arena);
+
+UPB_INLINE Tool** Hacker_resize_tools(Hacker* msg,
+                                             size_t size,
+                                             upb_Arena* arena) {
+  upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Tool_msg_init);
+  return (Tool**)upb_Message_ResizeArrayUninitialized(
+      UPB_UPCAST(msg), &field, size, arena);
 }
-UPB_INLINE struct Tool* Hacker_add_tools(Hacker* msg, upb_Arena* arena) {
-  upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE struct Tool* Hacker_add_tools(
+    Hacker* msg, upb_Arena* arena) {
+  upb_MiniTableField field = {8, UPB_SIZE(24, 72), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Tool_msg_init);
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(
       UPB_UPCAST(msg), &field, arena);
@@ -537,18 +581,20 @@ UPB_INLINE struct Tool* Hacker_add_tools(Hacker* msg, upb_Arena* arena) {
                   arr, arr->UPB_PRIVATE(size) + 1, arena)) {
     return NULL;
   }
-  struct Tool* sub = (struct Tool*)_upb_Message_New(&Tool_msg_init, arena);
+  struct Tool* sub =
+      (struct Tool*)_upb_Message_New(&Tool_msg_init, arena);
   if (!arr || !sub) return NULL;
   UPB_PRIVATE(_upb_Array_Set)
   (arr, arr->UPB_PRIVATE(size) - 1, &sub, sizeof(sub));
   return sub;
 }
 UPB_INLINE void Hacker_set_active_connection(Hacker* msg, Connection* value) {
-  const upb_MiniTableField field = {9, UPB_SIZE(28, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {9, UPB_SIZE(28, 80), 64, UPB_SIZE(4, 6), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Connection_msg_init);
   upb_Message_SetBaseField((upb_Message*)msg, &field, &value);
 }
-UPB_INLINE struct Connection* Hacker_mutable_active_connection(Hacker* msg, upb_Arena* arena) {
+UPB_INLINE struct Connection* Hacker_mutable_active_connection(
+    Hacker* msg, upb_Arena* arena) {
   struct Connection* sub = (struct Connection*)Hacker_active_connection(msg);
   if (sub == NULL) {
     sub = (struct Connection*)_upb_Message_New(&Connection_msg_init, arena);
@@ -558,37 +604,39 @@ UPB_INLINE struct Connection* Hacker_mutable_active_connection(Hacker* msg, upb_
 }
 
 /* Worm */
-
 UPB_INLINE Worm* Worm_new(upb_Arena* arena) {
   return (Worm*)_upb_Message_New(&Worm_msg_init, arena);
 }
-UPB_INLINE Worm* Worm_parse(const char* buf, size_t size, upb_Arena* arena) {
+UPB_INLINE Worm* Worm_parse(const char* buf, size_t size,
+                                        upb_Arena* arena) {
   Worm* ret = Worm_new(arena);
   if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Worm_msg_init, NULL, 0, arena) !=
-      kUpb_DecodeStatus_Ok) {
-    return NULL;
-  }
-  return ret;
-}
-UPB_INLINE Worm* Worm_parse_ex(const char* buf, size_t size,
-                           const upb_ExtensionRegistry* extreg,
-                           int options, upb_Arena* arena) {
-  Worm* ret = Worm_new(arena);
-  if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Worm_msg_init, extreg, options,
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Worm_msg_init, NULL, 0,
                  arena) != kUpb_DecodeStatus_Ok) {
     return NULL;
   }
   return ret;
 }
-UPB_INLINE char* Worm_serialize(const Worm* msg, upb_Arena* arena, size_t* len) {
+UPB_INLINE Worm* Worm_parse_ex(
+    const char* buf, size_t size, const upb_ExtensionRegistry* extreg,
+    int options, upb_Arena* arena) {
+  Worm* ret = Worm_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Worm_msg_init, extreg,
+                 options, arena) != kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char* Worm_serialize(const Worm* msg,
+                                      upb_Arena* arena, size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Worm_msg_init, 0, arena, &ptr, len);
   return ptr;
 }
-UPB_INLINE char* Worm_serialize_ex(const Worm* msg, int options,
-                                 upb_Arena* arena, size_t* len) {
+UPB_INLINE char* Worm_serialize_ex(const Worm* msg,
+                                         int options, upb_Arena* arena,
+                                         size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Worm_msg_init, options, arena, &ptr, len);
   return ptr;
@@ -657,7 +705,8 @@ UPB_INLINE void Worm_clear_targets(Worm* msg) {
   const upb_MiniTableField field = {6, UPB_SIZE(16, 56), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
 }
-UPB_INLINE upb_StringView const* Worm_targets(const Worm* msg, size_t* size) {
+UPB_INLINE upb_StringView const* Worm_targets(const Worm* msg,
+                                                  size_t* size) {
   const upb_MiniTableField field = {6, UPB_SIZE(16, 56), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -668,7 +717,10 @@ UPB_INLINE upb_StringView const* Worm_targets(const Worm* msg, size_t* size) {
     return NULL;
   }
 }
-UPB_INLINE const upb_Array* _Worm_targets_upb_array(const Worm* msg, size_t* size) {
+
+//
+UPB_INLINE const upb_Array* _Worm_targets_upb_array(
+    const Worm* msg, size_t* size) {
   const upb_MiniTableField field = {6, UPB_SIZE(16, 56), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (size) {
@@ -676,7 +728,9 @@ UPB_INLINE const upb_Array* _Worm_targets_upb_array(const Worm* msg, size_t* siz
   }
   return arr;
 }
-UPB_INLINE upb_Array* _Worm_targets_mutable_upb_array(Worm* msg, size_t* size, upb_Arena* arena) {
+
+UPB_INLINE upb_Array* _Worm_targets_mutable_upb_array(
+    Worm* msg, size_t* size, upb_Arena* arena) {
   const upb_MiniTableField field = {6, UPB_SIZE(16, 56), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
                                                        &field, arena);
@@ -706,7 +760,8 @@ UPB_INLINE void Worm_set_polymorphic(Worm *msg, bool value) {
   const upb_MiniTableField field = {5, 8, 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)};
   upb_Message_SetBaseField((upb_Message*)msg, &field, &value);
 }
-UPB_INLINE upb_StringView* Worm_mutable_targets(Worm* msg, size_t* size) {
+UPB_INLINE upb_StringView* Worm_mutable_targets(Worm* msg,
+                                              size_t* size) {
   upb_MiniTableField field = {6, UPB_SIZE(16, 56), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -717,12 +772,16 @@ UPB_INLINE upb_StringView* Worm_mutable_targets(Worm* msg, size_t* size) {
     return NULL;
   }
 }
-UPB_INLINE upb_StringView* Worm_resize_targets(Worm* msg, size_t size, upb_Arena* arena) {
+
+UPB_INLINE upb_StringView* Worm_resize_targets(Worm* msg,
+                                             size_t size,
+                                             upb_Arena* arena) {
   upb_MiniTableField field = {6, UPB_SIZE(16, 56), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
-  return (upb_StringView*)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
-                                                   &field, size, arena);
+  return (upb_StringView*)upb_Message_ResizeArrayUninitialized(
+      UPB_UPCAST(msg), &field, size, arena);
 }
-UPB_INLINE bool Worm_add_targets(Worm* msg, upb_StringView val, upb_Arena* arena) {
+UPB_INLINE bool Worm_add_targets(Worm* msg, upb_StringView val,
+                                      upb_Arena* arena) {
   upb_MiniTableField field = {6, UPB_SIZE(16, 56), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(
       UPB_UPCAST(msg), &field, arena);
@@ -736,37 +795,39 @@ UPB_INLINE bool Worm_add_targets(Worm* msg, upb_StringView val, upb_Arena* arena
 }
 
 /* Operation */
-
 UPB_INLINE Operation* Operation_new(upb_Arena* arena) {
   return (Operation*)_upb_Message_New(&Operation_msg_init, arena);
 }
-UPB_INLINE Operation* Operation_parse(const char* buf, size_t size, upb_Arena* arena) {
+UPB_INLINE Operation* Operation_parse(const char* buf, size_t size,
+                                        upb_Arena* arena) {
   Operation* ret = Operation_new(arena);
   if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Operation_msg_init, NULL, 0, arena) !=
-      kUpb_DecodeStatus_Ok) {
-    return NULL;
-  }
-  return ret;
-}
-UPB_INLINE Operation* Operation_parse_ex(const char* buf, size_t size,
-                           const upb_ExtensionRegistry* extreg,
-                           int options, upb_Arena* arena) {
-  Operation* ret = Operation_new(arena);
-  if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Operation_msg_init, extreg, options,
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Operation_msg_init, NULL, 0,
                  arena) != kUpb_DecodeStatus_Ok) {
     return NULL;
   }
   return ret;
 }
-UPB_INLINE char* Operation_serialize(const Operation* msg, upb_Arena* arena, size_t* len) {
+UPB_INLINE Operation* Operation_parse_ex(
+    const char* buf, size_t size, const upb_ExtensionRegistry* extreg,
+    int options, upb_Arena* arena) {
+  Operation* ret = Operation_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Operation_msg_init, extreg,
+                 options, arena) != kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char* Operation_serialize(const Operation* msg,
+                                      upb_Arena* arena, size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Operation_msg_init, 0, arena, &ptr, len);
   return ptr;
 }
-UPB_INLINE char* Operation_serialize_ex(const Operation* msg, int options,
-                                 upb_Arena* arena, size_t* len) {
+UPB_INLINE char* Operation_serialize_ex(const Operation* msg,
+                                         int options, upb_Arena* arena,
+                                         size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Operation_msg_init, options, arena, &ptr, len);
   return ptr;
@@ -832,11 +893,12 @@ UPB_INLINE upb_StringView Operation_stolen_data(const Operation* msg) {
   return ret;
 }
 UPB_INLINE void Operation_clear_crew(Operation* msg) {
-  const upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, UPB_SIZE(12, 13), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
 }
-UPB_INLINE const Hacker* const* Operation_crew(const Operation* msg, size_t* size) {
-  const upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE const Hacker* const* Operation_crew(const Operation* msg,
+                                                  size_t* size) {
+  const upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, UPB_SIZE(12, 13), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Hacker_msg_init);
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -847,8 +909,11 @@ UPB_INLINE const Hacker* const* Operation_crew(const Operation* msg, size_t* siz
     return NULL;
   }
 }
-UPB_INLINE const upb_Array* _Operation_crew_upb_array(const Operation* msg, size_t* size) {
-  const upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+
+//
+UPB_INLINE const upb_Array* _Operation_crew_upb_array(
+    const Operation* msg, size_t* size) {
+  const upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, UPB_SIZE(12, 13), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Hacker_msg_init);
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (size) {
@@ -856,8 +921,10 @@ UPB_INLINE const upb_Array* _Operation_crew_upb_array(const Operation* msg, size
   }
   return arr;
 }
-UPB_INLINE upb_Array* _Operation_crew_mutable_upb_array(Operation* msg, size_t* size, upb_Arena* arena) {
-  const upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+
+UPB_INLINE upb_Array* _Operation_crew_mutable_upb_array(
+    Operation* msg, size_t* size, upb_Arena* arena) {
+  const upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, UPB_SIZE(12, 13), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Hacker_msg_init);
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
                                                        &field, arena);
@@ -867,27 +934,28 @@ UPB_INLINE upb_Array* _Operation_crew_mutable_upb_array(Operation* msg, size_t*
   return arr;
 }
 UPB_INLINE void Operation_clear_worm(Operation* msg) {
-  const upb_MiniTableField field = {7, UPB_SIZE(16, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {7, UPB_SIZE(16, 80), 64, UPB_SIZE(10, 12), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
 }
 UPB_INLINE const Worm* Operation_worm(const Operation* msg) {
   const Worm* default_val = NULL;
   const Worm* ret;
-  const upb_MiniTableField field = {7, UPB_SIZE(16, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {7, UPB_SIZE(16, 80), 64, UPB_SIZE(10, 12), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Worm_msg_init);
   _upb_Message_GetNonExtensionField(UPB_UPCAST(msg), &field,
                                     &default_val, &ret);
   return ret;
 }
 UPB_INLINE bool Operation_has_worm(const Operation* msg) {
-  const upb_MiniTableField field = {7, UPB_SIZE(16, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {7, UPB_SIZE(16, 80), 64, UPB_SIZE(10, 12), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
 }
 UPB_INLINE void Operation_clear_log_entries(Operation* msg) {
   const upb_MiniTableField field = {8, UPB_SIZE(20, 88), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
 }
-UPB_INLINE upb_StringView const* Operation_log_entries(const Operation* msg, size_t* size) {
+UPB_INLINE upb_StringView const* Operation_log_entries(const Operation* msg,
+                                                  size_t* size) {
   const upb_MiniTableField field = {8, UPB_SIZE(20, 88), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -898,7 +966,10 @@ UPB_INLINE upb_StringView const* Operation_log_entries(const Operation* msg, siz
     return NULL;
   }
 }
-UPB_INLINE const upb_Array* _Operation_log_entries_upb_array(const Operation* msg, size_t* size) {
+
+//
+UPB_INLINE const upb_Array* _Operation_log_entries_upb_array(
+    const Operation* msg, size_t* size) {
   const upb_MiniTableField field = {8, UPB_SIZE(20, 88), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (size) {
@@ -906,7 +977,9 @@ UPB_INLINE const upb_Array* _Operation_log_entries_upb_array(const Operation* ms
   }
   return arr;
 }
-UPB_INLINE upb_Array* _Operation_log_entries_mutable_upb_array(Operation* msg, size_t* size, upb_Arena* arena) {
+
+UPB_INLINE upb_Array* _Operation_log_entries_mutable_upb_array(
+    Operation* msg, size_t* size, upb_Arena* arena) {
   const upb_MiniTableField field = {8, UPB_SIZE(20, 88), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
                                                        &field, arena);
@@ -948,8 +1021,9 @@ UPB_INLINE void Operation_set_stolen_data(Operation *msg, upb_StringView value)
   const upb_MiniTableField field = {5, UPB_SIZE(44, 48), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
   upb_Message_SetBaseField((upb_Message*)msg, &field, &value);
 }
-UPB_INLINE Hacker** Operation_mutable_crew(Operation* msg, size_t* size) {
-  upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE Hacker** Operation_mutable_crew(Operation* msg,
+                                              size_t* size) {
+  upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, UPB_SIZE(12, 13), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Hacker_msg_init);
   upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -960,13 +1034,18 @@ UPB_INLINE Hacker** Operation_mutable_crew(Operation* msg, size_t* size) {
     return NULL;
   }
 }
-UPB_INLINE Hacker** Operation_resize_crew(Operation* msg, size_t size, upb_Arena* arena) {
-  upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
-  return (Hacker**)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
-                                                   &field, size, arena);
+
+UPB_INLINE Hacker** Operation_resize_crew(Operation* msg,
+                                             size_t size,
+                                             upb_Arena* arena) {
+  upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, UPB_SIZE(12, 13), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Hacker_msg_init);
+  return (Hacker**)upb_Message_ResizeArrayUninitialized(
+      UPB_UPCAST(msg), &field, size, arena);
 }
-UPB_INLINE struct Hacker* Operation_add_crew(Operation* msg, upb_Arena* arena) {
-  upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE struct Hacker* Operation_add_crew(
+    Operation* msg, upb_Arena* arena) {
+  upb_MiniTableField field = {6, UPB_SIZE(12, 72), 0, UPB_SIZE(12, 13), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Hacker_msg_init);
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(
       UPB_UPCAST(msg), &field, arena);
@@ -974,18 +1053,20 @@ UPB_INLINE struct Hacker* Operation_add_crew(Operation* msg, upb_Arena* arena) {
                   arr, arr->UPB_PRIVATE(size) + 1, arena)) {
     return NULL;
   }
-  struct Hacker* sub = (struct Hacker*)_upb_Message_New(&Hacker_msg_init, arena);
+  struct Hacker* sub =
+      (struct Hacker*)_upb_Message_New(&Hacker_msg_init, arena);
   if (!arr || !sub) return NULL;
   UPB_PRIVATE(_upb_Array_Set)
   (arr, arr->UPB_PRIVATE(size) - 1, &sub, sizeof(sub));
   return sub;
 }
 UPB_INLINE void Operation_set_worm(Operation* msg, Worm* value) {
-  const upb_MiniTableField field = {7, UPB_SIZE(16, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {7, UPB_SIZE(16, 80), 64, UPB_SIZE(10, 12), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Worm_msg_init);
   upb_Message_SetBaseField((upb_Message*)msg, &field, &value);
 }
-UPB_INLINE struct Worm* Operation_mutable_worm(Operation* msg, upb_Arena* arena) {
+UPB_INLINE struct Worm* Operation_mutable_worm(
+    Operation* msg, upb_Arena* arena) {
   struct Worm* sub = (struct Worm*)Operation_worm(msg);
   if (sub == NULL) {
     sub = (struct Worm*)_upb_Message_New(&Worm_msg_init, arena);
@@ -993,7 +1074,8 @@ UPB_INLINE struct Worm* Operation_mutable_worm(Operation* msg, upb_Arena* arena)
   }
   return sub;
 }
-UPB_INLINE upb_StringView* Operation_mutable_log_entries(Operation* msg, size_t* size) {
+UPB_INLINE upb_StringView* Operation_mutable_log_entries(Operation* msg,
+                                              size_t* size) {
   upb_MiniTableField field = {8, UPB_SIZE(20, 88), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -1004,12 +1086,16 @@ UPB_INLINE upb_StringView* Operation_mutable_log_entries(Operation* msg, size_t*
     return NULL;
   }
 }
-UPB_INLINE upb_StringView* Operation_resize_log_entries(Operation* msg, size_t size, upb_Arena* arena) {
+
+UPB_INLINE upb_StringView* Operation_resize_log_entries(Operation* msg,
+                                             size_t size,
+                                             upb_Arena* arena) {
   upb_MiniTableField field = {8, UPB_SIZE(20, 88), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
-  return (upb_StringView*)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
-                                                   &field, size, arena);
+  return (upb_StringView*)upb_Message_ResizeArrayUninitialized(
+      UPB_UPCAST(msg), &field, size, arena);
 }
-UPB_INLINE bool Operation_add_log_entries(Operation* msg, upb_StringView val, upb_Arena* arena) {
+UPB_INLINE bool Operation_add_log_entries(Operation* msg, upb_StringView val,
+                                      upb_Arena* arena) {
   upb_MiniTableField field = {8, UPB_SIZE(20, 88), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(
       UPB_UPCAST(msg), &field, arena);
@@ -1027,37 +1113,39 @@ UPB_INLINE void Operation_set_severity(Operation *msg, int32_t value) {
 }
 
 /* Campaign */
-
 UPB_INLINE Campaign* Campaign_new(upb_Arena* arena) {
   return (Campaign*)_upb_Message_New(&Campaign_msg_init, arena);
 }
-UPB_INLINE Campaign* Campaign_parse(const char* buf, size_t size, upb_Arena* arena) {
+UPB_INLINE Campaign* Campaign_parse(const char* buf, size_t size,
+                                        upb_Arena* arena) {
   Campaign* ret = Campaign_new(arena);
   if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Campaign_msg_init, NULL, 0, arena) !=
-      kUpb_DecodeStatus_Ok) {
-    return NULL;
-  }
-  return ret;
-}
-UPB_INLINE Campaign* Campaign_parse_ex(const char* buf, size_t size,
-                           const upb_ExtensionRegistry* extreg,
-                           int options, upb_Arena* arena) {
-  Campaign* ret = Campaign_new(arena);
-  if (!ret) return NULL;
-  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Campaign_msg_init, extreg, options,
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Campaign_msg_init, NULL, 0,
                  arena) != kUpb_DecodeStatus_Ok) {
     return NULL;
   }
   return ret;
 }
-UPB_INLINE char* Campaign_serialize(const Campaign* msg, upb_Arena* arena, size_t* len) {
+UPB_INLINE Campaign* Campaign_parse_ex(
+    const char* buf, size_t size, const upb_ExtensionRegistry* extreg,
+    int options, upb_Arena* arena) {
+  Campaign* ret = Campaign_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, UPB_UPCAST(ret), &Campaign_msg_init, extreg,
+                 options, arena) != kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char* Campaign_serialize(const Campaign* msg,
+                                      upb_Arena* arena, size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Campaign_msg_init, 0, arena, &ptr, len);
   return ptr;
 }
-UPB_INLINE char* Campaign_serialize_ex(const Campaign* msg, int options,
-                                 upb_Arena* arena, size_t* len) {
+UPB_INLINE char* Campaign_serialize_ex(const Campaign* msg,
+                                         int options, upb_Arena* arena,
+                                         size_t* len) {
   char* ptr;
   (void)upb_Encode(UPB_UPCAST(msg), &Campaign_msg_init, options, arena, &ptr, len);
   return ptr;
@@ -1075,11 +1163,12 @@ UPB_INLINE upb_StringView Campaign_name(const Campaign* msg) {
   return ret;
 }
 UPB_INLINE void Campaign_clear_operations(Campaign* msg) {
-  const upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  const upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
 }
-UPB_INLINE const Operation* const* Campaign_operations(const Campaign* msg, size_t* size) {
-  const upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE const Operation* const* Campaign_operations(const Campaign* msg,
+                                                  size_t* size) {
+  const upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Operation_msg_init);
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -1090,8 +1179,11 @@ UPB_INLINE const Operation* const* Campaign_operations(const Campaign* msg, size
     return NULL;
   }
 }
-UPB_INLINE const upb_Array* _Campaign_operations_upb_array(const Campaign* msg, size_t* size) {
-  const upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+
+//
+UPB_INLINE const upb_Array* _Campaign_operations_upb_array(
+    const Campaign* msg, size_t* size) {
+  const upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Operation_msg_init);
   const upb_Array* arr = upb_Message_GetArray(UPB_UPCAST(msg), &field);
   if (size) {
@@ -1099,8 +1191,10 @@ UPB_INLINE const upb_Array* _Campaign_operations_upb_array(const Campaign* msg,
   }
   return arr;
 }
-UPB_INLINE upb_Array* _Campaign_operations_mutable_upb_array(Campaign* msg, size_t* size, upb_Arena* arena) {
-  const upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+
+UPB_INLINE upb_Array* _Campaign_operations_mutable_upb_array(
+    Campaign* msg, size_t* size, upb_Arena* arena) {
+  const upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Operation_msg_init);
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(UPB_UPCAST(msg),
                                                        &field, arena);
@@ -1126,8 +1220,9 @@ UPB_INLINE void Campaign_set_name(Campaign *msg, upb_StringView value) {
   const upb_MiniTableField field = {1, UPB_SIZE(12, 8), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
   upb_Message_SetBaseField((upb_Message*)msg, &field, &value);
 }
-UPB_INLINE Operation** Campaign_mutable_operations(Campaign* msg, size_t* size) {
-  upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE Operation** Campaign_mutable_operations(Campaign* msg,
+                                              size_t* size) {
+  upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Operation_msg_init);
   upb_Array* arr = upb_Message_GetMutableArray(UPB_UPCAST(msg), &field);
   if (arr) {
@@ -1138,13 +1233,18 @@ UPB_INLINE Operation** Campaign_mutable_operations(Campaign* msg, size_t* size)
     return NULL;
   }
 }
-UPB_INLINE Operation** Campaign_resize_operations(Campaign* msg, size_t size, upb_Arena* arena) {
-  upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
-  return (Operation**)upb_Message_ResizeArrayUninitialized(UPB_UPCAST(msg),
-                                                   &field, size, arena);
+
+UPB_INLINE Operation** Campaign_resize_operations(Campaign* msg,
+                                             size_t size,
+                                             upb_Arena* arena) {
+  upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Operation_msg_init);
+  return (Operation**)upb_Message_ResizeArrayUninitialized(
+      UPB_UPCAST(msg), &field, size, arena);
 }
-UPB_INLINE struct Operation* Campaign_add_operations(Campaign* msg, upb_Arena* arena) {
-  upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+UPB_INLINE struct Operation* Campaign_add_operations(
+    Campaign* msg, upb_Arena* arena) {
+  upb_MiniTableField field = {2, UPB_SIZE(8, 24), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   UPB_PRIVATE(_upb_MiniTable_StrongReference)(&Operation_msg_init);
   upb_Array* arr = upb_Message_GetOrCreateMutableArray(
       UPB_UPCAST(msg), &field, arena);
@@ -1152,7 +1252,8 @@ UPB_INLINE struct Operation* Campaign_add_operations(Campaign* msg, upb_Arena* a
                   arr, arr->UPB_PRIVATE(size) + 1, arena)) {
     return NULL;
   }
-  struct Operation* sub = (struct Operation*)_upb_Message_New(&Operation_msg_init, arena);
+  struct Operation* sub =
+      (struct Operation*)_upb_Message_New(&Operation_msg_init, arena);
   if (!arr || !sub) return NULL;
   UPB_PRIVATE(_upb_Array_Set)
   (arr, arr->UPB_PRIVATE(size) - 1, &sub, sizeof(sub));

upb_test/hackers.upb_minitable.c

@@ -13,49 +13,73 @@
 // Must be last.
 #include "upb/port/def.inc"
 
-extern const struct upb_MiniTable UPB_PRIVATE(_kUpb_MiniTable_StaticallyTreeShaken);
-static const upb_MiniTableField Tool__fields[5] = {
+extern const UPB_PRIVATE(upb_GeneratedExtensionListEntry)* UPB_PRIVATE(upb_generated_extension_list);
+typedef struct {
+  upb_MiniTableField fields[5];
+} Tool_msg_init_Fields;
+
+static const Tool_msg_init_Fields Tool__fields = {{
   {1, 16, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {2, UPB_SIZE(24, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {3, UPB_SIZE(32, 48), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {4, 8, 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
   {5, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
-};
+}};
 
 const upb_MiniTable Tool_msg_init = {
-  NULL,
-  &Tool__fields[0],
-  UPB_SIZE(40, 64), 5, kUpb_ExtMode_NonExtendable, 5, UPB_FASTTABLE_MASK(255), 0,
+  &Tool__fields.fields[0],
+  UPB_SIZE(40, 64), 5, kUpb_ExtMode_NonExtendable, 5, UPB_FASTTABLE_MASK(56), 0,
 #ifdef UPB_TRACING_ENABLED
   "Tool",
 #endif
+  UPB_FASTTABLE_INIT({
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x001000003f00000a, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x002000003f000012, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x003000003f00001a, &upb_DecodeFast_Bytes_Scalar_Tag1Byte},
+    {0x000800003f000020, &upb_DecodeFast_Bool_Scalar_Tag1Byte},
+    {0x000c00003f000028, &upb_DecodeFast_Varint32_Scalar_Tag1Byte},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+  })
 };
 
-const upb_MiniTable* Tool_msg_init_ptr = &Tool_msg_init;
-static const upb_MiniTableField Connection__fields[5] = {
+typedef struct {
+  upb_MiniTableField fields[5];
+} Connection_msg_init_Fields;
+
+static const Connection_msg_init_Fields Connection__fields = {{
   {1, 16, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {2, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
   {3, 8, 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
   {4, UPB_SIZE(32, 48), 0, kUpb_NoSub, 3, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
   {5, UPB_SIZE(24, 32), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
-};
+}};
 
 const upb_MiniTable Connection_msg_init = {
-  NULL,
-  &Connection__fields[0],
-  UPB_SIZE(40, 56), 5, kUpb_ExtMode_NonExtendable, 5, UPB_FASTTABLE_MASK(255), 0,
+  &Connection__fields.fields[0],
+  UPB_SIZE(40, 56), 5, kUpb_ExtMode_NonExtendable, 5, UPB_FASTTABLE_MASK(56), 0,
 #ifdef UPB_TRACING_ENABLED
   "Connection",
 #endif
+  UPB_FASTTABLE_INIT({
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x001000003f00000a, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x000c00003f000010, &upb_DecodeFast_Varint32_Scalar_Tag1Byte},
+    {0x000800003f000018, &upb_DecodeFast_Bool_Scalar_Tag1Byte},
+    {0x003000003f000020, &upb_DecodeFast_Varint64_Scalar_Tag1Byte},
+    {0x002000003f00002a, &upb_DecodeFast_Bytes_Scalar_Tag1Byte},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+  })
 };
 
-const upb_MiniTable* Connection_msg_init_ptr = &Connection_msg_init;
-static const upb_MiniTableSubInternal Hacker__submsgs[2] = {
-  {.UPB_PRIVATE(submsg) = &Tool_msg_init_ptr},
-  {.UPB_PRIVATE(submsg) = &Connection_msg_init_ptr},
-};
+typedef struct {
+  upb_MiniTableField fields[9];
+  upb_MiniTableSubInternal subs[2];
+} Hacker_msg_init_Fields;
 
-static const upb_MiniTableField Hacker__fields[9] = {
+static const Hacker_msg_init_Fields Hacker__fields = {{
   {1, UPB_SIZE(32, 24), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {2, 40, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {3, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
@@ -63,96 +87,138 @@ static const upb_MiniTableField Hacker__fields[9] = {
   {5, 9, 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
   {6, UPB_SIZE(48, 56), 0, kUpb_NoSub, 3, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
   {7, UPB_SIZE(20, 64), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
-  {8, UPB_SIZE(24, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
-  {9, UPB_SIZE(28, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
-};
+  {8, UPB_SIZE(24, 72), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
+  {9, UPB_SIZE(28, 80), 64, UPB_SIZE(4, 6), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
+ },
+  {
+  {.UPB_PRIVATE(submsg) = &Tool_msg_init},
+  {.UPB_PRIVATE(submsg) = &Connection_msg_init},
+}};
 
 const upb_MiniTable Hacker_msg_init = {
-  &Hacker__submsgs[0],
-  &Hacker__fields[0],
+  &Hacker__fields.fields[0],
   UPB_SIZE(56, 88), 9, kUpb_ExtMode_NonExtendable, 9, UPB_FASTTABLE_MASK(56), 0,
 #ifdef UPB_TRACING_ENABLED
   "Hacker",
 #endif
   UPB_FASTTABLE_INIT({
     {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
-    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
-    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
-    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x001800003f00000a, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x002800003f000012, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x000c00003f000018, &upb_DecodeFast_Varint32_Scalar_Tag1Byte},
     {0x001000003f000025, &upb_DecodeFast_Fixed32_Scalar_Tag1Byte},
-    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
-    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
-    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x000900003f000028, &upb_DecodeFast_Bool_Scalar_Tag1Byte},
+    {0x003800003f000030, &upb_DecodeFast_Varint64_Scalar_Tag1Byte},
+    {0x004000003f00003a, &upb_DecodeFast_String_Repeated_Tag1Byte},
   })
 };
 
-const upb_MiniTable* Hacker_msg_init_ptr = &Hacker_msg_init;
-static const upb_MiniTableField Worm__fields[6] = {
+typedef struct {
+  upb_MiniTableField fields[6];
+} Worm_msg_init_Fields;
+
+static const Worm_msg_init_Fields Worm__fields = {{
   {1, UPB_SIZE(20, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {2, 12, 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
   {3, UPB_SIZE(40, 48), 0, kUpb_NoSub, 3, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
   {4, UPB_SIZE(28, 32), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {5, 8, 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
   {6, UPB_SIZE(16, 56), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
-};
+}};
 
 const upb_MiniTable Worm_msg_init = {
-  NULL,
-  &Worm__fields[0],
-  UPB_SIZE(48, 64), 6, kUpb_ExtMode_NonExtendable, 6, UPB_FASTTABLE_MASK(255), 0,
+  &Worm__fields.fields[0],
+  UPB_SIZE(48, 64), 6, kUpb_ExtMode_NonExtendable, 6, UPB_FASTTABLE_MASK(56), 0,
 #ifdef UPB_TRACING_ENABLED
   "Worm",
 #endif
+  UPB_FASTTABLE_INIT({
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x001000003f00000a, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x000c00003f000010, &upb_DecodeFast_Varint32_Scalar_Tag1Byte},
+    {0x003000003f000018, &upb_DecodeFast_Varint64_Scalar_Tag1Byte},
+    {0x002000003f000022, &upb_DecodeFast_Bytes_Scalar_Tag1Byte},
+    {0x000800003f000028, &upb_DecodeFast_Bool_Scalar_Tag1Byte},
+    {0x003800003f000032, &upb_DecodeFast_String_Repeated_Tag1Byte},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+  })
 };
 
-const upb_MiniTable* Worm_msg_init_ptr = &Worm_msg_init;
-static const upb_MiniTableSubInternal Operation__submsgs[2] = {
-  {.UPB_PRIVATE(submsg) = &Hacker_msg_init_ptr},
-  {.UPB_PRIVATE(submsg) = &Worm_msg_init_ptr},
-};
+typedef struct {
+  upb_MiniTableField fields[9];
+  upb_MiniTableSubInternal subs[2];
+} Operation_msg_init_Fields;
 
-static const upb_MiniTableField Operation__fields[9] = {
+static const Operation_msg_init_Fields Operation__fields = {{
   {1, UPB_SIZE(28, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {2, UPB_SIZE(36, 32), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {3, UPB_SIZE(56, 64), 0, kUpb_NoSub, 3, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
   {4, 9, 0, kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
   {5, UPB_SIZE(44, 48), 0, kUpb_NoSub, 12, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
-  {6, UPB_SIZE(12, 72), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
-  {7, UPB_SIZE(16, 80), 64, 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
+  {6, UPB_SIZE(12, 72), 0, UPB_SIZE(12, 13), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
+  {7, UPB_SIZE(16, 80), 64, UPB_SIZE(10, 12), 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
   {8, UPB_SIZE(20, 88), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
   {9, UPB_SIZE(24, 12), 0, kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
-};
+ },
+  {
+  {.UPB_PRIVATE(submsg) = &Hacker_msg_init},
+  {.UPB_PRIVATE(submsg) = &Worm_msg_init},
+}};
 
 const upb_MiniTable Operation_msg_init = {
-  &Operation__submsgs[0],
-  &Operation__fields[0],
-  UPB_SIZE(64, 96), 9, kUpb_ExtMode_NonExtendable, 9, UPB_FASTTABLE_MASK(255), 0,
+  &Operation__fields.fields[0],
+  UPB_SIZE(64, 96), 9, kUpb_ExtMode_NonExtendable, 9, UPB_FASTTABLE_MASK(120), 0,
 #ifdef UPB_TRACING_ENABLED
   "Operation",
 #endif
+  UPB_FASTTABLE_INIT({
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x001000003f00000a, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x002000003f000012, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x004000003f000018, &upb_DecodeFast_Varint64_Scalar_Tag1Byte},
+    {0x000900003f000020, &upb_DecodeFast_Bool_Scalar_Tag1Byte},
+    {0x003000003f00002a, &upb_DecodeFast_Bytes_Scalar_Tag1Byte},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x005800003f000042, &upb_DecodeFast_String_Repeated_Tag1Byte},
+    {0x000c00003f000048, &upb_DecodeFast_Varint32_Scalar_Tag1Byte},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+  })
 };
 
-const upb_MiniTable* Operation_msg_init_ptr = &Operation_msg_init;
-static const upb_MiniTableSubInternal Campaign__submsgs[1] = {
-  {.UPB_PRIVATE(submsg) = &Operation_msg_init_ptr},
-};
+typedef struct {
+  upb_MiniTableField fields[3];
+  upb_MiniTableSubInternal subs[1];
+} Campaign_msg_init_Fields;
 
-static const upb_MiniTableField Campaign__fields[3] = {
+static const Campaign_msg_init_Fields Campaign__fields = {{
   {1, UPB_SIZE(12, 8), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
-  {2, UPB_SIZE(8, 24), 0, 0, 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
+  {2, UPB_SIZE(8, 24), 0, UPB_SIZE(6, 7), 11, (int)kUpb_FieldMode_Array | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
   {3, UPB_SIZE(24, 32), 0, kUpb_NoSub, 3, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
-};
+ },
+  {
+  {.UPB_PRIVATE(submsg) = &Operation_msg_init},
+}};
 
 const upb_MiniTable Campaign_msg_init = {
-  &Campaign__submsgs[0],
-  &Campaign__fields[0],
-  UPB_SIZE(32, 40), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(255), 0,
+  &Campaign__fields.fields[0],
+  UPB_SIZE(32, 40), 3, kUpb_ExtMode_NonExtendable, 3, UPB_FASTTABLE_MASK(24), 0,
 #ifdef UPB_TRACING_ENABLED
   "Campaign",
 #endif
+  UPB_FASTTABLE_INIT({
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x000800003f00000a, &upb_DecodeFast_String_Scalar_Tag1Byte},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x002000003f000018, &upb_DecodeFast_Varint64_Scalar_Tag1Byte},
+  })
 };
 
-const upb_MiniTable* Campaign_msg_init_ptr = &Campaign_msg_init;
 static const upb_MiniTable *messages_layout[6] = {
   &Tool_msg_init,
   &Connection_msg_init,

upb_test/hackers.upb_minitable.h

@@ -19,17 +19,11 @@ extern "C" {
 #endif
 
 extern const upb_MiniTable Tool_msg_init;
-extern const upb_MiniTable* Tool_msg_init_ptr;
 extern const upb_MiniTable Connection_msg_init;
-extern const upb_MiniTable* Connection_msg_init_ptr;
 extern const upb_MiniTable Hacker_msg_init;
-extern const upb_MiniTable* Hacker_msg_init_ptr;
 extern const upb_MiniTable Worm_msg_init;
-extern const upb_MiniTable* Worm_msg_init_ptr;
 extern const upb_MiniTable Operation_msg_init;
-extern const upb_MiniTable* Operation_msg_init_ptr;
 extern const upb_MiniTable Campaign_msg_init;
-extern const upb_MiniTable* Campaign_msg_init_ptr;
 
 extern const upb_MiniTableFile hackers_proto_upb_file_layout;
 

upb_test/hackers_bench.c

@@ -66,7 +66,7 @@ typedef struct {
 } BenchData;
 
 static bool load_bench_data(BenchData *out, const char *name) {
-    snprintf(out->path, sizeof(out->path), "../data/bench/%s.pb", name);
+    snprintf(out->path, sizeof(out->path), "data/bench/%s.pb", name);
     FILE *f = fopen(out->path, "rb");
     if (!f) {
         printf("[skip] %s not found — "
@@ -342,6 +342,34 @@ static void fn_count_all_crew(void *state) {
     upb_Arena_Free(arena);
 }
 
+static void fn_read_update_write(void *state) {
+    BenchData *d = state;
+    upb_Arena *arena = upb_Arena_New();
+    Campaign  *c     = Campaign_parse((const char *)d->data, d->len, arena);
+
+    upb_StringView name = { .data = "updated", .size = 7 };
+    Campaign_set_name(c, name);
+
+    size_t len;
+    char *out = Campaign_serialize(c, arena, &len);
+    g_sink = (uintptr_t)out;
+
+    upb_Arena_Free(arena);
+}
+
+static void bench_read_update_write(void) {
+    const char *sizes[] = {"tiny", "small", "medium", NULL};
+    printf("\n=== read_update_write ===\n");
+    for (int i = 0; sizes[i]; i++) {
+        BenchData d;
+        if (!load_bench_data(&d, sizes[i])) continue;
+        char label[80];
+        snprintf(label, sizeof(label), "Campaign_parse+set+serialize/%s  [%zu B]", sizes[i], d.len);
+        run_bench(fn_read_update_write, &d, d.len, label);
+        free_bench_data(&d);
+    }
+}
+
 static void bench_iterate(void) {
     const char *sizes[] = {"tiny", "small", "medium", NULL};
     printf("\n=== iterate ===\n");
@@ -374,6 +402,7 @@ int main(void) {
     bench_deep_parse();
     bench_field_access();
     bench_iterate();
+    bench_read_update_write();
 
     printf("\n");
     return 0;