starpc 0.49.20 → 0.50.0

package/srpc/call-receipt_test.go

@@ -97,7 +97,7 @@ func TestCallReceiptCommitWaitsForServerAcknowledgment(t *testing.T) {
 		t.Fatalf("close send count = %d, want 1", got)
 	}
 
-	stream.terminal = TerminalCommitted
+	stream.terminal = TerminalKind_TERMINAL_KIND_COMMITTED
 	stream.terminalOkay = true
 	ack <- io.EOF
 	select {
@@ -117,7 +117,7 @@ func TestCallReceiptRejectsBareCloseAfterCloseSend(t *testing.T) {
 	stream := &receiptTestStream{
 		ctx:          context.Background(),
 		ackErr:       io.EOF,
-		terminal:     TerminalClosed,
+		terminal:     TerminalKind_TERMINAL_KIND_CLOSED,
 		terminalOkay: true,
 	}
 	receipt, err := ExecCallReceipt(
@@ -139,7 +139,7 @@ func TestCallReceiptCommitIgnoresCleanupError(t *testing.T) {
 	stream := &receiptTestStream{
 		ctx:          context.Background(),
 		ackErr:       io.EOF,
-		terminal:     TerminalCommitted,
+		terminal:     TerminalKind_TERMINAL_KIND_COMMITTED,
 		terminalOkay: true,
 		closeErr:     ErrCompleted,
 	}
@@ -195,7 +195,7 @@ func TestCallReceiptCommitAbortExclusion(t *testing.T) {
 		stream := &receiptTestStream{
 			ctx:          context.Background(),
 			ackErr:       io.EOF,
-			terminal:     TerminalCommitted,
+			terminal:     TerminalKind_TERMINAL_KIND_COMMITTED,
 			terminalOkay: true,
 		}
 		receipt, err := ExecCallReceipt(
@@ -286,7 +286,7 @@ func newReceiptClient() *receiptTestClient {
 		stream: &receiptTestStream{
 			ctx:          context.Background(),
 			ackErr:       io.EOF,
-			terminal:     TerminalCommitted,
+			terminal:     TerminalKind_TERMINAL_KIND_COMMITTED,
 			terminalOkay: true,
 		},
 	}
@@ -305,7 +305,7 @@ func TestServerInvocationTerminalClassification(t *testing.T) {
 					t.Fatalf("handle complete: %v", err)
 				}
 			},
-			want: TerminalCommitted,
+			want: TerminalKind_TERMINAL_KIND_COMMITTED,
 		},
 		{
 			name: "cancel",
@@ -314,14 +314,14 @@ func TestServerInvocationTerminalClassification(t *testing.T) {
 					t.Fatalf("handle cancel: %v", err)
 				}
 			},
-			want: TerminalCanceled,
+			want: TerminalKind_TERMINAL_KIND_CANCELED,
 		},
 		{
 			name: "loss",
 			act: func(rpc *ServerRPC) {
 				rpc.HandleStreamClose(errors.New("transport loss"))
 			},
-			want: TerminalLost,
+			want: TerminalKind_TERMINAL_KIND_TRANSPORT_LOST,
 		},
 
 		{
@@ -329,7 +329,7 @@ func TestServerInvocationTerminalClassification(t *testing.T) {
 			act: func(rpc *ServerRPC) {
 				rpc.HandleStreamClose(context.Canceled)
 			},
-			want: TerminalLost,
+			want: TerminalKind_TERMINAL_KIND_TRANSPORT_LOST,
 		},
 		{
 			name: "remote error packet",
@@ -338,7 +338,7 @@ func TestServerInvocationTerminalClassification(t *testing.T) {
 					t.Fatalf("handle remote error: %v", err)
 				}
 			},
-			want: TerminalLost,
+			want: TerminalKind_TERMINAL_KIND_TRANSPORT_LOST,
 		},
 		{
 			name: "remote error completion packet",
@@ -350,7 +350,7 @@ func TestServerInvocationTerminalClassification(t *testing.T) {
 					t.Fatalf("handle remote error completion: %v", err)
 				}
 			},
-			want: TerminalLost,
+			want: TerminalKind_TERMINAL_KIND_TRANSPORT_LOST,
 		},
 
 		{
@@ -358,7 +358,7 @@ func TestServerInvocationTerminalClassification(t *testing.T) {
 			act: func(rpc *ServerRPC) {
 				rpc.HandleStreamClose(nil)
 			},
-			want: TerminalClosed,
+			want: TerminalKind_TERMINAL_KIND_CLOSED,
 		},
 	}
 	for _, tc := range cases {
@@ -429,7 +429,7 @@ func TestServerInvocationTerminalIsMonotonic(t *testing.T) {
 			if err != nil {
 				t.Fatalf("wait terminal: %v", err)
 			}
-			if kind != TerminalCommitted {
+			if kind != TerminalKind_TERMINAL_KIND_COMMITTED {
 				t.Fatalf("terminal = %v, want committed", kind)
 			}
 		})
@@ -450,8 +450,8 @@ func TestServerInvocationGenuineAbandonment(t *testing.T) {
 	ownerCancel()
 	select {
 	case got := <-result:
-		if got != TerminalAbandoned {
-			t.Fatalf("terminal = %v, want %v", got, TerminalAbandoned)
+		if got != TerminalKind_TERMINAL_KIND_ABANDONED {
+			t.Fatalf("terminal = %v, want %v", got, TerminalKind_TERMINAL_KIND_ABANDONED)
 		}
 	case <-time.After(time.Second):
 		t.Fatal("wait terminal did not return on owner cancellation")
@@ -471,7 +471,7 @@ func TestServerInvocationTerminalPrecedesOwnerCancellation(t *testing.T) {
 					t.Fatalf("handle complete: %v", err)
 				}
 			},
-			want: TerminalCommitted,
+			want: TerminalKind_TERMINAL_KIND_COMMITTED,
 		},
 		{
 			name: "cancel",
@@ -480,21 +480,21 @@ func TestServerInvocationTerminalPrecedesOwnerCancellation(t *testing.T) {
 					t.Fatalf("handle cancel: %v", err)
 				}
 			},
-			want: TerminalCanceled,
+			want: TerminalKind_TERMINAL_KIND_CANCELED,
 		},
 		{
 			name: "loss",
 			act: func(rpc *ServerRPC) {
 				rpc.HandleStreamClose(errors.New("transport loss"))
 			},
-			want: TerminalLost,
+			want: TerminalKind_TERMINAL_KIND_TRANSPORT_LOST,
 		},
 		{
 			name: "bare close",
 			act: func(rpc *ServerRPC) {
 				rpc.HandleStreamClose(nil)
 			},
-			want: TerminalClosed,
+			want: TerminalKind_TERMINAL_KIND_CLOSED,
 		},
 	}
 	for _, tc := range cases {

package/srpc/common-rpc.go

@@ -138,7 +138,7 @@ func (c *commonRPC) WaitTerminal(ownerCtx context.Context) (TerminalKind, error)
 		if ownerDone {
 			err := ownerCtx.Err()
 			locked.Unlock()
-			return TerminalAbandoned, err
+			return TerminalKind_TERMINAL_KIND_ABANDONED, err
 		}
 		waitCh := locked.WaitCh()
 		locked.Unlock()
@@ -277,11 +277,11 @@ func (c *commonRPC) HandleCallData(pkt *CallData) error {
 	if complete {
 		c.dataClosed = true
 		if len(pktErr) == 0 {
-			if c.recordRemoteTerminalLocked(TerminalCommitted) {
+			if c.recordRemoteTerminalLocked(TerminalKind_TERMINAL_KIND_COMMITTED) {
 				c.remoteCompleted = true
 			}
 		} else {
-			c.recordRemoteTerminalLocked(TerminalLost)
+			c.recordRemoteTerminalLocked(TerminalKind_TERMINAL_KIND_TRANSPORT_LOST)
 		}
 	}
 
@@ -312,11 +312,11 @@ func (c *commonRPC) handleStreamCloseLocked(
 		c.remoteErr = closeErr
 	}
 	if !normalRemoteCloseAfterLocalComplete && !c.remoteTerminalSet {
-		terminal := TerminalClosed
+		terminal := TerminalKind_TERMINAL_KIND_CLOSED
 		if closeErr != nil {
-			terminal = TerminalLost
+			terminal = TerminalKind_TERMINAL_KIND_TRANSPORT_LOST
 			if c.remoteCanceled {
-				terminal = TerminalCanceled
+				terminal = TerminalKind_TERMINAL_KIND_CANCELED
 			}
 		}
 		c.recordRemoteTerminalLocked(terminal)

package/srpc/common-rpc.ts

@@ -3,10 +3,13 @@ import type { Sink, Source } from 'it-stream-types'
 import { pushable, type Pushable } from 'it-pushable'
 import { CompleteMessage } from '@aptre/protobuf-es-lite'
 
-import type { CallData, CallStart } from './rpcproto.pb.js'
-import { Packet } from './rpcproto.pb.js'
+import {
+  Packet,
+  TerminalKind,
+  type CallData,
+  type CallStart,
+} from './rpcproto.pb.js'
 import { ERR_RPC_ABORT, RemoteRPCError } from './errors.js'
-import type { TerminalKind } from './server-invocation.js'
 
 const maxBufferedOutgoingPackets = 1
 
@@ -86,7 +89,7 @@ export class CommonRPC {
         const terminal = this.getTerminalKind()
         if (terminal !== undefined) {
           if (
-            terminal === 'closed' &&
+            terminal === TerminalKind.CLOSED &&
             this.remoteSourceClosed &&
             !this.closed
           ) {
@@ -95,7 +98,7 @@ export class CommonRPC {
           return terminal
         }
         if (ownerAborted) {
-          return 'abandoned'
+          return TerminalKind.ABANDONED
         }
         await Promise.race([this.terminalPromise, ownerDone])
         ownerAborted = ownerSignal.aborted
@@ -267,18 +270,17 @@ export class CommonRPC {
     }
 
     this.pushRpcData(packet.data, packet.dataIsZero)
-    const remoteError =
-      packet.error ?
-        new RemoteRPCError(this.service, this.method, packet.error)
+    const remoteError = packet.error
+      ? new RemoteRPCError(this.service, this.method, packet.error)
       : undefined
     if (remoteError) {
       this.remoteError ??= remoteError
       this.invocationController.abort()
-      this.recordRemoteTerminal('transportLost')
+      this.recordRemoteTerminal(TerminalKind.TRANSPORT_LOST)
     }
     if (packet.complete && !remoteError) {
       this.remoteCompleted = true
-      this.recordRemoteTerminal('committed')
+      this.recordRemoteTerminal(TerminalKind.COMMITTED)
       this._rpcDataSource.end(remoteError)
     } else if (remoteError) {
       this._rpcDataSource.end(remoteError)
@@ -287,7 +289,7 @@ export class CommonRPC {
 
   // handleCallCancel handles a CallCancel packet.
   public async handleCallCancel() {
-    this.recordRemoteTerminal('canceled')
+    this.recordRemoteTerminal(TerminalKind.CANCELED)
     await this.close(new Error(ERR_RPC_ABORT))
   }
 
@@ -300,7 +302,9 @@ export class CommonRPC {
     if (!this.remoteError && err) {
       this.remoteError = err
     }
-    this.recordRemoteTerminal(err ? 'transportLost' : 'closed')
+    this.recordRemoteTerminal(
+      err ? TerminalKind.TRANSPORT_LOST : TerminalKind.CLOSED,
+    )
     this.invocationController.abort()
     // note: this does nothing if _source is already ended.
     if (err && err.message) {
@@ -314,23 +318,20 @@ export class CommonRPC {
     this._rpcDataSource.end(err)
   }
 
-  // _createSink returns a value for the sink field.
   private _createSink(): Sink<Source<Packet>> {
     return async (source: Source<Packet>) => {
       try {
         if (Symbol.asyncIterator in source) {
-          // Handle async source
           for await (const msg of source) {
             await this.handlePacket(msg)
           }
         } else {
-          // Handle sync source
           for (const msg of source) {
             await this.handlePacket(msg)
           }
         }
         this.remoteSourceClosed = true
-        this.recordRemoteTerminal('closed')
+        this.recordRemoteTerminal(TerminalKind.CLOSED)
       } catch (err) {
         this.close(err as Error)
       }

package/srpc/index.ts

@@ -9,7 +9,7 @@ export { Client } from './client.js'
 export { CallReceipt } from './call-receipt.js'
 export type { HeldCall, ReceiptRpc } from './call-receipt.js'
 export { ServerInvocation } from './server-invocation.js'
-export type { TerminalKind } from './server-invocation.js'
+export { TerminalKind } from './rpcproto.pb.js'
 export { Server } from './server.js'
 export { StreamConn } from './conn.js'
 export type { StreamConnParams, StreamHandler } from './conn.js'

package/srpc/muxed-conn.go

@@ -6,7 +6,7 @@ import (
 	"math"
 	"net"
 
-	yamux "github.com/libp2p/go-yamux/v4"
+	yamux "github.com/libp2p/go-yamux/v5"
 )
 
 var yamuxConfigTemplate = func() yamux.Config {

package/srpc/muxed-yamux.go

@@ -3,7 +3,7 @@ package srpc
 import (
 	"context"
 
-	yamux "github.com/libp2p/go-yamux/v4"
+	yamux "github.com/libp2p/go-yamux/v5"
 )
 
 // yamuxConn wraps a yamux.Session to implement MuxedConn.

package/srpc/rpcproto.pb.cc

@@ -120,8 +120,8 @@ struct PacketDefaultTypeInternal {
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
     PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PacketDefaultTypeInternal _Packet_default_instance_;
 }  // namespace srpc
-static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
-    file_level_enum_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto = nullptr;
+static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL
+    file_level_enum_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto[1];
 static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
     file_level_service_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto = nullptr;
 const ::uint32_t
@@ -178,13 +178,18 @@ const char descriptor_table_protodef_github_2ecom_2faperturerobotics_2fstarpc_2f
     "service\030\001 \001(\t\022\022\n\nrpc_method\030\002 \001(\t\022\014\n\004dat"
     "a\030\003 \001(\014\022\024\n\014data_is_zero\030\004 \001(\010\"O\n\010CallDat"
     "a\022\014\n\004data\030\001 \001(\014\022\024\n\014data_is_zero\030\002 \001(\010\022\020\n"
-    "\010complete\030\003 \001(\010\022\r\n\005error\030\004 \001(\tb\006proto3"
+    "\010complete\030\003 \001(\010\022\r\n\005error\030\004 \001(\t*\277\001\n\014Termi"
+    "nalKind\022\035\n\031TERMINAL_KIND_UNSPECIFIED\020\000\022\033"
+    "\n\027TERMINAL_KIND_COMMITTED\020\001\022\032\n\026TERMINAL_"
+    "KIND_CANCELED\020\002\022 \n\034TERMINAL_KIND_TRANSPO"
+    "RT_LOST\020\003\022\030\n\024TERMINAL_KIND_CLOSED\020\004\022\033\n\027T"
+    "ERMINAL_KIND_ABANDONED\020\005b\006proto3"
 };
 static ::absl::once_flag descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto_once;
 PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto = {
     false,
     false,
-    358,
+    552,
     descriptor_table_protodef_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto,
     "github.com/aperturerobotics/starpc/srpc/rpcproto.proto",
     &descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto_once,
@@ -198,6 +203,12 @@ PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_github_2ecom_2
     file_level_service_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto,
 };
 namespace srpc {
+const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL TerminalKind_descriptor() {
+  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto);
+  return file_level_enum_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto[0];
+}
+PROTOBUF_CONSTINIT const uint32_t TerminalKind_internal_data_[] = {
+    393216u, 0u, };
 // ===================================================================
 
 class Packet::_Internal {

package/srpc/rpcproto.pb.go

@@ -16,6 +16,58 @@ import (
 	json "github.com/aperturerobotics/protobuf-go-lite/json"
 )
 
+// TerminalKind is the terminal state of a held unary invocation.
+type TerminalKind int32
+
+const (
+	// TERMINAL_KIND_UNSPECIFIED is not a valid terminal state.
+	TerminalKind_TERMINAL_KIND_UNSPECIFIED TerminalKind = 0
+	// TERMINAL_KIND_COMMITTED identifies an explicit remote CallData completion.
+	TerminalKind_TERMINAL_KIND_COMMITTED TerminalKind = 1
+	// TERMINAL_KIND_CANCELED identifies a remote CallCancel packet.
+	TerminalKind_TERMINAL_KIND_CANCELED TerminalKind = 2
+	// TERMINAL_KIND_TRANSPORT_LOST identifies a remote error or transport failure.
+	TerminalKind_TERMINAL_KIND_TRANSPORT_LOST TerminalKind = 3
+	// TERMINAL_KIND_CLOSED identifies a bare remote close without completion.
+	TerminalKind_TERMINAL_KIND_CLOSED TerminalKind = 4
+	// TERMINAL_KIND_ABANDONED identifies owner-context expiry without a remote terminal.
+	TerminalKind_TERMINAL_KIND_ABANDONED TerminalKind = 5
+)
+
+// Enum value maps for TerminalKind.
+var (
+	TerminalKind_name = map[int32]string{
+		0: "TERMINAL_KIND_UNSPECIFIED",
+		1: "TERMINAL_KIND_COMMITTED",
+		2: "TERMINAL_KIND_CANCELED",
+		3: "TERMINAL_KIND_TRANSPORT_LOST",
+		4: "TERMINAL_KIND_CLOSED",
+		5: "TERMINAL_KIND_ABANDONED",
+	}
+	TerminalKind_value = map[string]int32{
+		"TERMINAL_KIND_UNSPECIFIED":    0,
+		"TERMINAL_KIND_COMMITTED":      1,
+		"TERMINAL_KIND_CANCELED":       2,
+		"TERMINAL_KIND_TRANSPORT_LOST": 3,
+		"TERMINAL_KIND_CLOSED":         4,
+		"TERMINAL_KIND_ABANDONED":      5,
+	}
+)
+
+func (x TerminalKind) Enum() *TerminalKind {
+	p := new(TerminalKind)
+	*p = x
+	return p
+}
+
+func (x TerminalKind) String() string {
+	name, valid := TerminalKind_name[int32(x)]
+	if valid {
+		return name
+	}
+	return strconv.Itoa(int(x))
+}
+
 // Packet is a message sent over a srpc packet connection.
 type Packet struct {
 	unknownFields []byte
@@ -437,6 +489,46 @@ func (this *CallData) EqualMessageVT(thatMsg any) bool {
 	return this.EqualVT(that)
 }
 
+// MarshalProtoJSON marshals the TerminalKind to JSON.
+func (x TerminalKind) MarshalProtoJSON(s *json.MarshalState) {
+	s.WriteEnum(int32(x), TerminalKind_name)
+}
+
+// MarshalText marshals the TerminalKind to text.
+func (x TerminalKind) MarshalText() ([]byte, error) {
+	return []byte(json.GetEnumString(int32(x), TerminalKind_name)), nil
+}
+
+// MarshalJSON marshals the TerminalKind to JSON.
+func (x TerminalKind) MarshalJSON() ([]byte, error) {
+	return json.DefaultMarshalerConfig.Marshal(x)
+}
+
+// UnmarshalProtoJSON unmarshals the TerminalKind from JSON.
+func (x *TerminalKind) UnmarshalProtoJSON(s *json.UnmarshalState) {
+	v := s.ReadEnum(TerminalKind_value)
+	if err := s.Err(); err != nil {
+		s.SetErrorf("could not read TerminalKind enum: %v", err)
+		return
+	}
+	*x = TerminalKind(v)
+}
+
+// UnmarshalText unmarshals the TerminalKind from text.
+func (x *TerminalKind) UnmarshalText(b []byte) error {
+	i, err := json.ParseEnumString(string(b), TerminalKind_value)
+	if err != nil {
+		return err
+	}
+	*x = TerminalKind(i)
+	return nil
+}
+
+// UnmarshalJSON unmarshals the TerminalKind from JSON.
+func (x *TerminalKind) UnmarshalJSON(b []byte) error {
+	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
+}
+
 // MarshalProtoJSON marshals the Packet message to JSON.
 func (x *Packet) MarshalProtoJSON(s *json.MarshalState) {
 	if x == nil {
@@ -983,6 +1075,10 @@ func (m *CallData) SizeVT() (n int) {
 	return n
 }
 
+func (x TerminalKind) MarshalProtoText() string {
+	return x.String()
+}
+
 func (x *Packet) MarshalProtoText() string {
 	var sb strings.Builder
 	sb.WriteString("Packet {")

package/srpc/rpcproto.pb.h

@@ -30,6 +30,7 @@
 #include "google/protobuf/message_lite.h"
 #include "google/protobuf/repeated_field.h"  // IWYU pragma: export
 #include "google/protobuf/extension_set.h"  // IWYU pragma: export
+#include "google/protobuf/generated_enum_reflection.h"
 #include "google/protobuf/unknown_field_set.h"
 // @@protoc_insertion_point(includes)
 
@@ -55,6 +56,8 @@ extern "C" {
 extern const ::google::protobuf::internal::DescriptorTable descriptor_table_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto;
 }  // extern "C"
 namespace srpc {
+enum TerminalKind : int;
+extern const uint32_t TerminalKind_internal_data_[];
 class CallData;
 struct CallDataDefaultTypeInternal;
 extern CallDataDefaultTypeInternal _CallData_default_instance_;
@@ -70,10 +73,53 @@ extern const ::google::protobuf::internal::ClassDataFull Packet_class_data_;
 }  // namespace srpc
 namespace google {
 namespace protobuf {
+template <>
+internal::EnumTraitsT<::srpc::TerminalKind_internal_data_>
+    internal::EnumTraitsImpl::value<::srpc::TerminalKind>;
 }  // namespace protobuf
 }  // namespace google
 
 namespace srpc {
+enum TerminalKind : int {
+  TERMINAL_KIND_UNSPECIFIED = 0,
+  TERMINAL_KIND_COMMITTED = 1,
+  TERMINAL_KIND_CANCELED = 2,
+  TERMINAL_KIND_TRANSPORT_LOST = 3,
+  TERMINAL_KIND_CLOSED = 4,
+  TERMINAL_KIND_ABANDONED = 5,
+  TerminalKind_INT_MIN_SENTINEL_DO_NOT_USE_ =
+      ::std::numeric_limits<::int32_t>::min(),
+  TerminalKind_INT_MAX_SENTINEL_DO_NOT_USE_ =
+      ::std::numeric_limits<::int32_t>::max(),
+};
+
+extern const uint32_t TerminalKind_internal_data_[];
+inline constexpr TerminalKind TerminalKind_MIN =
+    static_cast<TerminalKind>(0);
+inline constexpr TerminalKind TerminalKind_MAX =
+    static_cast<TerminalKind>(5);
+inline bool TerminalKind_IsValid(int value) {
+  return 0 <= value && value <= 5;
+}
+inline constexpr int TerminalKind_ARRAYSIZE = 5 + 1;
+const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL TerminalKind_descriptor();
+template <typename T>
+const ::std::string& TerminalKind_Name(T value) {
+  static_assert(::std::is_same<T, TerminalKind>::value ||
+                    ::std::is_integral<T>::value,
+                "Incorrect type passed to TerminalKind_Name().");
+  return TerminalKind_Name(static_cast<TerminalKind>(value));
+}
+template <>
+inline const ::std::string& TerminalKind_Name(TerminalKind value) {
+  return ::google::protobuf::internal::NameOfDenseEnum<TerminalKind_descriptor, 0, 5>(
+      static_cast<int>(value));
+}
+inline bool TerminalKind_Parse(
+    ::absl::string_view name, TerminalKind* PROTOBUF_NONNULL value) {
+  return ::google::protobuf::internal::ParseNamedEnum<TerminalKind>(TerminalKind_descriptor(), name,
+                                           value);
+}
 
 // ===================================================================
 
@@ -1444,6 +1490,19 @@ inline void CallData::set_allocated_error(::std::string* PROTOBUF_NULLABLE value
 }  // namespace srpc
 
 
+namespace google {
+namespace protobuf {
+
+template <>
+struct is_proto_enum<::srpc::TerminalKind> : std::true_type {};
+template <>
+inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::srpc::TerminalKind>() {
+  return ::srpc::TerminalKind_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
 // @@protoc_insertion_point(global_scope)
 
 #include "google/protobuf/port_undef.inc"

package/srpc/rpcproto.pb.rs

@@ -59,4 +59,49 @@ pub struct CallData {
     #[prost(string, tag="4")]
     pub error: ::prost::alloc::string::String,
 }
+/// TerminalKind is the terminal state of a held unary invocation.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum TerminalKind {
+    /// TERMINAL_KIND_UNSPECIFIED is not a valid terminal state.
+    Unspecified = 0,
+    /// TERMINAL_KIND_COMMITTED identifies an explicit remote CallData completion.
+    Committed = 1,
+    /// TERMINAL_KIND_CANCELED identifies a remote CallCancel packet.
+    Canceled = 2,
+    /// TERMINAL_KIND_TRANSPORT_LOST identifies a remote error or transport failure.
+    TransportLost = 3,
+    /// TERMINAL_KIND_CLOSED identifies a bare remote close without completion.
+    Closed = 4,
+    /// TERMINAL_KIND_ABANDONED identifies owner-context expiry without a remote terminal.
+    Abandoned = 5,
+}
+impl TerminalKind {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            Self::Unspecified => "TERMINAL_KIND_UNSPECIFIED",
+            Self::Committed => "TERMINAL_KIND_COMMITTED",
+            Self::Canceled => "TERMINAL_KIND_CANCELED",
+            Self::TransportLost => "TERMINAL_KIND_TRANSPORT_LOST",
+            Self::Closed => "TERMINAL_KIND_CLOSED",
+            Self::Abandoned => "TERMINAL_KIND_ABANDONED",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "TERMINAL_KIND_UNSPECIFIED" => Some(Self::Unspecified),
+            "TERMINAL_KIND_COMMITTED" => Some(Self::Committed),
+            "TERMINAL_KIND_CANCELED" => Some(Self::Canceled),
+            "TERMINAL_KIND_TRANSPORT_LOST" => Some(Self::TransportLost),
+            "TERMINAL_KIND_CLOSED" => Some(Self::Closed),
+            "TERMINAL_KIND_ABANDONED" => Some(Self::Abandoned),
+            _ => None,
+        }
+    }
+}
 // @@protoc_insertion_point(module)