starpc 0.49.18 → 0.50.0

package/srpc/rpcproto.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-lite. DO NOT EDIT.
-// protoc-gen-go-lite version: v0.12.1
+// protoc-gen-go-lite version: v0.13.0
 // source: github.com/aperturerobotics/starpc/srpc/rpcproto.proto
 
 package srpc
@@ -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)

package/srpc/rpcproto.pb.ts

@@ -2,11 +2,75 @@
 // @generated from file github.com/aperturerobotics/starpc/srpc/rpcproto.proto (package srpc, syntax proto3)
 /* eslint-disable */
 
-import type { MessageType, PartialFieldInfo } from '@aptre/protobuf-es-lite'
-import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite'
+import { createEnumType } from '@aptre/protobuf-es-lite/enum'
+import type { MessageType } from '@aptre/protobuf-es-lite/message'
+import { createMessageType } from '@aptre/protobuf-es-lite/message'
+import { ScalarType } from '@aptre/protobuf-es-lite/scalar'
+import type { PartialFieldInfo } from '@aptre/protobuf-es-lite/field'
 
 export const protobufPackage = 'srpc'
 
+/**
+ * TerminalKind is the terminal state of a held unary invocation.
+ *
+ * @generated from enum srpc.TerminalKind
+ */
+export enum TerminalKind {
+  /**
+   * TERMINAL_KIND_UNSPECIFIED is not a valid terminal state.
+   *
+   * @generated from enum value: TERMINAL_KIND_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * TERMINAL_KIND_COMMITTED identifies an explicit remote CallData completion.
+   *
+   * @generated from enum value: TERMINAL_KIND_COMMITTED = 1;
+   */
+  COMMITTED = 1,
+
+  /**
+   * TERMINAL_KIND_CANCELED identifies a remote CallCancel packet.
+   *
+   * @generated from enum value: TERMINAL_KIND_CANCELED = 2;
+   */
+  CANCELED = 2,
+
+  /**
+   * TERMINAL_KIND_TRANSPORT_LOST identifies a remote error or transport failure.
+   *
+   * @generated from enum value: TERMINAL_KIND_TRANSPORT_LOST = 3;
+   */
+  TRANSPORT_LOST = 3,
+
+  /**
+   * TERMINAL_KIND_CLOSED identifies a bare remote close without completion.
+   *
+   * @generated from enum value: TERMINAL_KIND_CLOSED = 4;
+   */
+  CLOSED = 4,
+
+  /**
+   * TERMINAL_KIND_ABANDONED identifies owner-context expiry without a remote terminal.
+   *
+   * @generated from enum value: TERMINAL_KIND_ABANDONED = 5;
+   */
+  ABANDONED = 5,
+}
+
+export const TerminalKind_Enum = /* @__PURE__ */ createEnumType(
+  'srpc.TerminalKind',
+  [
+    [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'],
+  ],
+)
+
 /**
  * CallStart requests starting a new RPC call.
  *
@@ -42,17 +106,17 @@ export interface CallStart {
   dataIsZero?: boolean
 }
 
-// CallStart contains the message type declaration for CallStart.
-export const CallStart: MessageType<CallStart> = createMessageType({
-  typeName: 'srpc.CallStart',
-  fields: [
-    { no: 1, name: 'rpc_service', kind: 'scalar', T: ScalarType.STRING },
-    { no: 2, name: 'rpc_method', kind: 'scalar', T: ScalarType.STRING },
-    { no: 3, name: 'data', kind: 'scalar', T: ScalarType.BYTES },
-    { no: 4, name: 'data_is_zero', kind: 'scalar', T: ScalarType.BOOL },
-  ] as readonly PartialFieldInfo[],
-  packedByDefault: true,
-})
+export const CallStart: MessageType<CallStart> =
+  /* @__PURE__ */ createMessageType({
+    typeName: 'srpc.CallStart',
+    fields: [
+      { no: 1, name: 'rpc_service', kind: 'scalar', T: ScalarType.STRING },
+      { no: 2, name: 'rpc_method', kind: 'scalar', T: ScalarType.STRING },
+      { no: 3, name: 'data', kind: 'scalar', T: ScalarType.BYTES },
+      { no: 4, name: 'data_is_zero', kind: 'scalar', T: ScalarType.BOOL },
+    ] satisfies readonly PartialFieldInfo[],
+    packedByDefault: true,
+  })
 
 /**
  * CallData contains a message in a streaming RPC sequence.
@@ -87,17 +151,17 @@ export interface CallData {
   error?: string
 }
 
-// CallData contains the message type declaration for CallData.
-export const CallData: MessageType<CallData> = createMessageType({
-  typeName: 'srpc.CallData',
-  fields: [
-    { no: 1, name: 'data', kind: 'scalar', T: ScalarType.BYTES },
-    { no: 2, name: 'data_is_zero', kind: 'scalar', T: ScalarType.BOOL },
-    { no: 3, name: 'complete', kind: 'scalar', T: ScalarType.BOOL },
-    { no: 4, name: 'error', kind: 'scalar', T: ScalarType.STRING },
-  ] as readonly PartialFieldInfo[],
-  packedByDefault: true,
-})
+export const CallData: MessageType<CallData> =
+  /* @__PURE__ */ createMessageType({
+    typeName: 'srpc.CallData',
+    fields: [
+      { no: 1, name: 'data', kind: 'scalar', T: ScalarType.BYTES },
+      { no: 2, name: 'data_is_zero', kind: 'scalar', T: ScalarType.BOOL },
+      { no: 3, name: 'complete', kind: 'scalar', T: ScalarType.BOOL },
+      { no: 4, name: 'error', kind: 'scalar', T: ScalarType.STRING },
+    ] satisfies readonly PartialFieldInfo[],
+    packedByDefault: true,
+  })
 
 /**
  * Packet is a message sent over a srpc packet connection.
@@ -144,8 +208,7 @@ export interface Packet {
       }
 }
 
-// Packet contains the message type declaration for Packet.
-export const Packet: MessageType<Packet> = createMessageType({
+export const Packet: MessageType<Packet> = /* @__PURE__ */ createMessageType({
   typeName: 'srpc.Packet',
   fields: [
     {
@@ -169,6 +232,6 @@ export const Packet: MessageType<Packet> = createMessageType({
       T: ScalarType.BOOL,
       oneof: 'body',
     },
-  ] as readonly PartialFieldInfo[],
+  ] satisfies readonly PartialFieldInfo[],
   packedByDefault: true,
 })

package/srpc/rpcproto.proto

@@ -1,6 +1,22 @@
 syntax = "proto3";
 package srpc;
 
+// TerminalKind is the terminal state of a held unary invocation.
+enum TerminalKind {
+  // TERMINAL_KIND_UNSPECIFIED is not a valid terminal state.
+  TERMINAL_KIND_UNSPECIFIED = 0;
+  // TERMINAL_KIND_COMMITTED identifies an explicit remote CallData completion.
+  TERMINAL_KIND_COMMITTED = 1;
+  // TERMINAL_KIND_CANCELED identifies a remote CallCancel packet.
+  TERMINAL_KIND_CANCELED = 2;
+  // TERMINAL_KIND_TRANSPORT_LOST identifies a remote error or transport failure.
+  TERMINAL_KIND_TRANSPORT_LOST = 3;
+  // TERMINAL_KIND_CLOSED identifies a bare remote close without completion.
+  TERMINAL_KIND_CLOSED = 4;
+  // TERMINAL_KIND_ABANDONED identifies owner-context expiry without a remote terminal.
+  TERMINAL_KIND_ABANDONED = 5;
+}
+
 // Packet is a message sent over a srpc packet connection.
 message Packet {
   // Body is the packet body.

package/srpc/schema-ownership_test.go

@@ -0,0 +1,115 @@
+package srpc
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+// handwrittenTerminalConst names the parallel iota constants the receipt
+// post-mortem removed. Their reappearance signals a second handwritten owner of
+// the cross-language terminal vocabulary.
+var handwrittenTerminalConst = map[string]bool{
+	"TerminalCommitted": true,
+	"TerminalCanceled":  true,
+	"TerminalLost":      true,
+	"TerminalClosed":    true,
+	"TerminalAbandoned": true,
+}
+
+// handwrittenTerminalKindOwners returns the source files that declare the shared
+// TerminalKind vocabulary by hand instead of consuming the generated rpcproto
+// owner. The cross-language terminal noun has exactly one schema owner; a
+// handwritten type or iota constant reintroduces the parallel owner.
+func handwrittenTerminalKindOwners(t *testing.T, files map[string]string) []string {
+	t.Helper()
+	var owners []string
+	for name, src := range files {
+		fset := token.NewFileSet()
+		file, err := parser.ParseFile(fset, name, src, 0)
+		if err != nil {
+			t.Fatalf("parse %s: %v", name, err)
+		}
+		if declaresTerminalKindByHand(file) {
+			owners = append(owners, name)
+		}
+	}
+	return owners
+}
+
+// declaresTerminalKindByHand reports whether a file declares the TerminalKind
+// type or one of its removed iota constants.
+func declaresTerminalKindByHand(file *ast.File) bool {
+	for _, decl := range file.Decls {
+		gen, ok := decl.(*ast.GenDecl)
+		if !ok {
+			continue
+		}
+		for _, spec := range gen.Specs {
+			switch s := spec.(type) {
+			case *ast.TypeSpec:
+				if s.Name.Name == "TerminalKind" {
+					return true
+				}
+			case *ast.ValueSpec:
+				for _, id := range s.Names {
+					if handwrittenTerminalConst[id.Name] {
+						return true
+					}
+				}
+			}
+		}
+	}
+	return false
+}
+
+// packageSourceFiles reads the non-generated, non-test Go sources of the current
+// package directory.
+func packageSourceFiles(t *testing.T) map[string]string {
+	t.Helper()
+	entries, err := os.ReadDir(".")
+	if err != nil {
+		t.Fatalf("read package dir: %v", err)
+	}
+	files := map[string]string{}
+	for _, entry := range entries {
+		name := entry.Name()
+		if !strings.HasSuffix(name, ".go") {
+			continue
+		}
+		if strings.HasSuffix(name, ".pb.go") || strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		data, err := os.ReadFile(name)
+		if err != nil {
+			t.Fatalf("read %s: %v", name, err)
+		}
+		files[name] = string(data)
+	}
+	return files
+}
+
+// TestTerminalKindHasSingleSchemaOwner proves no handwritten srpc source owns
+// the cross-language TerminalKind vocabulary alongside the generated owner.
+func TestTerminalKindHasSingleSchemaOwner(t *testing.T) {
+	owners := handwrittenTerminalKindOwners(t, packageSourceFiles(t))
+	if len(owners) != 0 {
+		t.Fatalf("TerminalKind must come from generated rpcproto; handwritten owners: %v", owners)
+	}
+}
+
+// TestTerminalKindGuardDetectsHandwrittenOwner proves the guard fires when a
+// parallel handwritten TerminalKind owner regresses into the package.
+func TestTerminalKindGuardDetectsHandwrittenOwner(t *testing.T) {
+	bad := map[string]string{
+		"server-invocation.go": "package srpc\n\n" +
+			"type TerminalKind int\n\n" +
+			"const (\n\tTerminalCommitted TerminalKind = iota\n)\n",
+	}
+	if owners := handwrittenTerminalKindOwners(t, bad); len(owners) == 0 {
+		t.Fatal("guard failed to flag a handwritten TerminalKind owner")
+	}
+}

package/srpc/server-invocation.go

@@ -0,0 +1,40 @@
+package srpc
+
+import "context"
+
+// ServerInvocation exposes the terminal of a held unary server invocation.
+type ServerInvocation interface {
+	// WaitTerminal waits for a remote terminal or owner-context expiry. The
+	// owner context must outlive the invocation context.
+	WaitTerminal(ownerCtx context.Context) (TerminalKind, error)
+	// Done returns the invocation context cancellation channel for diagnostics.
+	Done() <-chan struct{}
+}
+
+type serverInvocationKey struct{}
+
+func withServerInvocation(ctx context.Context, invocation ServerInvocation) context.Context {
+	return context.WithValue(ctx, serverInvocationKey{}, invocation)
+}
+
+// GetServerInvocation returns the held unary invocation attached to a context.
+func GetServerInvocation(ctx context.Context) (ServerInvocation, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	invocation, ok := ctx.Value(serverInvocationKey{}).(ServerInvocation)
+	return invocation, ok
+}
+
+// WaitTerminal waits for and classifies the terminal of a held unary invocation.
+func (r *ServerRPC) WaitTerminal(ownerCtx context.Context) (TerminalKind, error) {
+	return r.commonRPC.WaitTerminal(ownerCtx)
+}
+
+// Done returns the invocation context cancellation channel for diagnostics.
+func (r *ServerRPC) Done() <-chan struct{} {
+	return r.ctx.Done()
+}
+
+// _ is a type assertion.
+var _ ServerInvocation = (*ServerRPC)(nil)

package/srpc/server-invocation.ts

@@ -0,0 +1,76 @@
+import type { TerminalKind } from './rpcproto.pb.js'
+
+// ServerInvocation exposes the invocation signal and terminal wait.
+export class ServerInvocation implements AbortSignal {
+  public constructor(
+    public readonly signal: AbortSignal,
+    private readonly waitFn: (
+      ownerSignal: AbortSignal,
+    ) => Promise<TerminalKind>,
+  ) {}
+
+  public get aborted(): boolean {
+    return this.signal.aborted
+  }
+
+  public get onabort() {
+    return this.signal.onabort
+  }
+
+  public set onabort(value: typeof this.signal.onabort) {
+    this.signal.onabort = value
+  }
+
+  public get reason() {
+    return this.signal.reason
+  }
+
+  public throwIfAborted(): void {
+    this.signal.throwIfAborted()
+  }
+
+  public addEventListener<K extends keyof AbortSignalEventMap>(
+    type: K,
+    listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => unknown,
+    options?: boolean | AddEventListenerOptions,
+  ): void
+  public addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions,
+  ): void
+  public addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions,
+  ): void {
+    this.signal.addEventListener(type, listener, options)
+  }
+
+  public removeEventListener<K extends keyof AbortSignalEventMap>(
+    type: K,
+    listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => unknown,
+    options?: boolean | EventListenerOptions,
+  ): void
+  public removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions,
+  ): void
+  public removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions,
+  ): void {
+    this.signal.removeEventListener(type, listener, options)
+  }
+
+  public dispatchEvent(event: Event): boolean {
+    return this.signal.dispatchEvent(event)
+  }
+
+  // waitTerminal waits for a remote terminal or owner-signal cancellation.
+  public waitTerminal(ownerSignal: AbortSignal): Promise<TerminalKind> {
+    return this.waitFn(ownerSignal)
+  }
+}

package/srpc/server-rpc.go

@@ -98,7 +98,7 @@ func (r *ServerRPC) HandleCallStart(pkt *CallStart) error {
 // invokeRPC invokes the RPC after CallStart is received.
 func (r *ServerRPC) invokeRPC(serviceID, methodID string) {
 	// on the server side, the writer is closed by invokeRPC.
-	strm := NewMsgStream(r.ctx, r, r.cancelContext)
+	strm := NewMsgStream(withServerInvocation(r.ctx, r), r, r.cancelContext)
 	ok, err := r.invoker.InvokeMethod(serviceID, methodID, strm)
 	if err == nil && !ok {
 		err = ErrUnimplemented