starpc 0.51.0 → 0.52.1

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

@@ -1,48 +1,51 @@
 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';
-// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
-function tcpSocketToPacketStream(socket) {
-    const socketSource = async function* () {
-        const source = pushable({ objectMode: true });
-        socket.on('data', (data) => {
-            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) => {
-            for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
-                const data = chunk instanceof Uint8Array ? chunk : chunk.subarray();
-                await new Promise((resolve, reject) => {
-                    socket.write(data, (err) => {
-                        if (err)
-                            reject(err);
-                        else
-                            resolve();
-                    });
-                });
-            }
-            socket.end();
-        },
-    };
+import { runClientTest, runAbortControllerTest, runRpcStreamTest, } from '../../echo/client-test.js';
+import { EchoerClient } from '../../echo/echo_srpc.pb.js';
+import { tcpSocketToPacketStream } from './tcp-packet-stream.js';
+async function runEchoBidiStreamTest(client) {
+    const request = pushable({ 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)}`);
+    }
+    const terminal = await iterator.next();
+    if (!terminal.done) {
+        throw new Error('expected bidi stream to terminate after input closes');
+    }
+}
+function parseAddr(addr) {
+    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 = async () => {
         const { promise, resolve, reject } = Promise.withResolvers();
         const socket = net.connect(port, host, () => {
@@ -54,6 +57,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.');
 }
 process.on('unhandledRejection', (ev) => {

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

@@ -1,43 +1,8 @@
 import net from 'net';
-import { pipe } from 'it-pipe';
-import { pushable } from 'it-pushable';
 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';
-// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
-// Each Uint8Array in source/sink is one packet (no length prefix).
-function tcpSocketToPacketStream(socket) {
-    // Source: read from socket, strip length prefix, yield individual packets.
-    const socketSource = async function* () {
-        const source = pushable({ objectMode: true });
-        socket.on('data', (data) => {
-            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) => {
-            for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
-                const data = chunk instanceof Uint8Array ? chunk : chunk.subarray();
-                await new Promise((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);
 const echoer = new EchoerServer(server);

package/dist/mock/mock_srpc.pb.d.ts

@@ -1,6 +1,6 @@
 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.
  *
@@ -35,6 +35,19 @@ 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 declare const MockServiceName: "e2e.mock.Mock";
 export declare class MockClient implements Mock {
     private readonly rpc;

package/dist/rpcstream/rpcstream.d.ts

@@ -15,7 +15,11 @@ export declare class RpcStream implements PacketStream {
     readonly sink: Sink<Source<Uint8Array>, Promise<void>>;
     private readonly _packetRx;
     private readonly _packetTx;
-    constructor(packetTx: Pushable<Message<RpcStreamPacket>>, packetRx: AsyncIterator<Message<RpcStreamPacket>>);
+    private readonly _termination;
+    private readonly _cancelRpc;
+    constructor(packetTx: Pushable<Message<RpcStreamPacket>>, packetRx: AsyncIterator<Message<RpcStreamPacket>>, cancelRpc?: () => void);
+    close(): Promise<void>;
+    abort(err: Error): void;
     private _createSink;
     private _createSource;
 }

package/dist/rpcstream/rpcstream.js

@@ -1,4 +1,5 @@
 import { pushable } from 'it-pushable';
+import { closeIterator, sourceIterator, TerminationGate, } from '../srpc/termination.js';
 // openRpcStream attempts to open a stream over a RPC call.
 // if waitAck is set, waits for the remote to ack the stream before returning.
 export async function openRpcStream(componentId, caller, waitAck) {
@@ -33,7 +34,7 @@ export async function openRpcStream(componentId, caller, waitAck) {
         }
     }
     // build & return the data stream
-    return new RpcStream(packetTx, packetIt);
+    return new RpcStream(packetTx, packetIt, () => closeIterator(packetIt));
 }
 // buildRpcStreamOpenStream builds a OpenStream func with a RpcStream.
 export function buildRpcStreamOpenStream(componentId, caller) {
@@ -87,7 +88,7 @@ export async function* handleRpcStream(packetRx, getter) {
     // build the outgoing packet sink & the packet source
     const packetTx = pushable({ objectMode: true });
     // start the handler
-    const rpcStream = new RpcStream(packetTx, packetRx);
+    const rpcStream = new RpcStream(packetTx, packetRx, () => closeIterator(packetRx));
     handler(rpcStream)
         .catch((err) => packetTx.end(err))
         .then(() => packetTx.end());
@@ -107,54 +108,100 @@ export class RpcStream {
     _packetRx;
     // _packetTx writes packets to the remote.
     _packetTx;
+    _termination = new TerminationGate();
+    _cancelRpc;
     // packetTx writes packets to the remote.
     // packetRx receives packets from the remote.
-    constructor(packetTx, packetRx) {
+    constructor(packetTx, packetRx, cancelRpc = () => closeIterator(packetRx)) {
         this._packetTx = packetTx;
         this._packetRx = packetRx;
+        this._cancelRpc = cancelRpc;
         this.sink = this._createSink();
         this.source = this._createSource();
     }
+    // close cleanly ends both directions of the stream.
+    async close() {
+        if (this._termination.terminate()) {
+            this._packetTx.end();
+            this._cancelRpc();
+        }
+    }
+    // abort ends both directions of the stream with err.
+    abort(err) {
+        if (this._termination.terminate(err)) {
+            this._packetTx.end(err);
+            this._cancelRpc();
+        }
+    }
     // _createSink initializes the sink field.
     _createSink() {
         return async (source) => {
+            const iterator = sourceIterator(source);
             try {
-                for await (const arr of source) {
+                while (true) {
+                    const next = await this._termination.next(iterator);
+                    if ('terminated' in next) {
+                        if (next.error)
+                            throw next.error;
+                        return;
+                    }
+                    if ('error' in next)
+                        throw next.error;
+                    if (next.result.done) {
+                        this._packetTx.end();
+                        return;
+                    }
+                    if (this._termination.terminated)
+                        return;
                     this._packetTx.push({
-                        body: { case: 'data', value: arr },
+                        body: { case: 'data', value: next.result.value },
                     });
                 }
-                this._packetTx.end();
             }
             catch (err) {
-                this._packetTx.end(err);
+                const error = err instanceof Error ? err : new Error(String(err));
+                this.abort(error);
+                throw error;
+            }
+            finally {
+                closeIterator(iterator);
             }
         };
     }
     // _createSource initializes the source field.
     _createSource() {
-        return (async function* (packetRx) {
-            while (true) {
-                const msgIt = await packetRx.next();
-                if (msgIt.done) {
-                    return;
-                }
-                const value = msgIt.value;
-                const body = value?.body;
-                if (!body) {
-                    continue;
-                }
-                switch (body.case) {
-                    case 'ack':
-                        if (body.value.error?.length) {
-                            throw new Error(body.value.error);
-                        }
-                        break;
-                    case 'data':
-                        yield body.value;
-                        break;
+        const packetRx = this._packetRx;
+        const termination = this._termination;
+        return (async function* () {
+            try {
+                while (true) {
+                    const next = await termination.next(packetRx);
+                    if ('terminated' in next) {
+                        if (next.error)
+                            throw next.error;
+                        return;
+                    }
+                    if ('error' in next)
+                        throw next.error;
+                    if (next.result.done)
+                        return;
+                    const body = next.result.value?.body;
+                    if (!body)
+                        continue;
+                    switch (body.case) {
+                        case 'ack':
+                            if (body.value.error?.length)
+                                throw new Error(body.value.error);
+                            break;
+                        case 'data':
+                            yield body.value;
+                            break;
+                    }
                 }
             }
-        })(this._packetRx);
+            finally {
+                closeIterator(packetRx);
+            }
+        })();
     }
 }

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

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

package/dist/rpcstream/rpcstream.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from 'vitest';
+import { pushable } from 'it-pushable';
+import { RpcStream } from './rpcstream.js';
+describe('RpcStream lifecycle', () => {
+    it('closes while its source is blocked', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.source.next();
+        await stream.close();
+        await expect(pending).resolves.toEqual({ done: true, value: undefined });
+        await expect(tx.next()).resolves.toEqual({ done: true, value: undefined });
+    });
+    it('aborts while its source is blocked', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.source.next();
+        const error = new Error('stopped');
+        stream.abort(error);
+        await expect(pending).rejects.toBe(error);
+        await expect(tx.next()).rejects.toBe(error);
+    });
+    it('closes while its sink source is blocked', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const input = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.sink(input);
+        await stream.close();
+        await expect(pending).resolves.toBeUndefined();
+        await expect(tx.next()).resolves.toEqual({ done: true, value: undefined });
+    });
+    it('aborts while its sink source is blocked', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const input = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.sink(input);
+        const error = new Error('stopped');
+        stream.abort(error);
+        await expect(pending).rejects.toBe(error);
+        await expect(tx.next()).rejects.toBe(error);
+    });
+    it('does not write input that becomes ready as the stream closes', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const input = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        input.push(new Uint8Array([1]));
+        const pending = stream.sink(input);
+        await stream.close();
+        await expect(pending).resolves.toBeUndefined();
+        await expect(tx.next()).resolves.toEqual({ done: true, value: undefined });
+    });
+    it('does not close when its sink completes', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        await stream.sink((async function* () { })());
+        rx.push({ body: { case: 'data', value: new Uint8Array([1]) } });
+        await expect(stream.source.next()).resolves.toMatchObject({ done: false });
+    });
+    it('finalizes a sink input iterator when closed', async () => {
+        const tx = pushable({ objectMode: true });
+        const rx = pushable({ objectMode: true });
+        const returned = vi.fn(() => Promise.resolve({ done: true, value: undefined }));
+        const input = {
+            [Symbol.asyncIterator]: () => ({
+                next: () => new Promise(() => { }),
+                return: returned,
+            }),
+        };
+        const stream = new RpcStream(tx, rx[Symbol.asyncIterator]());
+        const pending = stream.sink(input);
+        await stream.close();
+        await pending;
+        expect(returned).toHaveBeenCalledOnce();
+    });
+    it('cancels the outer RPC when aborted after sink completion', async () => {
+        const tx = pushable({ objectMode: true });
+        const returned = vi.fn(() => Promise.resolve({ done: true, value: undefined }));
+        const rx = {
+            next: () => new Promise(() => { }),
+            return: returned,
+        };
+        const stream = new RpcStream(tx, rx);
+        await stream.sink((async function* () { })());
+        stream.abort(new Error('stopped'));
+        expect(returned).toHaveBeenCalledOnce();
+    });
+});

package/dist/srpc/channel.js

@@ -1,6 +1,9 @@
 import { pushable } from 'it-pushable';
 import { Watchdog } from './watchdog.js';
 import { ERR_STREAM_IDLE } from './errors.js';
+function isMessagePort(channel) {
+    return 'postMessage' in channel && 'start' in channel;
+}
 // ChannelStream implements a Stream over a BroadcastChannel duplex or MessagePort.
 //
 // NOTE: there is no way to tell if a BroadcastChannel or MessagePort is closed.
@@ -99,7 +102,7 @@ export class ChannelStream {
         this._source = source;
         // wire up the message handlers
         const onMessage = this.onMessage.bind(this);
-        if (channel instanceof MessagePort) {
+        if (isMessagePort(channel)) {
             // MessagePort
             channel.onmessage = onMessage;
             channel.start();
@@ -124,7 +127,7 @@ export class ChannelStream {
             return;
         }
         msg.from = this.localId;
-        if (this.channel instanceof MessagePort) {
+        if (isMessagePort(this.channel)) {
             this.channel.postMessage(msg);
         }
         else {
@@ -165,7 +168,7 @@ export class ChannelStream {
         this.localWriteClosed = true;
         this.remoteWriteClosed = true;
         // close channels
-        if (this.channel instanceof MessagePort) {
+        if (isMessagePort(this.channel)) {
             this.channel.onmessage = null;
             this.channel.close();
         }

package/dist/srpc/channel.test.js

@@ -1,7 +1,26 @@
-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(),
+        };
+        const stream = new ChannelStream('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('client', port1);

package/dist/srpc/client.js

@@ -82,13 +82,27 @@ export class Client {
         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) => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            stream.abort(error);
+            await call.close(error);
+        })
             .finally(() => {
             abortSignal?.removeEventListener('abort', onAbort);
         });

package/dist/srpc/common-rpc.test.js

@@ -101,6 +101,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/dist/srpc/handler.d.ts

@@ -1,6 +1,14 @@
 import type { Sink, Source } from 'it-stream-types';
-import { ServiceDefinition, ServiceMethodDefinitions } from './definition.js';
-export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>, invocation?: AbortSignal) => Promise<void>;
+import { MethodKind, type MessageType } from '@aptre/protobuf-es-lite';
+import type { MessageStream } from './message.js';
+import { type MethodDefinition, ServiceDefinition, ServiceMethodDefinitions } from './definition.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]>;
+}>;
+export type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Source<Uint8Array>>, context: ServerContext) => Promise<void>;
 export interface Handler {
     getServiceID(): string;
     getMethodIDs(): string[];
@@ -17,4 +25,5 @@ export declare class StaticHandler implements Handler {
     getMethodIDs(): string[];
     lookupMethod(serviceID: string, methodID: string): Promise<InvokeFn | null>;
 }
-export declare function createHandler<T extends ServiceMethodDefinitions = ServiceMethodDefinitions>(definition: ServiceDefinition<T>, impl: any, serviceID?: string): Handler;
+export declare function createHandler<T extends ServiceMethodDefinitions = ServiceMethodDefinitions>(definition: ServiceDefinition<T>, impl: HandlerImplementation<T>, serviceID?: string): Handler;
+export {};

package/dist/srpc/index.d.ts

@@ -27,3 +27,5 @@ export { HandleStreamCtr } from './handle-stream-ctr.js';
 export { writeToPushable, buildPushableSink, messagePushable, } 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';

package/dist/srpc/index.js

@@ -18,3 +18,4 @@ export { OpenStreamCtr } from './open-stream-ctr.js';
 export { HandleStreamCtr } from './handle-stream-ctr.js';
 export { writeToPushable, buildPushableSink, messagePushable, } from './pushable.js';
 export { Watchdog } from './watchdog.js';
+export { createContextKey, serverContextValue, withServerContextValue, } from './server-context.js';

package/dist/srpc/invoker.d.ts

@@ -1,6 +1,7 @@
 import type { MethodDefinition } from './definition.js';
+import type { ServerContext } from './server-context.js';
 import { InvokeFn } from './handler.js';
 import type { MessageType, Message } from '@aptre/protobuf-es-lite';
 import { MethodIdempotency, MethodKind } from '@aptre/protobuf-es-lite';
-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>);
+export type MethodProto<R extends Message<R>, O extends Message<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>);
 export declare function createInvokeFn<R extends Message<R>, O extends Message<O>>(methodInfo: MethodDefinition<MessageType<R>, MessageType<O>, MethodKind, MethodIdempotency | undefined>, methodProto: MethodProto<R, O>): InvokeFn;

package/dist/srpc/invoker.js

@@ -6,7 +6,7 @@ import { MethodKind } from '@aptre/protobuf-es-lite';
 // createInvokeFn builds an InvokeFn from a method definition and a function prototype.
 export function createInvokeFn(methodInfo, methodProto) {
     const requestDecode = buildDecodeMessageTransform(methodInfo.I);
-    return async (dataSource, dataSink, invocation) => {
+    return async (dataSource, dataSink, context) => {
         // responseSink is a Sink for response messages.
         const responseSink = pushable({
             objectMode: true,
@@ -34,7 +34,7 @@ export function createInvokeFn(methodInfo, methodProto) {
         }
         // 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/dist/srpc/packet-codec.test.d.ts

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