starpc 0.42.0 → 0.43.1

package/README.md

@@ -1,6 +1,7 @@
 # starpc
 
 [![npm](https://img.shields.io/npm/v/starpc?style=flat-square)](https://www.npmjs.com/package/starpc)
+[![crates.io](https://img.shields.io/crates/v/starpc.svg?style=flat-square)](https://crates.io/crates/starpc)
 [![Build status](https://img.shields.io/github/actions/workflow/status/aperturerobotics/starpc/tests.yml?style=flat-square&branch=master)](https://github.com/aperturerobotics/starpc/actions)
 [![GoDoc Widget]][GoDoc] [![Go Report Card Widget]][Go Report Card]
 
@@ -14,32 +15,43 @@
 ## Table of Contents
 
 - [Features](#features)
+- [Documentation](#documentation)
 - [Installation](#installation)
 - [Quick Start](#quick-start)
 - [Examples](#examples)
   - [Protobuf Definition](#protobuf)
   - [Go Implementation](#go)
   - [TypeScript Implementation](#typescript)
+  - [Rust Implementation](#rust)
 - [Debugging](#debugging)
 - [Development Setup](#development-setup)
 - [Support](#support)
 
 ## Features
 
-- Full [Proto3 services] support for TypeScript and Go
+- Full [Proto3 services] support for TypeScript, Go, and Rust
 - Bidirectional streaming in browsers via WebSocket or WebRTC
 - Built on libp2p streams with [@chainsafe/libp2p-yamux]
 - Efficient multiplexing of RPCs over single connections
 - Zero-reflection Go via [protobuf-go-lite]
 - Lightweight TypeScript via [protobuf-es-lite]
+- Async Rust via [prost] and [tokio]
 - Sub-stream support via [rpcstream]
 
 [Proto3 services]: https://developers.google.com/protocol-buffers/docs/proto3#services
 [@chainsafe/libp2p-yamux]: https://github.com/ChainSafe/js-libp2p-yamux
 [protobuf-go-lite]: https://github.com/aperturerobotics/protobuf-go-lite
 [protobuf-es-lite]: https://github.com/aperturerobotics/protobuf-es-lite
+[prost]: https://github.com/tokio-rs/prost
+[tokio]: https://github.com/tokio-rs/tokio
 [rpcstream]: ./rpcstream
 
+## Documentation
+
+- [Getting Started with TypeScript](./GET_STARTED_TYPESCRIPT.md)
+- [Getting Started with Go](./GET_STARTED_GO.md)
+- [Getting Started with Rust](./GET_STARTED_RUST.md)
+
 ## Installation
 
 ```bash
@@ -47,11 +59,10 @@
 git clone -b starpc https://github.com/aperturerobotics/protobuf-project
 cd protobuf-project
 
-# Install dependencies
+# Install dependencies (any of these work)
+bun install
 npm install
-yarn install
 pnpm install
-bun install
 
 # Generate TypeScript and Go code
 bun run gen
@@ -134,6 +145,84 @@ For TypeScript <-> TypeScript, see the [e2e] test.
 [e2e]: ./e2e/e2e.ts
 [integration]: ./integration/integration.ts
 
+### Rust
+
+Add the dependencies to your `Cargo.toml`:
+
+```toml
+[dependencies]
+starpc = "0.1"
+prost = "0.13"
+tokio = { version = "1", features = ["rt", "macros"] }
+
+[build-dependencies]
+starpc-build = "0.1"
+prost-build = "0.13"
+```
+
+Create a `build.rs` to generate code from your proto files:
+
+```rust
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    starpc_build::configure()
+        .compile_protos(&["proto/echo.proto"], &["proto"])?;
+    Ok(())
+}
+```
+
+Implement and use your service:
+
+```rust
+use starpc::{Client, Mux, Server, SrpcClient};
+use std::sync::Arc;
+
+// Include generated code
+mod proto {
+    include!(concat!(env!("OUT_DIR"), "/echo.rs"));
+}
+
+use proto::*;
+
+// Implement the server trait
+struct EchoServer;
+
+#[starpc::async_trait]
+impl EchoerServer for EchoServer {
+    async fn echo(&self, request: EchoMsg) -> starpc::Result<EchoMsg> {
+        Ok(request) // Echo back the message
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create server
+    let mux = Arc::new(Mux::new());
+    mux.register(Arc::new(EchoerHandler::new(EchoServer)))?;
+    let server = Server::with_arc(mux);
+
+    // Create an in-memory connection for demonstration
+    let (client_stream, server_stream) = tokio::io::duplex(64 * 1024);
+
+    // Spawn server handler
+    tokio::spawn(async move {
+        let _ = server.handle_stream(server_stream).await;
+    });
+
+    // Create client
+    let opener = starpc::client::transport::SingleStreamOpener::new(client_stream);
+    let client = SrpcClient::new(opener);
+    let echoer = EchoerClientImpl::new(client);
+
+    // Make RPC call
+    let response = echoer.echo(&EchoMsg { body: "Hello!".into() }).await?;
+    println!("Response: {}", response.body);
+
+    Ok(())
+}
+```
+
+See the [echo example](./echo/main.rs) for a complete working example.
+
 #### WebSocket Example
 
 Connect to a WebSocket server:
@@ -226,21 +315,8 @@ Uses [protobuf-es-lite] (fork of [protobuf-es]) for TypeScript.
 
 ### MacOS
 
-Install required packages:
-
-```bash
-brew install bash make coreutils gnu-sed findutils protobuf
-brew link --overwrite protobuf
-```
-
-Add to your shell rc file (.bashrc, .zshrc):
-
-```bash
-export PATH="/opt/homebrew/opt/coreutils/libexec/gnubin:$PATH"
-export PATH="/opt/homebrew/opt/gnu-sed/libexec/gnubin:$PATH"
-export PATH="/opt/homebrew/opt/findutils/libexec/gnubin:$PATH"
-export PATH="/opt/homebrew/opt/make/libexec/gnubin:$PATH"
-```
+The `aptre` CLI handles all protobuf generation without requiring additional
+homebrew packages. Just run `bun run gen` after installing bun.
 
 ## Support
 

package/dist/mock/mock.pb.d.ts

@@ -1,4 +1,4 @@
-import type { MessageType } from "@aptre/protobuf-es-lite";
+import type { MessageType } from '@aptre/protobuf-es-lite';
 export declare const protobufPackage = "e2e.mock";
 /**
  * MockMsg is the mock message body.

package/dist/mock/mock.pb.js

@@ -1,14 +1,13 @@
 // @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/mock/mock.proto (package e2e.mock, syntax proto3)
 /* eslint-disable */
-import { createMessageType, ScalarType } from "@aptre/protobuf-es-lite";
-export const protobufPackage = "e2e.mock";
-;
+import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite';
+export const protobufPackage = 'e2e.mock';
 // MockMsg contains the message type declaration for MockMsg.
 export const MockMsg = createMessageType({
-    typeName: "e2e.mock.MockMsg",
+    typeName: 'e2e.mock.MockMsg',
     fields: [
-        { no: 1, name: "body", kind: "scalar", T: ScalarType.STRING },
+        { no: 1, name: 'body', kind: 'scalar', T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });

package/dist/mock/mock_srpc.pb.d.ts

@@ -1,6 +1,6 @@
-import { MockMsg } from "./mock.pb.js";
-import { MethodKind } from "@aptre/protobuf-es-lite";
-import { ProtoRpc } from "starpc";
+import { MockMsg } from './mock.pb.js';
+import { MethodKind } from '@aptre/protobuf-es-lite';
+import { ProtoRpc } from 'starpc';
 /**
  * Mock service mocks some RPCs for the e2e tests.
  *

package/dist/mock/mock_srpc.pb.js

@@ -1,15 +1,15 @@
 // @generated by protoc-gen-es-starpc none with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/mock/mock.proto (package e2e.mock, syntax proto3)
 /* eslint-disable */
-import { MockMsg } from "./mock.pb.js";
-import { MethodKind } from "@aptre/protobuf-es-lite";
+import { MockMsg } from './mock.pb.js';
+import { MethodKind } from '@aptre/protobuf-es-lite';
 /**
  * Mock service mocks some RPCs for the e2e tests.
  *
  * @generated from service e2e.mock.Mock
  */
 export const MockDefinition = {
-    typeName: "e2e.mock.Mock",
+    typeName: 'e2e.mock.Mock',
     methods: {
         /**
          * MockRequest runs a mock unary request.
@@ -17,12 +17,12 @@ export const MockDefinition = {
          * @generated from rpc e2e.mock.Mock.MockRequest
          */
         MockRequest: {
-            name: "MockRequest",
+            name: 'MockRequest',
             I: MockMsg,
             O: MockMsg,
             kind: MethodKind.Unary,
         },
-    }
+    },
 };
 export const MockServiceName = MockDefinition.typeName;
 export class MockClient {

package/echo/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "echo-example"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+publish = false
+
+[[bin]]
+name = "echo-example"
+path = "main.rs"
+
+[dependencies]
+starpc = { workspace = true }
+prost = { workspace = true }
+tokio = { version = "1", features = ["full"] }
+async-trait = { workspace = true }
+
+[build-dependencies]
+starpc-build = { workspace = true }
+prost-build = { workspace = true }

package/echo/build.rs

@@ -0,0 +1,15 @@
+use std::io::Result;
+use std::path::PathBuf;
+
+fn main() -> Result<()> {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    // Use simplified proto without rpcstream dependency
+    let proto_path = manifest_dir.join("echo_rust.proto");
+
+    println!("cargo:rerun-if-changed={}", proto_path.display());
+
+    starpc_build::configure()
+        .compile_protos(&[proto_path], &[&manifest_dir])?;
+
+    Ok(())
+}

package/echo/echo.pb.cc

@@ -0,0 +1,405 @@
+//go:build deps_only && cgo
+
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// NO CHECKED-IN PROTOBUF GENCODE
+// source: github.com/aperturerobotics/starpc/echo/echo.proto
+// Protobuf C++ Version: 6.33.4
+
+#include "echo.pb.h"
+
+#include <algorithm>
+#include <type_traits>
+#include "google/protobuf/io/coded_stream.h"
+#include "google/protobuf/generated_message_tctable_impl.h"
+#include "google/protobuf/extension_set.h"
+#include "google/protobuf/generated_message_util.h"
+#include "google/protobuf/wire_format_lite.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/generated_message_reflection.h"
+#include "google/protobuf/reflection_ops.h"
+#include "google/protobuf/wire_format.h"
+// @@protoc_insertion_point(includes)
+
+// Must be included last.
+#include "google/protobuf/port_def.inc"
+PROTOBUF_PRAGMA_INIT_SEG
+namespace _pb = ::google::protobuf;
+namespace _pbi = ::google::protobuf::internal;
+namespace _fl = ::google::protobuf::internal::field_layout;
+namespace echo {
+
+inline constexpr EchoMsg::Impl_::Impl_(
+    ::_pbi::ConstantInitialized) noexcept
+      : _cached_size_{0},
+        body_(
+            &::google::protobuf::internal::fixed_address_empty_string,
+            ::_pbi::ConstantInitialized()) {}
+
+template <typename>
+PROTOBUF_CONSTEXPR EchoMsg::EchoMsg(::_pbi::ConstantInitialized)
+#if defined(PROTOBUF_CUSTOM_VTABLE)
+    : ::google::protobuf::Message(EchoMsg_class_data_.base()),
+#else   // PROTOBUF_CUSTOM_VTABLE
+    : ::google::protobuf::Message(),
+#endif  // PROTOBUF_CUSTOM_VTABLE
+      _impl_(::_pbi::ConstantInitialized()) {
+}
+struct EchoMsgDefaultTypeInternal {
+  PROTOBUF_CONSTEXPR EchoMsgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
+  ~EchoMsgDefaultTypeInternal() {}
+  union {
+    EchoMsg _instance;
+  };
+};
+
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
+    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EchoMsgDefaultTypeInternal _EchoMsg_default_instance_;
+}  // namespace echo
+static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
+    file_level_enum_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto = nullptr;
+static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
+    file_level_service_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto = nullptr;
+const ::uint32_t
+    TableStruct_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE(
+        protodesc_cold) = {
+        0x081, // bitmap
+        PROTOBUF_FIELD_OFFSET(::echo::EchoMsg, _impl_._has_bits_),
+        4, // hasbit index offset
+        PROTOBUF_FIELD_OFFSET(::echo::EchoMsg, _impl_.body_),
+        0,
+};
+
+static const ::_pbi::MigrationSchema
+    schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
+        {0, sizeof(::echo::EchoMsg)},
+};
+static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = {
+    &::echo::_EchoMsg_default_instance_._instance,
+};
+const char descriptor_table_protodef_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE(
+    protodesc_cold) = {
+    "\n2github.com/aperturerobotics/starpc/ech"
+    "o/echo.proto\022\004echo\032<github.com/aperturer"
+    "obotics/starpc/rpcstream/rpcstream.proto"
+    "\032\033google/protobuf/empty.proto\"\027\n\007EchoMsg"
+    "\022\014\n\004body\030\001 \001(\t2\320\002\n\006Echoer\022$\n\004Echo\022\r.echo"
+    ".EchoMsg\032\r.echo.EchoMsg\0222\n\020EchoServerStr"
+    "eam\022\r.echo.EchoMsg\032\r.echo.EchoMsg0\001\0222\n\020E"
+    "choClientStream\022\r.echo.EchoMsg\032\r.echo.Ec"
+    "hoMsg(\001\0222\n\016EchoBidiStream\022\r.echo.EchoMsg"
+    "\032\r.echo.EchoMsg(\0010\001\022G\n\tRpcStream\022\032.rpcst"
+    "ream.RpcStreamPacket\032\032.rpcstream.RpcStre"
+    "amPacket(\0010\001\022;\n\tDoNothing\022\026.google.proto"
+    "buf.Empty\032\026.google.protobuf.Emptyb\006proto"
+    "3"
+};
+static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const
+    descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto_deps[2] = {
+        &::descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2frpcstream_2frpcstream_2eproto,
+        &::descriptor_table_google_2fprotobuf_2fempty_2eproto,
+};
+static ::absl::once_flag descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto_once;
+PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto = {
+    false,
+    false,
+    521,
+    descriptor_table_protodef_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto,
+    "github.com/aperturerobotics/starpc/echo/echo.proto",
+    &descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto_once,
+    descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto_deps,
+    2,
+    1,
+    schemas,
+    file_default_instances,
+    TableStruct_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto::offsets,
+    file_level_enum_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto,
+    file_level_service_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto,
+};
+namespace echo {
+// ===================================================================
+
+class EchoMsg::_Internal {
+ public:
+  using HasBits =
+      decltype(::std::declval<EchoMsg>()._impl_._has_bits_);
+  static constexpr ::int32_t kHasBitsOffset =
+      8 * PROTOBUF_FIELD_OFFSET(EchoMsg, _impl_._has_bits_);
+};
+
+EchoMsg::EchoMsg(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
+#if defined(PROTOBUF_CUSTOM_VTABLE)
+    : ::google::protobuf::Message(arena, EchoMsg_class_data_.base()) {
+#else   // PROTOBUF_CUSTOM_VTABLE
+    : ::google::protobuf::Message(arena) {
+#endif  // PROTOBUF_CUSTOM_VTABLE
+  SharedCtor(arena);
+  // @@protoc_insertion_point(arena_constructor:echo.EchoMsg)
+}
+PROTOBUF_NDEBUG_INLINE EchoMsg::Impl_::Impl_(
+    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
+    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
+    [[maybe_unused]] const ::echo::EchoMsg& from_msg)
+      : _has_bits_{from._has_bits_},
+        _cached_size_{0},
+        body_(arena, from.body_) {}
+
+EchoMsg::EchoMsg(
+    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
+    const EchoMsg& from)
+#if defined(PROTOBUF_CUSTOM_VTABLE)
+    : ::google::protobuf::Message(arena, EchoMsg_class_data_.base()) {
+#else   // PROTOBUF_CUSTOM_VTABLE
+    : ::google::protobuf::Message(arena) {
+#endif  // PROTOBUF_CUSTOM_VTABLE
+  EchoMsg* const _this = this;
+  (void)_this;
+  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
+
+  // @@protoc_insertion_point(copy_constructor:echo.EchoMsg)
+}
+PROTOBUF_NDEBUG_INLINE EchoMsg::Impl_::Impl_(
+    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
+    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
+      : _cached_size_{0},
+        body_(arena) {}
+
+inline void EchoMsg::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
+  new (&_impl_) Impl_(internal_visibility(), arena);
+}
+EchoMsg::~EchoMsg() {
+  // @@protoc_insertion_point(destructor:echo.EchoMsg)
+  SharedDtor(*this);
+}
+inline void EchoMsg::SharedDtor(MessageLite& self) {
+  EchoMsg& this_ = static_cast<EchoMsg&>(self);
+  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
+    this_.CheckHasBitConsistency();
+  }
+  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
+  ABSL_DCHECK(this_.GetArena() == nullptr);
+  this_._impl_.body_.Destroy();
+  this_._impl_.~Impl_();
+}
+
+inline void* PROTOBUF_NONNULL EchoMsg::PlacementNew_(
+    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
+    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
+  return ::new (mem) EchoMsg(arena);
+}
+constexpr auto EchoMsg::InternalNewImpl_() {
+  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(EchoMsg),
+                                            alignof(EchoMsg));
+}
+constexpr auto EchoMsg::InternalGenerateClassData_() {
+  return ::google::protobuf::internal::ClassDataFull{
+      ::google::protobuf::internal::ClassData{
+          &_EchoMsg_default_instance_._instance,
+          &_table_.header,
+          nullptr,  // OnDemandRegisterArenaDtor
+          nullptr,  // IsInitialized
+          &EchoMsg::MergeImpl,
+          ::google::protobuf::Message::GetNewImpl<EchoMsg>(),
+#if defined(PROTOBUF_CUSTOM_VTABLE)
+          &EchoMsg::SharedDtor,
+          ::google::protobuf::Message::GetClearImpl<EchoMsg>(), &EchoMsg::ByteSizeLong,
+              &EchoMsg::_InternalSerialize,
+#endif  // PROTOBUF_CUSTOM_VTABLE
+          PROTOBUF_FIELD_OFFSET(EchoMsg, _impl_._cached_size_),
+          false,
+      },
+      &EchoMsg::kDescriptorMethods,
+      &descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto,
+      nullptr,  // tracker
+  };
+}
+
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
+    ::google::protobuf::internal::ClassDataFull EchoMsg_class_data_ =
+        EchoMsg::InternalGenerateClassData_();
+
+PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
+EchoMsg::GetClassData() const {
+  ::google::protobuf::internal::PrefetchToLocalCache(&EchoMsg_class_data_);
+  ::google::protobuf::internal::PrefetchToLocalCache(EchoMsg_class_data_.tc_table);
+  return EchoMsg_class_data_.base();
+}
+PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
+const ::_pbi::TcParseTable<0, 1, 0, 25, 2>
+EchoMsg::_table_ = {
+  {
+    PROTOBUF_FIELD_OFFSET(EchoMsg, _impl_._has_bits_),
+    0, // no _extensions_
+    1, 0,  // max_field_number, fast_idx_mask
+    offsetof(decltype(_table_), field_lookup_table),
+    4294967294,  // skipmap
+    offsetof(decltype(_table_), field_entries),
+    1,  // num_field_entries
+    0,  // num_aux_entries
+    offsetof(decltype(_table_), field_names),  // no aux_entries
+    EchoMsg_class_data_.base(),
+    nullptr,  // post_loop_handler
+    ::_pbi::TcParser::GenericFallback,  // fallback
+    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
+    ::_pbi::TcParser::GetTable<::echo::EchoMsg>(),  // to_prefetch
+    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
+  }, {{
+    // string body = 1;
+    {::_pbi::TcParser::FastUS1,
+     {10, 0, 0,
+      PROTOBUF_FIELD_OFFSET(EchoMsg, _impl_.body_)}},
+  }}, {{
+    65535, 65535
+  }}, {{
+    // string body = 1;
+    {PROTOBUF_FIELD_OFFSET(EchoMsg, _impl_.body_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)},
+  }},
+  // no aux_entries
+  {{
+    "\14\4\0\0\0\0\0\0"
+    "echo.EchoMsg"
+    "body"
+  }},
+};
+PROTOBUF_NOINLINE void EchoMsg::Clear() {
+// @@protoc_insertion_point(message_clear_start:echo.EchoMsg)
+  ::google::protobuf::internal::TSanWrite(&_impl_);
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _impl_._has_bits_[0];
+  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
+    _impl_.body_.ClearNonDefaultToEmpty();
+  }
+  _impl_._has_bits_.Clear();
+  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
+}
+
+#if defined(PROTOBUF_CUSTOM_VTABLE)
+::uint8_t* PROTOBUF_NONNULL EchoMsg::_InternalSerialize(
+    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
+    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
+  const EchoMsg& this_ = static_cast<const EchoMsg&>(base);
+#else   // PROTOBUF_CUSTOM_VTABLE
+::uint8_t* PROTOBUF_NONNULL EchoMsg::_InternalSerialize(
+    ::uint8_t* PROTOBUF_NONNULL target,
+    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
+  const EchoMsg& this_ = *this;
+#endif  // PROTOBUF_CUSTOM_VTABLE
+  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
+    this_.CheckHasBitConsistency();
+  }
+  // @@protoc_insertion_point(serialize_to_array_start:echo.EchoMsg)
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  cached_has_bits = this_._impl_._has_bits_[0];
+  // string body = 1;
+  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
+    if (!this_._internal_body().empty()) {
+      const ::std::string& _s = this_._internal_body();
+      ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
+          _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "echo.EchoMsg.body");
+      target = stream->WriteStringMaybeAliased(1, _s, target);
+    }
+  }
+
+  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
+    target =
+        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
+            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:echo.EchoMsg)
+  return target;
+}
+
+#if defined(PROTOBUF_CUSTOM_VTABLE)
+::size_t EchoMsg::ByteSizeLong(const MessageLite& base) {
+  const EchoMsg& this_ = static_cast<const EchoMsg&>(base);
+#else   // PROTOBUF_CUSTOM_VTABLE
+::size_t EchoMsg::ByteSizeLong() const {
+  const EchoMsg& this_ = *this;
+#endif  // PROTOBUF_CUSTOM_VTABLE
+  // @@protoc_insertion_point(message_byte_size_start:echo.EchoMsg)
+  ::size_t total_size = 0;
+
+  ::uint32_t cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void)cached_has_bits;
+
+   {
+    // string body = 1;
+    cached_has_bits = this_._impl_._has_bits_[0];
+    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
+      if (!this_._internal_body().empty()) {
+        total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
+                                        this_._internal_body());
+      }
+    }
+  }
+  return this_.MaybeComputeUnknownFieldsSize(total_size,
+                                             &this_._impl_._cached_size_);
+}
+
+void EchoMsg::MergeImpl(::google::protobuf::MessageLite& to_msg,
+                            const ::google::protobuf::MessageLite& from_msg) {
+   auto* const _this =
+      static_cast<EchoMsg*>(&to_msg);
+  auto& from = static_cast<const EchoMsg&>(from_msg);
+  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
+    from.CheckHasBitConsistency();
+  }
+  // @@protoc_insertion_point(class_specific_merge_from_start:echo.EchoMsg)
+  ABSL_DCHECK_NE(&from, _this);
+  ::uint32_t cached_has_bits = 0;
+  (void)cached_has_bits;
+
+  cached_has_bits = from._impl_._has_bits_[0];
+  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
+    if (!from._internal_body().empty()) {
+      _this->_internal_set_body(from._internal_body());
+    } else {
+      if (_this->_impl_.body_.IsDefault()) {
+        _this->_internal_set_body("");
+      }
+    }
+  }
+  _this->_impl_._has_bits_[0] |= cached_has_bits;
+  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
+      from._internal_metadata_);
+}
+
+void EchoMsg::CopyFrom(const EchoMsg& from) {
+  // @@protoc_insertion_point(class_specific_copy_from_start:echo.EchoMsg)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+
+void EchoMsg::InternalSwap(EchoMsg* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
+  using ::std::swap;
+  auto* arena = GetArena();
+  ABSL_DCHECK_EQ(arena, other->GetArena());
+  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
+  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.body_, &other->_impl_.body_, arena);
+}
+
+::google::protobuf::Metadata EchoMsg::GetMetadata() const {
+  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
+}
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace echo
+namespace google {
+namespace protobuf {
+}  // namespace protobuf
+}  // namespace google
+// @@protoc_insertion_point(global_scope)
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type
+    _static_init2_ [[maybe_unused]] =
+        (::_pbi::AddDescriptors(&descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fecho_2fecho_2eproto),
+         ::std::false_type{});
+#include "google/protobuf/port_undef.inc"