starpc 0.50.0 → 0.52.0

package/srpc/rpcproto.pb.h

@@ -30,7 +30,6 @@
 #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)
 
@@ -56,8 +55,6 @@ 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_;
@@ -73,53 +70,10 @@ 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);
-}
 
 // ===================================================================
 
@@ -1490,19 +1444,6 @@ 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,49 +59,4 @@ 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,7 +2,6 @@
 // @generated from file github.com/aperturerobotics/starpc/srpc/rpcproto.proto (package srpc, syntax proto3)
 /* eslint-disable */
 
-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'
@@ -10,67 +9,6 @@ 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.
  *

package/srpc/rpcproto.proto

@@ -1,22 +1,6 @@
 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/server-context.ts

@@ -0,0 +1,55 @@
+declare const contextKeyValue: unique symbol
+const contextParent = Symbol('server context parent')
+const contextKey = Symbol('server context key')
+const contextStoredValue = Symbol('server context value')
+
+// ContextKey identifies one typed server-context value.
+export interface ContextKey<T> {
+  readonly [contextKeyValue]?: T
+}
+
+// ServerContext carries cancellation for one server invocation.
+export interface ServerContext {
+  readonly signal: AbortSignal
+}
+
+type StoredServerContext = ServerContext & {
+  readonly [contextParent]?: ServerContext
+  readonly [contextKey]?: ContextKey<unknown>
+  readonly [contextStoredValue]?: unknown
+}
+
+// createContextKey constructs an identity key for one server-context value.
+export function createContextKey<T>(): ContextKey<T> {
+  return {}
+}
+
+// withServerContextValue derives a context with one immutable typed value.
+export function withServerContextValue<T>(
+  context: ServerContext,
+  key: ContextKey<T>,
+  value: T,
+): ServerContext {
+  const derived: StoredServerContext = {
+    signal: context.signal,
+    [contextParent]: context,
+    [contextKey]: key as ContextKey<unknown>,
+    [contextStoredValue]: value,
+  }
+  return derived
+}
+
+// serverContextValue retrieves the nearest value for a typed identity key.
+export function serverContextValue<T>(
+  context: ServerContext,
+  key: ContextKey<T>,
+): T | undefined {
+  let current: StoredServerContext | undefined = context as StoredServerContext
+  while (current) {
+    if (current[contextKey] === key) {
+      return current[contextStoredValue] as T
+    }
+    current = current[contextParent] as StoredServerContext | undefined
+  }
+  return undefined
+}

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(withServerInvocation(r.ctx, r), r, r.cancelContext)
+	strm := NewMsgStream(r.ctx, r, r.cancelContext)
 	ok, err := r.invoker.InvokeMethod(serviceID, methodID, strm)
 	if err == nil && !ok {
 		err = ErrUnimplemented

package/srpc/server-rpc.ts

@@ -3,8 +3,8 @@ import type { Sink, Source } from 'it-stream-types'
 import type { CallData, CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 import { InvokeFn } from './handler.js'
-import { ServerInvocation } from './server-invocation.js'
 import { LookupMethod } from './mux.js'
+import type { ServerContext } from './server-context.js'
 
 // ServerRPC is an ongoing RPC from the server side.
 export class ServerRPC extends CommonRPC {
@@ -47,12 +47,10 @@ export class ServerRPC extends CommonRPC {
   // invokeRPC starts invoking the RPC handler.
   private async invokeRPC(invokeFn: InvokeFn) {
     const dataSink = this._createDataSink()
-    const invocation = new ServerInvocation(
-      this.invocationSignal,
-      (ownerSignal) => this.waitTerminal(ownerSignal),
-    )
     try {
-      await invokeFn(this.rpcDataSource, dataSink, invocation)
+      await invokeFn(this.rpcDataSource, dataSink, {
+        signal: this.invocationSignal,
+      } satisfies ServerContext)
     } catch (err) {
       this.close(err as Error)
     }

package/srpc/server.test.ts

@@ -10,18 +10,23 @@ import {
   combineUint8ArrayListTransform,
   ChannelStreamOpts,
   Packet,
+  createContextKey,
+  serverContextValue,
+  withServerContextValue,
+  type ServerContext,
 } from '../srpc/index.js'
 import {
   EchoerDefinition,
   EchoerServer,
   EchoerServiceName,
+  EchoMsg,
   runClientTest,
 } from '../echo/index.js'
 import {
   runAbortControllerTest,
   runRpcStreamTest,
 } from '../echo/client-test.js'
-
+import type { EchoMsg as EchoMsgType } from '../echo/echo.pb.js'
 describe('srpc server', () => {
   let client: Client
 
@@ -77,6 +82,78 @@ describe('srpc server', () => {
   it('should pass rpc stream tests', async () => {
     await runRpcStreamTest(client)
   })
+  it('passes the exact invocation context after async request decode', async () => {
+    const controller = new AbortController()
+    const callerKey = createContextKey<string>()
+    let observedAbortSignal: AbortSignal | undefined
+    let observedContextSignal: AbortSignal | undefined
+    let observedCaller: string | undefined
+    const handler = createHandler(EchoerDefinition, {
+      Echo: async (
+        request: EchoMsgType,
+        abortSignal: AbortSignal,
+        context: ServerContext,
+      ) => {
+        observedAbortSignal = abortSignal
+        observedContextSignal = context.signal
+        observedCaller = serverContextValue(context, callerKey)
+        return request
+      },
+    })
+    const invokeFn = await handler.lookupMethod(EchoerServiceName, 'Echo')
+    if (!invokeFn) {
+      throw new Error('Echo method was not found')
+    }
+    const request = EchoMsg.create({ body: 'signal identity' })
+    const drained = Promise.withResolvers<void>()
+    await invokeFn(
+      (async function* () {
+        await Promise.resolve()
+        yield EchoMsg.toBinary(request)
+      })(),
+      async (source) => {
+        for await (const _data of source) {
+          // Drain the encoded response so the invocation pipeline completes.
+        }
+        drained.resolve()
+      },
+      withServerContextValue(
+        { signal: controller.signal },
+        callerKey,
+        'caller-1',
+      ),
+    )
+    await drained.promise
+    expect(observedAbortSignal).toBe(controller.signal)
+    expect(observedContextSignal).toBe(controller.signal)
+    expect(observedCaller).toBe('caller-1')
+  })
+
+  it('keeps two-argument server handlers compatible', async () => {
+    const controller = new AbortController()
+    let observedSignal: AbortSignal | undefined
+    const handler = createHandler(EchoerDefinition, {
+      Echo: async (request: EchoMsgType, abortSignal?: AbortSignal) => {
+        observedSignal = abortSignal
+        return request
+      },
+    })
+    const invokeFn = await handler.lookupMethod(EchoerServiceName, 'Echo')
+    if (!invokeFn) throw new Error('Echo method was not found')
+    const request = EchoMsg.create({ body: 'legacy handler' })
+    await invokeFn(
+      (async function* () {
+        yield EchoMsg.toBinary(request)
+      })(),
+      async (source) => {
+        for await (const _data of source) {
+          // Drain the response.
+        }
+      },
+      { signal: controller.signal },
+    )
+    expect(observedSignal).toBe(controller.signal)
+  })
 
   it('keeps detached server-streaming responses open after request source completes', async () => {
     const mux = createMux()
@@ -249,6 +326,22 @@ describe('srpc server', () => {
     )
   })
 
+  it('settles a late abort after the call has already closed', async () => {
+    const controller = new AbortController()
+    vi.spyOn(controller.signal, 'removeEventListener').mockImplementation(
+      () => undefined,
+    )
+
+    await client.request(
+      EchoerServiceName,
+      'Echo',
+      new TextEncoder().encode('late abort'),
+      controller.signal,
+    )
+    controller.abort()
+    await Promise.resolve()
+  })
+
   it('tears down passive channel close state', async () => {
     const { port1, port2 } = new MessageChannel()
     const opts: ChannelStreamOpts = { idleTimeoutMs: 1000, keepAliveMs: 1000 }

package/srpc/stream-pipe.go

@@ -85,4 +85,4 @@ func (p *pipeStream) closeRemote() {
 }
 
 // _ is a type assertion
-var _ Stream = ((*pipeStream)(nil))
+var _ Stream = (*pipeStream)(nil)

package/srpc/stream-rwc.go

@@ -82,4 +82,4 @@ func (s *StreamRwc) Write(p []byte) (n int, err error) {
 }
 
 // _ is a type assertion
-var _ io.ReadWriteCloser = ((*StreamRwc)(nil))
+var _ io.ReadWriteCloser = (*StreamRwc)(nil)

package/srpc/stream.go

@@ -23,10 +23,6 @@ type Stream interface {
 	Close() error
 }
 
-type receiptTerminalStream interface {
-	receiptTerminalKind() (TerminalKind, bool)
-}
-
 // StreamRecv is a stream that can receive typed messages.
 //
 // T is the response type.
@@ -73,14 +69,6 @@ func (s *streamWithClose) Close() error {
 	return err2
 }
 
-func (s *streamWithClose) receiptTerminalKind() (TerminalKind, bool) {
-	receipt, ok := s.Stream.(receiptTerminalStream)
-	if !ok {
-		return 0, false
-	}
-	return receipt.receiptTerminalKind()
-}
-
 // streamWithContext is a Stream with a wrapped Context function.
 type streamWithContext struct {
 	Stream
@@ -97,14 +85,6 @@ func (s *streamWithContext) Context() context.Context {
 	return s.ctx
 }
 
-func (s *streamWithContext) receiptTerminalKind() (TerminalKind, bool) {
-	receipt, ok := s.Stream.(receiptTerminalStream)
-	if !ok {
-		return 0, false
-	}
-	return receipt.receiptTerminalKind()
-}
-
 // _ is a type assertion
 var (
 	_ Stream = (*streamWithClose)(nil)

package/srpc/watchdog.test.ts

@@ -7,6 +7,7 @@ describe('Watchdog', () => {
   })
 
   afterEach(() => {
+    vi.useRealTimers()
     vi.restoreAllMocks()
   })
 

package/dist/rpcstream/receipt.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/rpcstream/receipt.test.js

@@ -1,41 +0,0 @@
-/// <reference lib="es2024.promise" />
-import { describe, expect, it } from 'vitest';
-import { Client } from '../srpc/client.js';
-import { Server } from '../srpc/server.js';
-import { TerminalKind } from '../srpc/rpcproto.pb.js';
-import { buildRpcStreamOpenStream, handleRpcStream } from './rpcstream.js';
-const response = new Uint8Array([4, 5, 6]);
-// This guard mirrors the Go rpcstream/receipt_test.go nested tunnel: an
-// ExecCallReceipt-equivalent held unary call runs through a real handleRpcStream
-// tunnel. The inner generated handler sends its single response, then the
-// wrapping invocation synchronously holds on waitTerminal. The first response
-// must be client-visible while the exact invocation stays open for commit.
-describe('rpcstream held receipt tunnel', () => {
-    it('delivers the first inner response while the invocation stays held', async () => {
-        const terminal = Promise.withResolvers();
-        const innerServer = new Server(async () => {
-            return async (_source, dataSink, invocation) => {
-                await dataSink((async function* () {
-                    yield response;
-                    if (!invocation) {
-                        throw new Error('missing invocation');
-                    }
-                    terminal.resolve(await invocation.waitTerminal(new AbortController().signal));
-                })());
-            };
-        });
-        const caller = (packetTx) => handleRpcStream(packetTx[Symbol.asyncIterator](), async () => innerServer.rpcStreamHandler);
-        const client = new Client(buildRpcStreamOpenStream('component-a', caller));
-        const held = await client.requestWithReceipt('test.Service', 'Unary', response);
-        // The first inner response is client-visible while the invocation is held.
-        expect(held.response).toEqual(response);
-        // The inner invocation must still be open: no terminal observed yet.
-        const raced = await Promise.race([
-            terminal.promise.then(() => 'terminal'),
-            Promise.resolve('pending'),
-        ]);
-        expect(raced).toBe('pending');
-        await expect(held.receipt.commit()).resolves.toBeUndefined();
-        await expect(terminal.promise).resolves.toBe(TerminalKind.COMMITTED);
-    });
-});

package/dist/srpc/call-receipt.d.ts

@@ -1,17 +0,0 @@
-import { ClientRPC } from './client-rpc.js';
-export interface ReceiptRpc {
-    requestWithReceipt(service: string, method: string, data: Uint8Array, abortSignal?: AbortSignal): Promise<HeldCall>;
-}
-export interface HeldCall {
-    readonly response: Uint8Array;
-    readonly receipt: CallReceipt;
-}
-export declare class CallReceipt {
-    #private;
-    constructor(call: ClientRPC, iterator: AsyncIterator<Uint8Array>);
-    get done(): Promise<void>;
-    get settled(): boolean;
-    commit(): Promise<void>;
-    abort(reason?: Error): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-}