starpc 0.50.0 → 0.51.0

package/srpc/common-rpc.go

@@ -31,8 +31,8 @@ type commonRPC struct {
 	writer PacketWriter
 	// writerClosed is set after writer has been closed locally.
 	writerClosed bool
-	// localCompleting is set while the local handler is publishing its terminal
-	// packet and closing the writer.
+	// localCompleting is set while the local handler is publishing its
+	// completion packet and closing the writer.
 	localCompleting bool
 	// localActive is set while the local handler goroutine may still be inside
 	// user code. Resource owners use Wait as a lifetime barrier, so cancellation
@@ -48,14 +48,8 @@ type commonRPC struct {
 	dataClosed bool
 	// remoteErr is an error set by the remote.
 	remoteErr error
-	// remoteCanceled distinguishes a received CallCancel from transport loss.
-	remoteCanceled bool
 	// remoteCompleted is set only by an explicit remote CallData completion.
 	remoteCompleted bool
-	// remoteTerminal is the first valid remote terminal.
-	remoteTerminal TerminalKind
-	// remoteTerminalSet records whether remoteTerminal is valid.
-	remoteTerminalSet bool
 }
 
 // initCommonRPC initializes the commonRPC.
@@ -124,41 +118,6 @@ func (c *commonRPC) Wait(ctx context.Context) error {
 	}
 }
 
-// WaitTerminal waits for and classifies the remote terminal of a held unary
-// invocation.
-func (c *commonRPC) WaitTerminal(ownerCtx context.Context) (TerminalKind, error) {
-	var ownerDone bool
-	for {
-		locked := c.bcast.Lock()
-		if c.remoteTerminalSet {
-			terminal := c.remoteTerminal
-			locked.Unlock()
-			return terminal, nil
-		}
-		if ownerDone {
-			err := ownerCtx.Err()
-			locked.Unlock()
-			return TerminalKind_TERMINAL_KIND_ABANDONED, err
-		}
-		waitCh := locked.WaitCh()
-		locked.Unlock()
-
-		select {
-		case <-ownerCtx.Done():
-			ownerDone = true
-		case <-waitCh:
-		}
-	}
-}
-
-// receiptTerminalKind returns the first valid remote terminal.
-func (c *commonRPC) receiptTerminalKind() (TerminalKind, bool) {
-	locked := c.bcast.Lock()
-	terminal, ok := c.remoteTerminal, c.remoteTerminalSet
-	locked.Unlock()
-	return terminal, ok
-}
-
 // ReadOne reads a single message and returns.
 //
 // returns io.EOF if the stream ended without a packet.
