starpc 0.51.0 → 0.52.1

package/srpc/invoker.ts

@@ -2,6 +2,7 @@ import { Sink, Source } from 'it-stream-types'
 import { pushable } from 'it-pushable'
 import { pipe } from 'it-pipe'
 import type { MethodDefinition } from './definition.js'
+import type { ServerContext } from './server-context.js'
 import { InvokeFn } from './handler.js'
 import {
   buildDecodeMessageTransform,
@@ -13,10 +14,26 @@ import { MethodIdempotency, MethodKind } from '@aptre/protobuf-es-lite'
 
 // 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?: AbortSignal) => Promise<O>)
-  | ((request: R, invocation?: AbortSignal) => AsyncIterable<O>)
-  | ((request: AsyncIterable<R>, invocation?: AbortSignal) => Promise<O>)
-  | ((request: AsyncIterable<R>, invocation?: AbortSignal) => AsyncIterable<O>)
+  | ((
+      request: R,
+      abortSignal: AbortSignal,
+      context: ServerContext,
+    ) => Promise<O>)
+  | ((
+      request: R,
+      abortSignal: AbortSignal,
+      context: ServerContext,
+    ) => AsyncIterable<O>)
+  | ((
+      request: AsyncIterable<R>,
+      abortSignal: AbortSignal,
+      context: ServerContext,
+    ) => Promise<O>)
+  | ((
+      request: AsyncIterable<R>,
+      abortSignal: AbortSignal,
+      context: ServerContext,
+    ) => 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>>(
@@ -32,7 +49,7 @@ export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
   return async (
     dataSource: Source<Uint8Array>,
     dataSink: Sink<Source<Uint8Array>>,
-    invocation?: AbortSignal,
+    context: ServerContext,
   ) => {
     // responseSink is a Sink for response messages.
     const responseSink = pushable<O>({
@@ -67,7 +84,7 @@ export function createInvokeFn<R extends Message<R>, O extends Message<O>>(
 
     // Call the implementation.
     try {
-      const responseObj = methodProto(requestArg, invocation)
+      const responseObj = methodProto(requestArg, context.signal, context)
       if (!responseObj) {
         throw new Error('return value was undefined')
       }

package/srpc/packet-codec-vectors_test.go

@@ -0,0 +1,195 @@
+package srpc
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"testing"
+)
+
+type packetCodecVector struct {
+	Name      string `json:"name"`
+	PacketHex string `json:"packet_hex"`
+	FrameHex  string `json:"frame_hex"`
+}
+
+func TestPacketCodecGoldenVectors(t *testing.T) {
+	data, err := os.ReadFile("../testdata/packet-codec-vectors.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var document struct {
+		Cases []packetCodecVector `json:"cases"`
+	}
+	if err := json.Unmarshal(data, &document); err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range document.Cases {
+		if tc.PacketHex == "" || tc.FrameHex == "" {
+			continue
+		}
+		t.Run(tc.Name, func(t *testing.T) {
+			packet := goldenPacket(t, tc.Name)
+			packetData, err := packet.MarshalVT()
+			if err != nil {
+				t.Fatal(err)
+			}
+			if want := decodeHex(t, tc.PacketHex); !bytes.Equal(packetData, want) {
+				t.Fatalf("packet = %x, want %x", packetData, want)
+			}
+			stream := &packetTestStream{}
+			if err := NewPacketReadWriter(stream).WritePacket(packet); err != nil {
+				t.Fatal(err)
+			}
+			if want := decodeHex(t, tc.FrameHex); !bytes.Equal(stream.writes, want) {
+				t.Fatalf("frame = %x, want %x", stream.writes, want)
+			}
+		})
+	}
+}
+
+func goldenPacket(t *testing.T, name string) *Packet {
+	t.Helper()
+	switch name {
+	case "call_start_data":
+		return NewCallStartPacket("svc", "method", []byte("abc"), false)
+	case "call_start_absent_empty":
+		return NewCallStartPacket("svc", "method", nil, false)
+	case "call_start_present_empty":
+		return NewCallStartPacket("svc", "method", nil, true)
+	case "call_data_terminal":
+		return NewCallDataPacket([]byte("out"), false, true, nil)
+	case "call_data_error":
+		return NewCallDataPacket(nil, false, false, errors.New("failed"))
+	case "call_cancel":
+		return NewCallCancelPacket()
+	default:
+		t.Fatalf("unknown golden packet %q", name)
+		return nil
+	}
+}
+
+func decodeHex(t *testing.T, value string) []byte {
+	t.Helper()
+	data, err := hex.DecodeString(value)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return data
+}
+
+func framePacket(t *testing.T, packet *Packet) []byte {
+	t.Helper()
+	packetSize := packet.SizeVT()
+	if packetSize > maxMessageSize {
+		t.Fatalf("packet size %d exceeds maximum %d", packetSize, maxMessageSize)
+	}
+	frame := make([]byte, 4+packetSize)
+	binary.LittleEndian.PutUint32(frame, uint32(packetSize)) //nolint:gosec // bounded by maxMessageSize
+	if _, err := packet.MarshalToSizedBufferVT(frame[4:]); err != nil {
+		t.Fatal(err)
+	}
+	return frame
+}
+
+type packetTestStream struct {
+	reads   bytes.Buffer
+	writes  []byte
+	maxRead int
+}
+
+func (s *packetTestStream) Read(data []byte) (int, error) {
+	if s.maxRead > 0 && len(data) > s.maxRead {
+		data = data[:s.maxRead]
+	}
+	return s.reads.Read(data)
+}
+
+func (s *packetTestStream) Write(data []byte) (int, error) {
+	s.writes = append(s.writes, data...)
+	return len(data), nil
+}
+
+func (s *packetTestStream) Close() error { return nil }
+
+func TestPacketCodecReadFragmentsAndCoalesces(t *testing.T) {
+	first := framePacket(t, NewCallCancelPacket())
+	second := framePacket(t, NewCallDataPacket([]byte("x"), false, true, nil))
+	input := append(first, second...)
+	stream := &packetTestStream{reads: *bytes.NewBuffer(input)}
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	var count int
+	err := NewPacketReadWriter(stream).ReadToHandler(func(data []byte) error {
+		count++
+		return decode(data)
+	})
+	if err != nil || count != 2 {
+		t.Fatalf("ReadToHandler() = %v, packets=%d", err, count)
+	}
+}
+
+func TestPacketCodecReadEveryFragmentBoundary(t *testing.T) {
+	frame := framePacket(t, NewCallCancelPacket())
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	for size := 1; size <= len(frame); size++ {
+		stream := &packetTestStream{reads: *bytes.NewBuffer(frame), maxRead: size}
+		var count int
+		err := NewPacketReadWriter(stream).ReadToHandler(func(data []byte) error {
+			count++
+			return decode(data)
+		})
+		if err != nil || count != 1 {
+			t.Fatalf("chunk %d: err=%v count=%d", size, err, count)
+		}
+	}
+}
+
+func TestPacketCodecRejectsInvalidPrefixesAndMalformedPacket(t *testing.T) {
+	for name, frame := range map[string][]byte{
+		"zero":      {0, 0, 0, 0},
+		"oversized": {0x81, 0x96, 0x98, 0x00},
+	} {
+		t.Run(name, func(t *testing.T) {
+			stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+			if err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error { return nil }); err == nil {
+				t.Fatal("accepted invalid prefix")
+			}
+		})
+	}
+	frame := []byte{3, 0, 0, 0, 0x0a, 0x01, 0xff}
+	stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+	decode := NewPacketDataHandler(func(*Packet) error { return nil })
+	if err := NewPacketReadWriter(stream).ReadToHandler(decode); err == nil {
+		t.Fatal("accepted malformed protobuf")
+	}
+}
+
+func TestPacketCodecCleanEOFReturnsNil(t *testing.T) {
+	stream := &packetTestStream{reads: *bytes.NewBuffer(nil)}
+	if err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error { return nil }); err != nil {
+		t.Fatalf("clean EOF: %v", err)
+	}
+}
+
+func TestPacketCodecTruncatedBodyAtEOF(t *testing.T) {
+	frame := []byte{4, 0, 0, 0, 0x0a, 0x01}
+	stream := &packetTestStream{reads: *bytes.NewBuffer(frame)}
+	var count int
+	err := NewPacketReadWriter(stream).ReadToHandler(func([]byte) error {
+		count++
+		return nil
+	})
+	if err != io.ErrUnexpectedEOF || count != 0 {
+		t.Fatalf("err=%v count=%d", err, count)
+	}
+}
+
+func TestPacketCodecWriteRejectsZeroPacket(t *testing.T) {
+	if err := NewPacketReadWriter(&packetTestStream{}).WritePacket(&Packet{}); err == nil {
+		t.Fatal("accepted zero-size packet")
+	}
+}

package/srpc/packet-codec.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest'
+import vectors from '../testdata/packet-codec-vectors.json'
+import { Packet } from './rpcproto.pb.js'
+import {
+  decodePacketSource,
+  encodePacketSource,
+  lengthPrefixDecode,
+  prependLengthPrefixTransform,
+  uint32LEDecode,
+} from './packet.js'
+
+const bytes = (hex: string) =>
+  Uint8Array.from(hex.match(/../g) ?? [], (b) => parseInt(b, 16))
+const hex = (
+  data: Uint8Array | { subarray: (start?: number, end?: number) => Uint8Array },
+) => Buffer.from(data.subarray()).toString('hex')
+const collect = async <T>(source: AsyncIterable<T> | Iterable<T>) => {
+  const out: T[] = []
+  for await (const value of source) out.push(value)
+  return out
+}
+
+type ValidVector = (typeof vectors.cases)[number] & {
+  packet_hex: string
+  frame_hex: string
+}
+const validCases: ValidVector[] = vectors.cases.filter(
+  (entry): entry is ValidVector => Boolean(entry.packet_hex && entry.frame_hex),
+)
+
+describe('packet codec golden vectors', () => {
+  it.each(validCases)(
+    '$name has exact protobuf and frame bytes',
+    async (entry) => {
+      const packet = Packet.fromBinary(bytes(entry.packet_hex))
+      const encoded = (
+        await collect(
+          encodePacketSource(
+            (async function* () {
+              yield packet
+            })(),
+          ),
+        )
+      )[0]
+      expect(hex(encoded)).toBe(entry.packet_hex)
+
+      const framed = (
+        await collect(
+          prependLengthPrefixTransform()(
+            (async function* () {
+              yield encoded
+            })(),
+          ),
+        )
+      )[0]
+      expect(hex(framed)).toBe(entry.frame_hex)
+    },
+  )
+
+  it('rejects zero and oversized encoded chunks', async () => {
+    const zero = (async function* () {
+      yield new Uint8Array()
+    })()
+    await expect(collect(prependLengthPrefixTransform()(zero))).rejects.toThrow(
+      'invalid packet length',
+    )
+    const oversized = (async function* () {
+      yield new Uint8Array(10_000_001)
+    })()
+    await expect(
+      collect(prependLengthPrefixTransform()(oversized)),
+    ).rejects.toThrow('invalid packet length')
+  })
+
+  it('rejects zero and oversized lengths, and truncated bodies', async () => {
+    const zero = (async function* () {
+      yield bytes('00000000')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(zero, uint32LEDecode)),
+    ).rejects.toThrow('invalid packet length')
+    const oversized = (async function* () {
+      yield bytes('81969800')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(oversized, uint32LEDecode)),
+    ).rejects.toThrow('invalid packet length')
+    const truncated = (async function* () {
+      yield bytes('040000000a01')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(truncated, uint32LEDecode)),
+    ).rejects.toThrow('truncated packet frame')
+  })
+
+  it('decodes fragmented and coalesced frames', async () => {
+    const frames = validCases.map((entry) => bytes(entry.frame_hex))
+    const combined = new Uint8Array(
+      frames.reduce((n, frame) => n + frame.length, 0),
+    )
+    let offset = 0
+    for (const frame of frames) {
+      combined.set(frame, offset)
+      offset += frame.length
+    }
+    const payloads = await collect(
+      lengthPrefixDecode(
+        (async function* () {
+          yield combined.subarray(0, 3)
+          yield combined.subarray(3, 11)
+          yield combined.subarray(11)
+        })(),
+        uint32LEDecode,
+      ),
+    )
+    expect(payloads.map(hex)).toEqual(
+      validCases.map((entry) => entry.packet_hex),
+    )
+    const decoded = await collect(
+      decodePacketSource(payloads.map((payload) => payload.slice())),
+    )
+    expect(decoded).toHaveLength(validCases.length)
+  })
+
+  it('rejects malformed protobuf and incomplete frame prefix', async () => {
+    const malformed = vectors.cases.find(
+      (entry) => entry.name === 'malformed_complete',
+    )!
+    expect(() =>
+      Packet.fromBinary(bytes(malformed.frame_hex!.slice(8))),
+    ).toThrow()
+    const incomplete = (async function* () {
+      yield bytes('010203')
+    })()
+    await expect(
+      collect(lengthPrefixDecode(incomplete, uint32LEDecode)),
+    ).rejects.toThrow('truncated packet frame')
+  })
+})

package/srpc/packet-rw.go

@@ -65,7 +65,10 @@ func (r *PacketReadWriter) WritePacket(p *Packet) error {
 	defer r.writeMtx.Unlock()
 
 	msgSize := p.SizeVT()
-	if msgSize < 0 || msgSize > maxMessageSize {
+	if msgSize <= 0 {
+		return errors.New("unexpected zero message size")
+	}
+	if msgSize > maxMessageSize {
 		return errors.Errorf("message size %v greater than maximum %v", msgSize, maxMessageSize)
 	}
 
@@ -163,7 +166,11 @@ func (r *PacketReadWriter) ReadToHandler(cb PacketDataHandler) error {
 		}
 	}
 
-	// closed
+	// closed: a clean frame boundary has no buffered bytes; otherwise EOF
+	// ended a prefix or packet body before completion.
+	if currLen != 0 || r.buf.Len() != 0 {
+		return io.ErrUnexpectedEOF
+	}
 	return nil
 }
 

package/srpc/packet.ts

@@ -7,6 +7,8 @@ import {
   buildEncodeMessageTransform,
 } from './message.js'
 
+const MAX_MESSAGE_SIZE = 10_000_000
+
 // decodePacketSource decodes packets from a binary data stream.
 export const decodePacketSource = buildDecodeMessageTransform<Packet>(Packet)
 
@@ -39,6 +41,9 @@ export async function* lengthPrefixEncode(
   for await (const chunk of source) {
     // Encode the length of the chunk.
     const length = chunk instanceof Uint8Array ? chunk.length : chunk.byteLength
+    if (length === 0 || length > MAX_MESSAGE_SIZE) {
+      throw RangeError(`invalid packet length: ${length}`)
+    }
     const lengthEncoded = lengthEncoder(length)
 
     // Concatenate the length prefix and the data.
@@ -50,7 +55,7 @@ export async function* lengthPrefixEncode(
 export async function* lengthPrefixDecode(
   source: Source<Uint8Array | Uint8ArrayList>,
   lengthDecoder: typeof uint32LEDecode,
-) {
+): AsyncGenerator<Uint8ArrayList> {
   const buffer = new Uint8ArrayList()
 
   for await (const chunk of source) {
@@ -59,18 +64,26 @@ export async function* lengthPrefixDecode(
     // Continue extracting messages while buffer contains enough data for decoding.
     while (buffer.length >= lengthDecoder.bytes) {
       const messageLength = lengthDecoder(buffer)
+      if (messageLength === 0 || messageLength > MAX_MESSAGE_SIZE) {
+        throw RangeError(`invalid packet length: ${messageLength}`)
+      }
       const totalLength = lengthDecoder.bytes + messageLength
 
       if (buffer.length < totalLength) break // Wait for more data if the full message hasn't arrived.
 
       // Extract the message excluding the length prefix.
-      const message = buffer.sublist(lengthDecoder.bytes, totalLength)
+      const message = new Uint8ArrayList(
+        buffer.slice(lengthDecoder.bytes, totalLength),
+      )
       yield message
 
       // Remove the processed message from the buffer.
       buffer.consume(totalLength)
     }
   }
+  if (buffer.length !== 0) {
+    throw new RangeError('truncated packet frame')
+  }
 }
 
 // prependLengthPrefixTransform adds a length prefix to a message source.

package/srpc/rpcproto_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: github.com/aperturerobotics/starpc/srpc/rpcproto.proto
+# Protobuf Python Version: 6.33.4
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    33,
+    4,
+    '',
+    'github.com/aperturerobotics/starpc/srpc/rpcproto.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n6github.com/aperturerobotics/starpc/srpc/rpcproto.proto\x12\x04srpc\"s\n\x06Packet\x12%\n\ncall_start\x18\x01 \x01(\x0b\x32\x0f.srpc.CallStartH\x00\x12#\n\tcall_data\x18\x02 \x01(\x0b\x32\x0e.srpc.CallDataH\x00\x12\x15\n\x0b\x63\x61ll_cancel\x18\x03 \x01(\x08H\x00\x42\x06\n\x04\x62ody\"X\n\tCallStart\x12\x13\n\x0brpc_service\x18\x01 \x01(\t\x12\x12\n\nrpc_method\x18\x02 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\x12\x14\n\x0c\x64\x61ta_is_zero\x18\x04 \x01(\x08\"O\n\x08\x43\x61llData\x12\x0c\n\x04\x64\x61ta\x18\x01 \x01(\x0c\x12\x14\n\x0c\x64\x61ta_is_zero\x18\x02 \x01(\x08\x12\x10\n\x08\x63omplete\x18\x03 \x01(\x08\x12\r\n\x05\x65rror\x18\x04 \x01(\tb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'github.com.aperturerobotics.starpc.srpc.rpcproto_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_PACKET']._serialized_start=64
+  _globals['_PACKET']._serialized_end=179
+  _globals['_CALLSTART']._serialized_start=181
+  _globals['_CALLSTART']._serialized_end=269
+  _globals['_CALLDATA']._serialized_start=271
+  _globals['_CALLDATA']._serialized_end=350
+# @@protoc_insertion_point(module_scope)

package/srpc/rpcproto_pb2.pyi

@@ -0,0 +1,40 @@
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Packet(_message.Message):
+    __slots__ = ("call_start", "call_data", "call_cancel")
+    CALL_START_FIELD_NUMBER: _ClassVar[int]
+    CALL_DATA_FIELD_NUMBER: _ClassVar[int]
+    CALL_CANCEL_FIELD_NUMBER: _ClassVar[int]
+    call_start: CallStart
+    call_data: CallData
+    call_cancel: bool
+    def __init__(self, call_start: _Optional[_Union[CallStart, _Mapping]] = ..., call_data: _Optional[_Union[CallData, _Mapping]] = ..., call_cancel: _Optional[bool] = ...) -> None: ...
+
+class CallStart(_message.Message):
+    __slots__ = ("rpc_service", "rpc_method", "data", "data_is_zero")
+    RPC_SERVICE_FIELD_NUMBER: _ClassVar[int]
+    RPC_METHOD_FIELD_NUMBER: _ClassVar[int]
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    DATA_IS_ZERO_FIELD_NUMBER: _ClassVar[int]
+    rpc_service: str
+    rpc_method: str
+    data: bytes
+    data_is_zero: bool
+    def __init__(self, rpc_service: _Optional[str] = ..., rpc_method: _Optional[str] = ..., data: _Optional[bytes] = ..., data_is_zero: _Optional[bool] = ...) -> None: ...
+
+class CallData(_message.Message):
+    __slots__ = ("data", "data_is_zero", "complete", "error")
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    DATA_IS_ZERO_FIELD_NUMBER: _ClassVar[int]
+    COMPLETE_FIELD_NUMBER: _ClassVar[int]
+    ERROR_FIELD_NUMBER: _ClassVar[int]
+    data: bytes
+    data_is_zero: bool
+    complete: bool
+    error: str
+    def __init__(self, data: _Optional[bytes] = ..., data_is_zero: _Optional[bool] = ..., complete: _Optional[bool] = ..., error: _Optional[str] = ...) -> None: ...

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.ts

@@ -4,6 +4,7 @@ import type { CallData, CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 import { InvokeFn } from './handler.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,7 +48,9 @@ export class ServerRPC extends CommonRPC {
   private async invokeRPC(invokeFn: InvokeFn) {
     const dataSink = this._createDataSink()
     try {
-      await invokeFn(this.rpcDataSource, dataSink, this.invocationSignal)
+      await invokeFn(this.rpcDataSource, dataSink, {
+        signal: this.invocationSignal,
+      } satisfies ServerContext)
     } catch (err) {
       this.close(err as Error)
     }