starpc 0.51.0 → 0.52.1

package/integration/cross-language/ts-client.ts

@@ -1,59 +1,71 @@
 import net from 'net'
-import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
 import { Client } from '../../srpc/client.js'
 import {
-  parseLengthPrefixTransform,
-  prependLengthPrefixTransform,
-} from '../../srpc/packet.js'
-import { combineUint8ArrayListTransform } from '../../srpc/array-list.js'
-import { runClientTest } from '../../echo/index.js'
+  runClientTest,
+  runAbortControllerTest,
+  runRpcStreamTest,
+} from '../../echo/client-test.js'
+import { EchoerClient } from '../../echo/echo_srpc.pb.js'
 import type { OpenStreamFunc, PacketStream } from '../../srpc/stream.js'
-import type { Source } from 'it-stream-types'
+import { tcpSocketToPacketStream } from './tcp-packet-stream.js'
 
-// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
-function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
-  const socketSource = async function* (): AsyncGenerator<Uint8Array> {
-    const source = pushable<Uint8Array>({ objectMode: true })
-    socket.on('data', (data: Buffer) => {
-      source.push(new Uint8Array(data))
-    })
-    socket.on('end', () => source.end())
-    socket.on('error', (err) => source.end(err))
-    socket.on('close', () => source.end())
-    yield* pipe(
-      source,
-      parseLengthPrefixTransform(),
-      combineUint8ArrayListTransform(),
-    )
+async function runEchoBidiStreamTest(client: Client): Promise<void> {
+  const request = pushable<{ body: string }>({ objectMode: true })
+  const stream = new EchoerClient(client).EchoBidiStream(request)
+  const iterator = stream[Symbol.asyncIterator]()
+
+  const initial = await iterator.next()
+  if (initial.done || initial.value.body !== 'hello from server') {
+    throw new Error('expected initial bidi message "hello from server"')
+  }
+
+  const body = 'hello from TypeScript bidi client'
+  request.push({ body })
+  request.end()
+
+  const echo = await iterator.next()
+  if (echo.done || echo.value.body !== body) {
+    throw new Error(`expected bidi echo ${JSON.stringify(body)}`)
   }
 
-  return {
-    source: socketSource(),
-    sink: async (source: Source<Uint8Array>): Promise<void> => {
-      for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
-        const data = chunk instanceof Uint8Array ? chunk : chunk.subarray()
-        await new Promise<void>((resolve, reject) => {
-          socket.write(data, (err) => {
-            if (err) reject(err)
-            else resolve()
-          })
-        })
-      }
-      socket.end()
-    },
+  const terminal = await iterator.next()
+  if (!terminal.done) {
+    throw new Error('expected bidi stream to terminate after input closes')
   }
 }
 
+function parseAddr(addr: string): { host: string; port: number } {
+  const match = /^(?:\[([^\]]+)\]|([^:]+)):(\d+)$/.exec(addr)
+  if (!match) {
+    throw new Error(`invalid host:port address: ${addr}`)
+  }
+
+  const port = Number(match[3])
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`invalid port: ${match[3]}`)
+  }
+
+  return { host: match[1] ?? match[2], port }
+}
+
 async function main() {
-  const addr = process.argv[2]
+  const args = process.argv.slice(2)
+  const lifecycle = args.includes('lifecycle')
+  const nested = args.includes('--nested') || args.includes('--nested-release')
+  const nestedRelease = args.includes('--nested-release')
+  const addr = args.find(
+    (arg) =>
+      arg !== 'lifecycle' && arg !== '--nested' && arg !== '--nested-release',
+  )
   if (!addr) {
-    console.error('usage: ts-client <host:port>')
+    console.error(
+      'usage: ts-client [--nested] [--nested-release] [lifecycle] <host:port>',
+    )
     process.exit(1)
   }
 
-  const [host, portStr] = addr.split(':')
-  const port = parseInt(portStr, 10)
+  const { host, port } = parseAddr(addr)
   const openStream: OpenStreamFunc = async (): Promise<PacketStream> => {
     const { promise, resolve, reject } = Promise.withResolvers<PacketStream>()
     const socket = net.connect(port, host, () => {
@@ -66,6 +78,16 @@ async function main() {
   const client = new Client(openStream)
   console.log('Running client test via TCP...')
   await runClientTest(client)
+  console.log('Running EchoBidiStream test via TCP...')
+  await runEchoBidiStreamTest(client)
+  if (lifecycle) {
+    console.log('Running abort controller test via TCP...')
+    await runAbortControllerTest(client)
+  }
+  if (nested) {
+    console.log('Running RpcStream test via TCP...')
+    await runRpcStreamTest(client, nestedRelease)
+  }
   console.log('All tests passed.')
 }
 

package/integration/cross-language/ts-server.ts

@@ -1,53 +1,9 @@
 import net from 'net'
-import { pipe } from 'it-pipe'
-import { pushable } from 'it-pushable'
-import type { Source } from 'it-stream-types'
 
 import { createMux, createHandler, Server } from '../../srpc/index.js'
-import {
-  parseLengthPrefixTransform,
-  prependLengthPrefixTransform,
-} from '../../srpc/packet.js'
-import { combineUint8ArrayListTransform } from '../../srpc/array-list.js'
 import { EchoerServer } from '../../echo/index.js'
 import { EchoerDefinition } from '../../echo/echo_srpc.pb.js'
-import type { PacketStream } from '../../srpc/stream.js'
-
-// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
-// Each Uint8Array in source/sink is one packet (no length prefix).
-function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
-  // Source: read from socket, strip length prefix, yield individual packets.
-  const socketSource = async function* (): AsyncGenerator<Uint8Array> {
-    const source = pushable<Uint8Array>({ objectMode: true })
-    socket.on('data', (data: Buffer) => {
-      source.push(new Uint8Array(data))
-    })
-    socket.on('end', () => source.end())
-    socket.on('error', (err) => source.end(err))
-    socket.on('close', () => source.end())
-    yield* pipe(
-      source,
-      parseLengthPrefixTransform(),
-      combineUint8ArrayListTransform(),
-    )
-  }
-
-  return {
-    source: socketSource(),
-    sink: async (source: Source<Uint8Array>): Promise<void> => {
-      for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
-        const data = chunk instanceof Uint8Array ? chunk : chunk.subarray()
-        await new Promise<void>((resolve, reject) => {
-          socket.write(data, (err) => {
-            if (err) reject(err)
-            else resolve()
-          })
-        })
-      }
-      socket.end()
-    },
-  }
-}
+import { tcpSocketToPacketStream } from './tcp-packet-stream.js'
 
 const mux = createMux()
 const server = new Server(mux.lookupMethod)

package/mock/mock_pb2.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: github.com/aperturerobotics/starpc/mock/mock.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/mock/mock.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n2github.com/aperturerobotics/starpc/mock/mock.proto\x12\x08\x65\x32\x65.mock\"\x17\n\x07MockMsg\x12\x0c\n\x04\x62ody\x18\x01 \x01(\t2;\n\x04Mock\x12\x33\n\x0bMockRequest\x12\x11.e2e.mock.MockMsg\x1a\x11.e2e.mock.MockMsgb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'github.com.aperturerobotics.starpc.mock.mock_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_MOCKMSG']._serialized_start=64
+  _globals['_MOCKMSG']._serialized_end=87
+  _globals['_MOCK']._serialized_start=89
+  _globals['_MOCK']._serialized_end=148
+# @@protoc_insertion_point(module_scope)

package/mock/mock_pb2.pyi

@@ -0,0 +1,11 @@
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Optional as _Optional
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class MockMsg(_message.Message):
+    __slots__ = ("body",)
+    BODY_FIELD_NUMBER: _ClassVar[int]
+    body: str
+    def __init__(self, body: _Optional[str] = ...) -> None: ...

package/mock/mock_srpc.pb.ts

@@ -4,7 +4,7 @@
 
 import { MockMsg } from './mock.pb.js'
 import { MethodKind } from '@aptre/protobuf-es-lite'
-import { ProtoRpc } from 'starpc'
+import { ProtoRpc, ServerContext } from 'starpc'
 
 /**
  * Mock service mocks some RPCs for the e2e tests.
@@ -42,6 +42,24 @@ export interface Mock {
   MockRequest(request: MockMsg, abortSignal?: AbortSignal): Promise<MockMsg>
 }
 
+/**
+ * Mock service mocks some RPCs for the e2e tests.
+ *
+ * @generated from service e2e.mock.Mock
+ */
+export interface MockHandler {
+  /**
+   * MockRequest runs a mock unary request.
+   *
+   * @generated from rpc e2e.mock.Mock.MockRequest
+   */
+  MockRequest(
+    request: MockMsg,
+    abortSignal: AbortSignal,
+    context: ServerContext,
+  ): Promise<MockMsg>
+}
+
 export const MockServiceName = MockDefinition.typeName
 
 export class MockClient implements Mock {

package/mock/mock_srpc.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from mock import (
+    mock_pb2 as _github_com_aperturerobotics_starpc_mock_mock_pb2,
+)
+from starpc.call import Call, CallProtocolError
+from starpc.client import Client
+from starpc.server import ServiceRegistry
+from starpc.service import MethodDescriptor, ServiceDescriptor
+
+MOCK_SERVICE = ServiceDescriptor(
+    "e2e.mock.Mock",
+    (
+        MethodDescriptor(
+            "MockRequest",
+            _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg,
+            _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg,
+            False,
+            False,
+        ),
+    ),
+)
+
+
+class MockClient:
+    def __init__(self, client: Client, service: str | None = None) -> None:
+        self._client = client
+        self._service = service or "e2e.mock.Mock"
+
+    async def mock_request(
+        self, request: _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg
+    ) -> _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg:
+        call = await self._client.open_call(
+            self._service, "MockRequest", request.SerializeToString(deterministic=True)
+        )
+        try:
+            data = await call.receive()
+            if data is None:
+                raise CallProtocolError("missing unary response")
+            response = _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg()
+            response.ParseFromString(data)
+            if await call.receive() is not None:
+                raise CallProtocolError("extra unary response")
+            return response
+        finally:
+            await call.aclose()
+
+
+class MockServer(Protocol):
+    async def mock_request(
+        self, request: _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg
+    ) -> _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg: ...
+
+
+def register_mock(
+    registry: ServiceRegistry,
+    implementation: MockServer,
+    service: str = "e2e.mock.Mock",
+) -> None:
+    async def mock_request_handler(call: Call) -> None:
+        first = await call.receive()
+        if first is None:
+            raise CallProtocolError("missing initial request")
+        request = _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg()
+        request.ParseFromString(first)
+        response = await implementation.mock_request(request)
+        await call.send(response.SerializeToString(deterministic=True))
+
+    registry.register(service, "MockRequest", mock_request_handler)

package/mock/mock_srpc.pyi

@@ -0,0 +1,27 @@
+from typing import Protocol
+
+from mock import (
+    mock_pb2 as _github_com_aperturerobotics_starpc_mock_mock_pb2,
+)
+from starpc.client import Client
+from starpc.server import ServiceRegistry
+from starpc.service import ServiceDescriptor
+
+MOCK_SERVICE: ServiceDescriptor
+
+class MockClient:
+    def __init__(self, client: Client, service: str | None = None) -> None: ...
+    async def mock_request(
+        self, request: _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg
+    ) -> _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg: ...
+
+class MockServer(Protocol):
+    async def mock_request(
+        self, request: _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg
+    ) -> _github_com_aperturerobotics_starpc_mock_mock_pb2.MockMsg: ...
+
+def register_mock(
+    registry: ServiceRegistry,
+    implementation: MockServer,
+    service: str = "e2e.mock.Mock",
+) -> None: ...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.51.0",
+  "version": "0.52.1",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -68,12 +68,12 @@
     "deps": "depcheck --ignores 'bufferutil,utf-8-validate,rimraf,starpc,@aptre/protobuf-es-lite,tsx'",
     "codegen": "bun run gen",
     "ci": "bun run build && bun run lint:js && bun run lint:go",
-    "format": "bun run format:js && bun run format:go && bun run format:config",
+    "format": "bun run format:js && bun run format:go && bun run format:python && bun run format:config",
     "format:config": "oxfmt '*.json' '.github/**/*.json' '.github/**/*.yml' '.oxfmtrc.json' 'tsconfig.json'",
     "format:go": "bun run go:aptre -- format",
     "format:js": "oxfmt './{srpc,echo,e2e,integration,rpcstream,cmd,mock,scripts}/**/*.{ts,tsx,js,mjs,html,css,scss}' '*.{ts,tsx,js,mjs}'",
-    "gen": "bun run go:aptre -- generate && bun run format",
-    "gen:force": "bun run go:aptre -- generate --force && bun run format",
+    "gen": "bun run build && bun run go:aptre -- generate && bun run format",
+    "gen:force": "bun run build && bun run go:aptre -- generate --force && bun run format",
     "test": "bun run test:js && bun run test:go",
     "test:go": "bun run go:aptre -- test",
     "test:cpp": "mkdir -p build && cd build && cmake -G Ninja .. -DCMAKE_BUILD_TYPE=Release && cmake --build . --parallel && ctest --output-on-failure",
@@ -100,7 +100,8 @@
     "release:version": "bun scripts/release-version.ts patch",
     "release:version:minor": "bun scripts/release-version.ts minor",
     "release:commit": "version=$(bun -e 'console.log(require(\"./package.json\").version)') && git reset && git add package.json Cargo.toml && git commit -s -m \"release: v$version\" && git tag \"v$version\"",
-    "release:publish": "git push && git push --tags"
+    "release:publish": "git push && git push --tags",
+    "format:python": "files=$(find echo mock -type f \\( -name '*_srpc.py' -o -name '*_srpc.pyi' \\)); if [ -n \"$files\" ]; then uv run ruff check --fix --ignore UP026 $files && uv run ruff format $files; fi"
   },
   "preferUnplugged": true,
   "lint-staged": {
@@ -114,7 +115,7 @@
     "happy-dom": "^20.9.0",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.0",
-    "oxfmt": "0.61.0",
+    "oxfmt": "0.62.0",
     "oxlint": "^1.76.0",
     "rimraf": "^6.1.3",
     "tsx": "^4.20.4",
@@ -138,5 +139,18 @@
   },
   "overrides": {
     "@aptre/protobuf-es-lite": "1.1.1"
+  },
+  "aptre": {
+    "languages": [
+      "go",
+      "ts",
+      "cpp",
+      "rust",
+      "python"
+    ],
+    "rpc": [
+      "starpc",
+      "starpc-python"
+    ]
   }
 }

package/srpc/channel.test.ts

@@ -1,9 +1,29 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import { pushable } from 'it-pushable'
 
 import { ChannelStream } from './channel.js'
 
 describe('ChannelStream', () => {
+  it('recognizes MessagePort implementations from another realm', () => {
+    const port = {
+      close: vi.fn(),
+      onmessage: null,
+      postMessage: vi.fn(),
+      start: vi.fn(),
+    } as unknown as MessagePort
+
+    const stream = new ChannelStream<Uint8Array>('client', port)
+    try {
+      expect(port.start).toHaveBeenCalledOnce()
+      expect(port.postMessage).toHaveBeenCalledWith({
+        ack: true,
+        from: 'client',
+      })
+    } finally {
+      stream.close()
+    }
+  })
+
   it('keeps MessagePort peer writes open after local source completes normally', async () => {
     const { port1, port2 } = new MessageChannel()
     const client = new ChannelStream<Uint8Array>('client', port1)

package/srpc/channel.ts

@@ -26,6 +26,10 @@ export type ChannelPort =
   | MessagePort
   | { tx: BroadcastChannel; rx: BroadcastChannel }
 
+function isMessagePort(channel: ChannelPort): channel is MessagePort {
+  return 'postMessage' in channel && 'start' in channel
+}
+
 // ChannelStreamOpts are options for ChannelStream.
 export interface ChannelStreamOpts {
   // remoteOpen indicates that the remote already knows the channel is open.
@@ -149,7 +153,7 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
 
     // wire up the message handlers
     const onMessage = this.onMessage.bind(this)
-    if (channel instanceof MessagePort) {
+    if (isMessagePort(channel)) {
       // MessagePort
       channel.onmessage = onMessage
       channel.start()
@@ -180,7 +184,7 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
       return
     }
     msg.from = this.localId
-    if (this.channel instanceof MessagePort) {
+    if (isMessagePort(this.channel)) {
       this.channel.postMessage(msg)
     } else {
       this.channel.tx.postMessage(msg)
@@ -222,7 +226,7 @@ export class ChannelStream<T = Uint8Array> implements Duplex<
     this.localWriteClosed = true
     this.remoteWriteClosed = true
     // close channels
-    if (this.channel instanceof MessagePort) {
+    if (isMessagePort(this.channel)) {
       this.channel.onmessage = null
       this.channel.close()
     } else {

package/srpc/client.ts

@@ -117,13 +117,29 @@ export class Client implements ProtoRpc {
     const stream = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     const onAbort = () => {
+      if (call.isClosed) return
+      const error = new Error(ERR_RPC_ABORT)
       void call.writeCallCancel().catch(() => undefined)
-      void call.close(new Error(ERR_RPC_ABORT)).catch(() => undefined)
+      stream.abort(error)
+      void call.close(error).catch(() => undefined)
     }
     abortSignal?.addEventListener('abort', onAbort, { once: true })
-    pipe(stream, decodePacketSource, call, encodePacketSource, stream)
-      .catch((err) => call.close(err))
-      .then(() => call.close())
+    void pipe(stream, decodePacketSource, call, encodePacketSource, stream)
+      .then(
+        async () => {
+          if (call.isClosed instanceof Error) {
+            stream.abort(call.isClosed)
+            return
+          }
+          await stream.close()
+          await call.close()
+        },
+        async (err: unknown) => {
+          const error = err instanceof Error ? err : new Error(String(err))
+          stream.abort(error)
+          await call.close(error)
+        },
+      )
       .finally(() => {
         abortSignal?.removeEventListener('abort', onAbort)
       })

package/srpc/codec.rs

@@ -76,6 +76,9 @@ impl Encoder<Packet> for PacketCodec {
         let msg_size = item.encoded_len();
 
         // Validate message size.
+        if msg_size == 0 {
+            return Err(Error::MessageSizeZero);
+        }
         if msg_size > MAX_MESSAGE_SIZE {
             return Err(Error::MessageTooLarge(msg_size, MAX_MESSAGE_SIZE));
         }
@@ -96,6 +99,9 @@ impl Encoder<Packet> for PacketCodec {
 /// Encode a packet to bytes with length prefix.
 pub fn encode_packet(packet: &Packet) -> Result<Vec<u8>> {
     let msg_size = packet.encoded_len();
+    if msg_size == 0 {
+        return Err(Error::MessageSizeZero);
+    }
     if msg_size > MAX_MESSAGE_SIZE {
         return Err(Error::MessageTooLarge(msg_size, MAX_MESSAGE_SIZE));
     }

package/srpc/common-rpc.test.ts

@@ -152,6 +152,8 @@ describe('CommonRPC', () => {
     const responseGate = deferred()
     const response = new Uint8Array([7])
     const client = new Client(async () => ({
+      close: async () => {},
+      abort: () => {},
       source: (async function* () {
         await responseGate.promise
         yield Packet.toBinary({

package/srpc/handler.ts

@@ -1,12 +1,58 @@
 import type { Sink, Source } from 'it-stream-types'
-import { ServiceDefinition, ServiceMethodDefinitions } from './definition.js'
+import { MethodKind, type MessageType } from '@aptre/protobuf-es-lite'
+import type { MessageStream } from './message.js'
+import {
+  type MethodDefinition,
+  ServiceDefinition,
+  ServiceMethodDefinitions,
+} from './definition.js'
 import { createInvokeFn } from './invoker.js'
+import type { ServerContext } from './server-context.js'
+
+type MessageOf<T> = T extends MessageType<infer M> ? M : never
+
+type ServerMethod<T> =
+  T extends MethodDefinition<
+    infer Request,
+    infer Response,
+    infer Kind,
+    infer _Idempotency
+  >
+    ? Kind extends MethodKind.Unary
+      ? (
+          request: MessageOf<Request>,
+          abortSignal: AbortSignal,
+          context: ServerContext,
+        ) => Promise<MessageOf<Response>>
+      : Kind extends MethodKind.ServerStreaming
+        ? (
+            request: MessageOf<Request>,
+            abortSignal: AbortSignal,
+            context: ServerContext,
+          ) => MessageStream<MessageOf<Response>>
+        : Kind extends MethodKind.ClientStreaming
+          ? (
+              request: MessageStream<MessageOf<Request>>,
+              abortSignal: AbortSignal,
+              context: ServerContext,
+            ) => Promise<MessageOf<Response>>
+          : (
+              request: MessageStream<MessageOf<Request>>,
+              abortSignal: AbortSignal,
+              context: ServerContext,
+            ) => MessageStream<MessageOf<Response>>
+    : never
+
+export type HandlerImplementation<T extends ServiceMethodDefinitions> =
+  Partial<{
+    [Method in keyof T]: ServerMethod<T[Method]>
+  }>
 
 // InvokeFn describes an SRPC call method invoke function.
 export type InvokeFn = (
   dataSource: Source<Uint8Array>,
   dataSink: Sink<Source<Uint8Array>>,
-  invocation?: AbortSignal,
+  context: ServerContext,
 ) => Promise<void>
 
 // Handler describes a SRPC call handler implementation.
@@ -62,7 +108,11 @@ export class StaticHandler implements Handler {
 // if serviceID is not set, uses the fullName of the service as the identifier.
 export function createHandler<
   T extends ServiceMethodDefinitions = ServiceMethodDefinitions,
->(definition: ServiceDefinition<T>, impl: any, serviceID?: string): Handler {
+>(
+  definition: ServiceDefinition<T>,
+  impl: HandlerImplementation<T>,
+  serviceID?: string,
+): Handler {
   // serviceID defaults to the full name of the service from Protobuf.
   serviceID = serviceID || definition.typeName
 
@@ -70,7 +120,7 @@ export function createHandler<
   const methodMap: MethodMap = {}
   for (const methodInfo of Object.values(definition.methods)) {
     const methodName = methodInfo.name
-    let methodProto = impl[methodName]
+    let methodProto = impl[methodName as keyof T] as any
     if (!methodProto) {
       continue
     }

package/srpc/index.ts

@@ -83,3 +83,10 @@ export {
 } from './pushable.js'
 export { Watchdog } from './watchdog.js'
 export type { ProtoRpc } from './proto-rpc.js'
+
+export {
+  createContextKey,
+  serverContextValue,
+  withServerContextValue,
+} from './server-context.js'
+export type { ContextKey, ServerContext } from './server-context.js'