@@ -236,9 +195,6 @@ func (c *commonRPC) HandleStreamClose(closeErr error) {
 // HandleCallCancel handles the call cancel packet.
 func (c *commonRPC) HandleCallCancel() error {
 	locked := c.bcast.Lock()
-	if (!c.dataClosed || !c.writerClosed) && !c.remoteTerminalSet {
-		c.remoteCanceled = true
-	}
 	writer := c.handleStreamCloseLocked(&locked, context.Canceled)
 	locked.Unlock()
 	if writer != nil {
@@ -277,11 +233,7 @@ func (c *commonRPC) HandleCallData(pkt *CallData) error {
 	if complete {
 		c.dataClosed = true
 		if len(pktErr) == 0 {
-			if c.recordRemoteTerminalLocked(TerminalKind_TERMINAL_KIND_COMMITTED) {
-				c.remoteCompleted = true
-			}
-		} else {
-			c.recordRemoteTerminalLocked(TerminalKind_TERMINAL_KIND_TRANSPORT_LOST)
+			c.remoteCompleted = true
 		}
 	}
 
@@ -291,15 +243,6 @@ func (c *commonRPC) HandleCallData(pkt *CallData) error {
 	return err
 }
 
-func (c *commonRPC) recordRemoteTerminalLocked(kind TerminalKind) bool {
-	if c.remoteTerminalSet {
-		return false
-	}
-	c.remoteTerminal = kind
-	c.remoteTerminalSet = true
-	return true
-}
-
 func (c *commonRPC) handleStreamCloseLocked(
 	locked *broadcast.Locked,
 	closeErr error,
@@ -307,19 +250,22 @@ func (c *commonRPC) handleStreamCloseLocked(
 	if c.dataClosed && c.writerClosed {
 		return nil
 	}
+	// A peer that closes its side reports the end of the stream. Transports
+	// disagree on whether they surface that as io.EOF or as no error at all,
+	// and it means the same thing either way, so settle it here rather than in
+	// each transport. It says nothing about whether a completion preceded it.
+	if errors.Is(closeErr, io.EOF) {
+		closeErr = nil
+	}
 	normalRemoteCloseAfterLocalComplete := closeErr == nil && (c.localCompleting || c.localDone)
 	if closeErr != nil && c.remoteErr == nil {
 		c.remoteErr = closeErr
 	}
-	if !normalRemoteCloseAfterLocalComplete && !c.remoteTerminalSet {
-		terminal := TerminalKind_TERMINAL_KIND_CLOSED
-		if closeErr != nil {
-			terminal = TerminalKind_TERMINAL_KIND_TRANSPORT_LOST
-			if c.remoteCanceled {
-				terminal = TerminalKind_TERMINAL_KIND_CANCELED
-			}
-		}
-		c.recordRemoteTerminalLocked(terminal)
+	// A clean close that arrives with no completion behind it leaves the call
+	// without a verdict. Reading io.EOF there says the stream ended in good
+	// order, which is the one thing we do not know.
+	if closeErr == nil && !normalRemoteCloseAfterLocalComplete && !c.remoteCompleted && c.remoteErr == nil {
+		c.remoteErr = ErrClosedBeforeCompletion
 	}
 	c.dataClosed = true
 	if !normalRemoteCloseAfterLocalComplete {

package/srpc/common-rpc.ts

@@ -3,12 +3,7 @@ import type { Sink, Source } from 'it-stream-types'
 import { pushable, type Pushable } from 'it-pushable'
 import { CompleteMessage } from '@aptre/protobuf-es-lite'
 
-import {
-  Packet,
-  TerminalKind,
-  type CallData,
-  type CallStart,
-} from './rpcproto.pb.js'
+import { Packet, type CallData, type CallStart } from './rpcproto.pb.js'
 import { ERR_RPC_ABORT, RemoteRPCError } from './errors.js'
 
 const maxBufferedOutgoingPackets = 1
@@ -39,27 +34,15 @@ export class CommonRPC {
 
   // closed indicates this rpc has been closed already.
   private closed?: true | Error
-  // remoteCompleted is set only by an explicit remote CallData completion.
-  private remoteCompleted = false
   // remoteError records a remote error or transport failure.
   private remoteError?: Error
-  // remoteSourceClosed records an incoming source ending without a packet error.
-  private remoteSourceClosed = false
-  // remoteTerminal is the first valid remote terminal.
-  private remoteTerminal?: TerminalKind
-  // invocationController cancels the server invocation on a remote terminal.
+  // invocationController cancels the server invocation when the RPC closes.
   private readonly invocationController = new AbortController()
-  // terminalPromise resolves when a remote terminal is recorded.
-  private readonly terminalPromise: Promise<void>
-  private resolveTerminal!: () => void
 
   // writeDrainAbort wakes writers waiting for outbound stream drain on close.
   private readonly writeDrainAbort = new AbortController()
 
   constructor() {
-    const { promise, resolve } = Promise.withResolvers<void>()
-    this.terminalPromise = promise
-    this.resolveTerminal = resolve
     this.sink = this._createSink()
     this.source = this._source
     this.rpcDataSource = this._rpcDataSource
@@ -70,57 +53,11 @@ export class CommonRPC {
     return this.closed ?? false
   }
 
-  // invocationSignal is canceled when the RPC reaches a terminal.
+  // invocationSignal is canceled when the RPC closes.
   protected get invocationSignal(): AbortSignal {
     return this.invocationController.signal
   }
 
-  // waitTerminal waits for the remote terminal or external owner cancellation.
-  protected async waitTerminal(
-    ownerSignal: AbortSignal,
-  ): Promise<TerminalKind> {
-    const { promise: ownerDone, resolve: resolveOwnerDone } =
-      Promise.withResolvers<void>()
-    const onAbort = () => resolveOwnerDone()
-    ownerSignal.addEventListener('abort', onAbort, { once: true })
-    let ownerAborted = ownerSignal.aborted
-    try {
-      for (;;) {
-        const terminal = this.getTerminalKind()
-        if (terminal !== undefined) {
-          if (
-            terminal === TerminalKind.CLOSED &&
-            this.remoteSourceClosed &&
-            !this.closed
-          ) {
-            await this.close()
-          }
-          return terminal
-        }
-        if (ownerAborted) {
-          return TerminalKind.ABANDONED
-        }
-        await Promise.race([this.terminalPromise, ownerDone])
-        ownerAborted = ownerSignal.aborted
-      }
-    } finally {
-      ownerSignal.removeEventListener('abort', onAbort)
-    }
-  }
-
-  // getTerminalKind returns the observed remote terminal, if any.
-  public getTerminalKind(): TerminalKind | undefined {
-    return this.remoteTerminal
-  }
-
-  private recordRemoteTerminal(kind: TerminalKind) {
-    if (this.remoteTerminal !== undefined) {
-      return
-    }
-    this.remoteTerminal = kind
-    this.resolveTerminal()
-  }
-
   // writeCallData writes the call data packet.
   public async writeCallData(
     data?: Uint8Array,
@@ -276,20 +213,15 @@ export class CommonRPC {
     if (remoteError) {
       this.remoteError ??= remoteError
       this.invocationController.abort()
-      this.recordRemoteTerminal(TerminalKind.TRANSPORT_LOST)
     }
     if (packet.complete && !remoteError) {
-      this.remoteCompleted = true
-      this.recordRemoteTerminal(TerminalKind.COMMITTED)
       this._rpcDataSource.end(remoteError)
     } else if (remoteError) {
       this._rpcDataSource.end(remoteError)
     }
   }
-
-  // handleCallCancel handles a CallCancel packet.
+  // handleCallCancel aborts the invocation and closes the call.
   public async handleCallCancel() {
-    this.recordRemoteTerminal(TerminalKind.CANCELED)
     await this.close(new Error(ERR_RPC_ABORT))
   }
 
@@ -302,9 +234,6 @@ export class CommonRPC {
     if (!this.remoteError && err) {
       this.remoteError = err
     }
-    this.recordRemoteTerminal(
-      err ? TerminalKind.TRANSPORT_LOST : TerminalKind.CLOSED,
-    )
     this.invocationController.abort()
     // note: this does nothing if _source is already ended.
     if (err && err.message) {
@@ -330,8 +259,6 @@ export class CommonRPC {
             await this.handlePacket(msg)
           }
         }
-        this.remoteSourceClosed = true
-        this.recordRemoteTerminal(TerminalKind.CLOSED)
       } catch (err) {
         this.close(err as Error)
       }

package/srpc/common-rpc_test.go

@@ -3,6 +3,7 @@ package srpc
 import (
 	"bytes"
 	"context"
+	"errors"
 	"io"
 	"sync"
 	"sync/atomic"
@@ -423,3 +424,83 @@ func TestCommonRPCReadOneQueuedDoesNotAllocate(t *testing.T) {
 		t.Fatalf("expected queued ReadOne to avoid allocations, got %f", allocs)
 	}
 }
+
+func TestRemoteCloseWithoutCompletionNamesTheMissingCompletion(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// the transport ends the stream in good order with nothing behind it,
+	// which is what a dropped completion packet looks like from here.
+	rpc.HandleStreamClose(nil)
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("read after a truncated stream reported %v, want the missing completion", err)
+	}
+	if errors.Is(err, io.EOF) {
+		t.Fatalf("read after a truncated stream claims the call ended in good order: %v", err)
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("read after a truncated stream stopped satisfying a cancellation check: %v", err)
+	}
+	if got := err.Error(); got == context.Canceled.Error() {
+		t.Fatalf("read after a truncated stream still claims a cancellation happened: %q", got)
+	}
+	if err := rpc.Wait(context.Background()); !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("wait after a truncated stream reported %v, want the missing completion", err)
+	}
+}
+
+func TestRemoteCloseReportingEOFNamesTheMissingCompletion(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	// rpcstream surfaces the peer's close as io.EOF rather than as no error.
+	rpc.HandleStreamClose(io.EOF)
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("read after an EOF close reported %v, want the missing completion", err)
+	}
+}
+
+func TestRemoteCloseAfterCompletionStillEndsTheStream(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	if err := rpc.HandleCallData(&CallData{Complete: true}); err != nil {
+		t.Fatalf("handle completion: %v", err)
+	}
+	rpc.HandleStreamClose(nil)
+
+	if _, err := rpc.ReadOne(); !errors.Is(err, io.EOF) {
+		t.Fatalf("read after a completed call reported %v, want the end of the stream", err)
+	}
+}
+
+func TestClientRPCCloseReportsALocalCancellation(t *testing.T) {
+	writer := &closeCountingPacketWriter{}
+	rpc := NewClientRPC(context.Background(), "service", "method")
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatalf("start: %v", err)
+	}
+
+	rpc.Close()
+
+	_, err := rpc.ReadOne()
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("read after a local close reported %v, want a cancellation", err)
+	}
+	if errors.Is(err, ErrClosedBeforeCompletion) {
+		t.Fatalf("a close this side performed was blamed on the remote: %v", err)
+	}
+}

package/srpc/errors.go

@@ -1,6 +1,9 @@
 package srpc
 
-import "errors"
+import (
+	"context"
+	"errors"
+)
 
 var (
 	// ErrReset is returned when a stream is reset.
@@ -24,3 +27,25 @@ var (
 	// ErrNilWriter is returned if the rpc writer is nil.
 	ErrNilWriter = errors.New("writer cannot be nil")
 )
+
+// ErrClosedBeforeCompletion is the error a call reports when its stream closed
+// without the remote sending a completion or an error. The call has no verdict:
+// the handler may have finished with its answer lost in the transport, or it may
+// never have run. Anything read from the call after that point fails with this.
+//
+// It unwraps to context.Canceled, which is what this case reported before the
+// distinction existed, so a caller that tests for cancellation keeps working.
+var ErrClosedBeforeCompletion error = closedBeforeCompletion{}
+
+// closedBeforeCompletion carries ErrClosedBeforeCompletion.
+type closedBeforeCompletion struct{}
+
+// Error returns the error message.
+func (closedBeforeCompletion) Error() string {
+	return "stream closed before the remote reported completion"
+}
+
+// Unwrap returns the cancellation this case reported historically.
+func (closedBeforeCompletion) Unwrap() error {
+	return context.Canceled
+}

package/srpc/handler.ts

@@ -1,13 +1,12 @@
 import type { Sink, Source } from 'it-stream-types'
 import { ServiceDefinition, ServiceMethodDefinitions } from './definition.js'
 import { createInvokeFn } from './invoker.js'
-import type { ServerInvocation } from './server-invocation.js'
 
 // InvokeFn describes an SRPC call method invoke function.
 export type InvokeFn = (
   dataSource: Source<Uint8Array>,
   dataSink: Sink<Source<Uint8Array>>,
-  invocation?: ServerInvocation,
+  invocation?: AbortSignal,
 ) => Promise<void>
 
 // Handler describes a SRPC call handler implementation.

package/srpc/index.ts

@@ -6,10 +6,6 @@ export {
   castToError,
 } from './errors.js'
 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 { TerminalKind } from './rpcproto.pb.js'
 export { Server } from './server.js'
 export { StreamConn } from './conn.js'
 export type { StreamConnParams, StreamHandler } from './conn.js'

package/srpc/invoker-prefix.go

@@ -37,4 +37,4 @@ func (i *PrefixInvoker) InvokeMethod(serviceID, methodID string, strm Stream) (b
 }
 
 // _ is a type assertion
-var _ Invoker = ((*PrefixInvoker)(nil))
+var _ Invoker = (*PrefixInvoker)(nil)

package/srpc/invoker.go

@@ -37,7 +37,7 @@ func (s InvokerSlice) InvokeMethod(serviceID, methodID string, strm Stream) (boo
 }
 
 // _ is a type assertion
-var _ Invoker = (InvokerSlice)(nil)
+var _ Invoker = InvokerSlice(nil)
 
 // InvokerFunc is a function implementing InvokeMethod.
 type InvokerFunc func(serviceID, methodID string, strm Stream) (bool, error)
@@ -52,4 +52,4 @@ func (f InvokerFunc) InvokeMethod(serviceID, methodID string, strm Stream) (bool
 	return f(serviceID, methodID, strm)
 }
 
-var _ Invoker = (InvokerFunc)(nil)
+var _ Invoker = InvokerFunc(nil)

package/srpc/invoker.ts

@@ -11,16 +11,12 @@ import { writeToPushable } from './pushable.js'
 import type { MessageType, Message } from '@aptre/protobuf-es-lite'
 import { MethodIdempotency, MethodKind } from '@aptre/protobuf-es-lite'
 
-import type { ServerInvocation } from './server-invocation.js'
 // MethodProto is a function which matches one of the RPC signatures.
 export type MethodProto<R extends Message<R>, O extends Message<O>> =
-  | ((request: R, invocation?: ServerInvocation) => Promise<O>)
-  | ((request: R, invocation?: ServerInvocation) => AsyncIterable<O>)
-  | ((request: AsyncIterable<R>, invocation?: ServerInvocation) => Promise<O>)
-  | ((
-      request: AsyncIterable<R>,
-      invocation?: ServerInvocation,
-    ) => AsyncIterable<O>)
+  | ((request: R, invocation?: AbortSignal) => Promise<O>)
+  | ((request: R, invocation?: AbortSignal) => AsyncIterable<O>)
+  | ((request: AsyncIterable<R>, invocation?: AbortSignal) => Promise<O>)
+  | ((request: AsyncIterable<R>, invocation?: AbortSignal) => AsyncIterable<O>)
 
 // createInvokeFn builds an InvokeFn from a method definition and a function prototype.
 export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
@@ -36,7 +32,7 @@ export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
   return async (
     dataSource: Source<Uint8Array>,
     dataSink: Sink<Source<Uint8Array>>,
-    invocation?: ServerInvocation,
+    invocation?: AbortSignal,
   ) => {
     // responseSink is a Sink for response messages.
     const responseSink = pushable<O>({

package/srpc/message.go

@@ -86,4 +86,4 @@ func (m *RawMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 }
 
 // _ is a type assertion
-var _ Message = ((*RawMessage)(nil))
+var _ Message = (*RawMessage)(nil)

package/srpc/msg-stream.go

@@ -86,13 +86,5 @@ func (r *MsgStream) Close() error {
 	return err
 }
 
-func (r *MsgStream) receiptTerminalKind() (TerminalKind, bool) {
-	receipt, ok := r.rw.(receiptTerminalStream)
-	if !ok {
-		return 0, false
-	}
-	return receipt.receiptTerminalKind()
-}
-
 // _ is a type assertion
-var _ Stream = ((*MsgStream)(nil))
+var _ Stream = (*MsgStream)(nil)

package/srpc/mux-verbose.go

@@ -93,4 +93,4 @@ func (v *VMux) HasServiceMethod(serviceID, methodID string) (has bool) {
 }
 
 // _ is a type assertion
-var _ Mux = ((*VMux)(nil))
+var _ Mux = (*VMux)(nil)

package/srpc/mux.go

@@ -134,4 +134,4 @@ func (m *mux) InvokeMethod(serviceID, methodID string, strm Stream) (bool, error
 }
 
 // _ is a type assertion
-var _ Mux = ((*mux)(nil))
+var _ Mux = (*mux)(nil)

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 const ::_pb::EnumDescriptor* PROTOBUF_NONNULL
-    file_level_enum_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto[1];
+static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
+    file_level_enum_descriptors_github_2ecom_2faperturerobotics_2fstarpc_2fsrpc_2frpcproto_2eproto = nullptr;
 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,18 +178,13 @@ 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(\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"
+    "\010complete\030\003 \001(\010\022\r\n\005error\030\004 \001(\tb\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,
-    552,
+    358,
     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,
@@ -203,12 +198,6 @@ 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 {